CoCalc -- spirv

GitHub Repository: wine-mirror/wine
Path: blob/master/libs/vkd3d/include/private/spirv_grammar.h
⁴³⁹³ views
1
/* This file is automatically generated from version 1.6.4 of the
2
 * machine-readable SPIR-V grammar.
3
 *
4
 * The original source is covered by the following license:
5
 *
6
 * Copyright (c) 2014-2024 The Khronos Group Inc.
7
 *
8
 * Permission is hereby granted, free of charge, to any person obtaining a copy
9
 * of this software and/or associated documentation files (the "Materials"),
10
 * to deal in the Materials without restriction, including without limitation
11
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12
 * and/or sell copies of the Materials, and to permit persons to whom the
13
 * Materials are furnished to do so, subject to the following conditions:
14
 *
15
 * The above copyright notice and this permission notice shall be included in
16
 * all copies or substantial portions of the Materials.
17
 *
18
 * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
19
 * STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
20
 * HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
21
 *
22
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27
 * FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
28
 * IN THE MATERIALS.
29
 */
30

31
enum spirv_parser_operand_category
32
{
33
    SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM,
34
    SPIRV_PARSER_OPERAND_CATEGORY_COMPOSITE,
35
    SPIRV_PARSER_OPERAND_CATEGORY_ID,
36
    SPIRV_PARSER_OPERAND_CATEGORY_LITERAL,
37
    SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM,
38
};
39

40
enum spirv_parser_operand_type
41
{
42
    SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER,
43
    SPIRV_PARSER_OPERAND_TYPE_ADDRESSING_MODEL,
44
    SPIRV_PARSER_OPERAND_TYPE_BUILT_IN,
45
    SPIRV_PARSER_OPERAND_TYPE_CAPABILITY,
46
    SPIRV_PARSER_OPERAND_TYPE_COMPONENT_TYPE,
47
    SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT,
48
    SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS,
49
    SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE,
50
    SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_USE,
51
    SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT,
52
    SPIRV_PARSER_OPERAND_TYPE_DECORATION,
53
    SPIRV_PARSER_OPERAND_TYPE_DIM,
54
    SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODE,
55
    SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODEL,
56
    SPIRV_PARSER_OPERAND_TYPE_FPDENORM_MODE,
57
    SPIRV_PARSER_OPERAND_TYPE_FPENCODING,
58
    SPIRV_PARSER_OPERAND_TYPE_FPFAST_MATH_MODE,
59
    SPIRV_PARSER_OPERAND_TYPE_FPOPERATION_MODE,
60
    SPIRV_PARSER_OPERAND_TYPE_FPROUNDING_MODE,
61
    SPIRV_PARSER_OPERAND_TYPE_FRAGMENT_SHADING_RATE,
62
    SPIRV_PARSER_OPERAND_TYPE_FUNCTION_CONTROL,
63
    SPIRV_PARSER_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
64
    SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION,
65
    SPIRV_PARSER_OPERAND_TYPE_HOST_ACCESS_QUALIFIER,
66
    SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS,
67
    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
68
    SPIRV_PARSER_OPERAND_TYPE_ID_RESULT,
69
    SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE,
70
    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
71
    SPIRV_PARSER_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE,
72
    SPIRV_PARSER_OPERAND_TYPE_IMAGE_CHANNEL_ORDER,
73
    SPIRV_PARSER_OPERAND_TYPE_IMAGE_FORMAT,
74
    SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS,
75
    SPIRV_PARSER_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER,
76
    SPIRV_PARSER_OPERAND_TYPE_KERNEL_ENQUEUE_FLAGS,
77
    SPIRV_PARSER_OPERAND_TYPE_KERNEL_PROFILING_INFO,
78
    SPIRV_PARSER_OPERAND_TYPE_LINKAGE_TYPE,
79
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_CONTEXT_DEPENDENT_NUMBER,
80
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_EXT_INST_INTEGER,
81
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_FLOAT,
82
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
83
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_SPEC_CONSTANT_OP_INTEGER,
84
    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
85
    SPIRV_PARSER_OPERAND_TYPE_LOAD_CACHE_CONTROL,
86
    SPIRV_PARSER_OPERAND_TYPE_LOOP_CONTROL,
87
    SPIRV_PARSER_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS,
88
    SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS,
89
    SPIRV_PARSER_OPERAND_TYPE_MEMORY_MODEL,
90
    SPIRV_PARSER_OPERAND_TYPE_MEMORY_SEMANTICS,
91
    SPIRV_PARSER_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS,
92
    SPIRV_PARSER_OPERAND_TYPE_OVERFLOW_MODES,
93
    SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT,
94
    SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_ID_REF,
95
    SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_LITERAL_INTEGER,
96
    SPIRV_PARSER_OPERAND_TYPE_PAIR_LITERAL_INTEGER_ID_REF,
97
    SPIRV_PARSER_OPERAND_TYPE_QUANTIZATION_MODES,
98
    SPIRV_PARSER_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS,
99
    SPIRV_PARSER_OPERAND_TYPE_RAY_FLAGS,
100
    SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE,
101
    SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE,
102
    SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_INTERSECTION,
103
    SPIRV_PARSER_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE,
104
    SPIRV_PARSER_OPERAND_TYPE_SAMPLER_FILTER_MODE,
105
    SPIRV_PARSER_OPERAND_TYPE_SCOPE,
106
    SPIRV_PARSER_OPERAND_TYPE_SELECTION_CONTROL,
107
    SPIRV_PARSER_OPERAND_TYPE_SOURCE_LANGUAGE,
108
    SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS,
109
    SPIRV_PARSER_OPERAND_TYPE_STORE_CACHE_CONTROL,
110
    SPIRV_PARSER_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS,
111
    SPIRV_PARSER_OPERAND_TYPE_TENSOR_CLAMP_MODE,
112
};
113

114
static const struct spirv_parser_operand_type_info
115
{
116
    const char *name;
117
    enum spirv_parser_operand_category category;
118
    size_t enumerant_count;
119
    const struct spirv_parser_enumerant
120
    {
121
        uint32_t value;
122
        const char *name;
123
        size_t parameter_count;
124
        enum spirv_parser_operand_type *parameters;
125
    } *enumerants;
126
}
127
spirv_parser_operand_type_info[] =
128
{
129
    [SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER] =
130
    {
131
        "AccessQualifier", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 3,
132
        (struct spirv_parser_enumerant[])
133
        {
134
            {0, "ReadOnly"},
135
            {0x1, "WriteOnly"},
136
            {0x2, "ReadWrite"},
137
        }
138
    },
139
    [SPIRV_PARSER_OPERAND_TYPE_ADDRESSING_MODEL] =
140
    {
141
        "AddressingModel", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
142
        (struct spirv_parser_enumerant[])
143
        {
144
            {0, "Logical"},
145
            {0x1, "Physical32"},
146
            {0x2, "Physical64"},
147
            {0x14e4, "PhysicalStorageBuffer64"},
148
        }
149
    },
150
    [SPIRV_PARSER_OPERAND_TYPE_BUILT_IN] =
151
    {
152
        "BuiltIn", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 126,
153
        (struct spirv_parser_enumerant[])
154
        {
155
            {0, "Position"},
156
            {0x1, "PointSize"},
157
            {0x3, "ClipDistance"},
158
            {0x4, "CullDistance"},
159
            {0x5, "VertexId"},
160
            {0x6, "InstanceId"},
161
            {0x7, "PrimitiveId"},
162
            {0x8, "InvocationId"},
163
            {0x9, "Layer"},
164
            {0xa, "ViewportIndex"},
165
            {0xb, "TessLevelOuter"},
166
            {0xc, "TessLevelInner"},
167
            {0xd, "TessCoord"},
168
            {0xe, "PatchVertices"},
169
            {0xf, "FragCoord"},
170
            {0x10, "PointCoord"},
171
            {0x11, "FrontFacing"},
172
            {0x12, "SampleId"},
173
            {0x13, "SamplePosition"},
174
            {0x14, "SampleMask"},
175
            {0x16, "FragDepth"},
176
            {0x17, "HelperInvocation"},
177
            {0x18, "NumWorkgroups"},
178
            {0x19, "WorkgroupSize"},
179
            {0x1a, "WorkgroupId"},
180
            {0x1b, "LocalInvocationId"},
181
            {0x1c, "GlobalInvocationId"},
182
            {0x1d, "LocalInvocationIndex"},
183
            {0x1e, "WorkDim"},
184
            {0x1f, "GlobalSize"},
185
            {0x20, "EnqueuedWorkgroupSize"},
186
            {0x21, "GlobalOffset"},
187
            {0x22, "GlobalLinearId"},
188
            {0x24, "SubgroupSize"},
189
            {0x25, "SubgroupMaxSize"},
190
            {0x26, "NumSubgroups"},
191
            {0x27, "NumEnqueuedSubgroups"},
192
            {0x28, "SubgroupId"},
193
            {0x29, "SubgroupLocalInvocationId"},
194
            {0x2a, "VertexIndex"},
195
            {0x2b, "InstanceIndex"},
196
            {0x1040, "CoreIDARM"},
197
            {0x1041, "CoreCountARM"},
198
            {0x1042, "CoreMaxIDARM"},
199
            {0x1043, "WarpIDARM"},
200
            {0x1044, "WarpMaxIDARM"},
201
            {0x1140, "SubgroupEqMask"},
202
            {0x1141, "SubgroupGeMask"},
203
            {0x1142, "SubgroupGtMask"},
204
            {0x1143, "SubgroupLeMask"},
205
            {0x1144, "SubgroupLtMask"},
206
            {0x1148, "BaseVertex"},
207
            {0x1149, "BaseInstance"},
208
            {0x114a, "DrawIndex"},
209
            {0x1150, "PrimitiveShadingRateKHR"},
210
            {0x1156, "DeviceIndex"},
211
            {0x1158, "ViewIndex"},
212
            {0x115c, "ShadingRateKHR"},
213
            {0x118c, "TileOffsetQCOM"},
214
            {0x118d, "TileDimensionQCOM"},
215
            {0x118e, "TileApronSizeQCOM"},
216
            {0x1380, "BaryCoordNoPerspAMD"},
217
            {0x1381, "BaryCoordNoPerspCentroidAMD"},
218
            {0x1382, "BaryCoordNoPerspSampleAMD"},
219
            {0x1383, "BaryCoordSmoothAMD"},
220
            {0x1384, "BaryCoordSmoothCentroidAMD"},
221
            {0x1385, "BaryCoordSmoothSampleAMD"},
222
            {0x1386, "BaryCoordPullModelAMD"},
223
            {0x1396, "FragStencilRefEXT"},
224
            {0x139d, "RemainingRecursionLevelsAMDX"},
225
            {0x13d1, "ShaderIndexAMDX"},
226
            {0x1485, "ViewportMaskNV"},
227
            {0x1489, "SecondaryPositionNV"},
228
            {0x148a, "SecondaryViewportMaskNV"},
229
            {0x148d, "PositionPerViewNV"},
230
            {0x148e, "ViewportMaskPerViewNV"},
231
            {0x1490, "FullyCoveredEXT"},
232
            {0x149a, "TaskCountNV"},
233
            {0x149b, "PrimitiveCountNV"},
234
            {0x149c, "PrimitiveIndicesNV"},
235
            {0x149d, "ClipDistancePerViewNV"},
236
            {0x149e, "CullDistancePerViewNV"},
237
            {0x149f, "LayerPerViewNV"},
238
            {0x14a0, "MeshViewCountNV"},
239
            {0x14a1, "MeshViewIndicesNV"},
240
            {0x14a6, "BaryCoordKHR"},
241
            {0x14a7, "BaryCoordNoPerspKHR"},
242
            {0x14ac, "FragSizeEXT"},
243
            {0x14ad, "FragInvocationCountEXT"},
244
            {0x14ae, "PrimitivePointIndicesEXT"},
245
            {0x14af, "PrimitiveLineIndicesEXT"},
246
            {0x14b0, "PrimitiveTriangleIndicesEXT"},
247
            {0x14b3, "CullPrimitiveEXT"},
248
            {0x14c7, "LaunchIdKHR"},
249
            {0x14c8, "LaunchSizeKHR"},
250
            {0x14c9, "WorldRayOriginKHR"},
251
            {0x14ca, "WorldRayDirectionKHR"},
252
            {0x14cb, "ObjectRayOriginKHR"},
253
            {0x14cc, "ObjectRayDirectionKHR"},
254
            {0x14cd, "RayTminKHR"},
255
            {0x14ce, "RayTmaxKHR"},
256
            {0x14cf, "InstanceCustomIndexKHR"},
257
            {0x14d2, "ObjectToWorldKHR"},
258
            {0x14d3, "WorldToObjectKHR"},
259
            {0x14d4, "HitTNV"},
260
            {0x14d5, "HitKindKHR"},
261
            {0x14d6, "CurrentRayTimeNV"},
262
            {0x14d7, "HitTriangleVertexPositionsKHR"},
263
            {0x14d9, "HitMicroTriangleVertexPositionsNV"},
264
            {0x14e0, "HitMicroTriangleVertexBarycentricsNV"},
265
            {0x14e7, "IncomingRayFlagsKHR"},
266
            {0x14e8, "RayGeometryIndexKHR"},
267
            {0x14ef, "HitIsSphereNV"},
268
            {0x14f0, "HitIsLSSNV"},
269
            {0x14f1, "HitSpherePositionNV"},
270
            {0x14fe, "WarpsPerSMNV"},
271
            {0x14ff, "SMCountNV"},
272
            {0x1500, "WarpIDNV"},
273
            {0x1501, "SMIDNV"},
274
            {0x1514, "HitLSSPositionsNV"},
275
            {0x151d, "HitKindFrontFacingMicroTriangleNV"},
276
            {0x151e, "HitKindBackFacingMicroTriangleNV"},
277
            {0x152c, "HitSphereRadiusNV"},
278
            {0x152d, "HitLSSRadiiNV"},
279
            {0x153c, "ClusterIDNV"},
280
            {0x1785, "CullMaskKHR"},
281
        }
282
    },
283
    [SPIRV_PARSER_OPERAND_TYPE_CAPABILITY] =
284
    {
285
        "Capability", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 261,
286
        (struct spirv_parser_enumerant[])
287
        {
288
            {0, "Matrix"},
289
            {0x1, "Shader"},
290
            {0x2, "Geometry"},
291
            {0x3, "Tessellation"},
292
            {0x4, "Addresses"},
293
            {0x5, "Linkage"},
294
            {0x6, "Kernel"},
295
            {0x7, "Vector16"},
296
            {0x8, "Float16Buffer"},
297
            {0x9, "Float16"},
298
            {0xa, "Float64"},
299
            {0xb, "Int64"},
300
            {0xc, "Int64Atomics"},
301
            {0xd, "ImageBasic"},
302
            {0xe, "ImageReadWrite"},
303
            {0xf, "ImageMipmap"},
304
            {0x11, "Pipes"},
305
            {0x12, "Groups"},
306
            {0x13, "DeviceEnqueue"},
307
            {0x14, "LiteralSampler"},
308
            {0x15, "AtomicStorage"},
309
            {0x16, "Int16"},
310
            {0x17, "TessellationPointSize"},
311
            {0x18, "GeometryPointSize"},
312
            {0x19, "ImageGatherExtended"},
313
            {0x1b, "StorageImageMultisample"},
314
            {0x1c, "UniformBufferArrayDynamicIndexing"},
315
            {0x1d, "SampledImageArrayDynamicIndexing"},
316
            {0x1e, "StorageBufferArrayDynamicIndexing"},
317
            {0x1f, "StorageImageArrayDynamicIndexing"},
318
            {0x20, "ClipDistance"},
319
            {0x21, "CullDistance"},
320
            {0x22, "ImageCubeArray"},
321
            {0x23, "SampleRateShading"},
322
            {0x24, "ImageRect"},
323
            {0x25, "SampledRect"},
324
            {0x26, "GenericPointer"},
325
            {0x27, "Int8"},
326
            {0x28, "InputAttachment"},
327
            {0x29, "SparseResidency"},
328
            {0x2a, "MinLod"},
329
            {0x2b, "Sampled1D"},
330
            {0x2c, "Image1D"},
331
            {0x2d, "SampledCubeArray"},
332
            {0x2e, "SampledBuffer"},
333
            {0x2f, "ImageBuffer"},
334
            {0x30, "ImageMSArray"},
335
            {0x31, "StorageImageExtendedFormats"},
336
            {0x32, "ImageQuery"},
337
            {0x33, "DerivativeControl"},
338
            {0x34, "InterpolationFunction"},
339
            {0x35, "TransformFeedback"},
340
            {0x36, "GeometryStreams"},
341
            {0x37, "StorageImageReadWithoutFormat"},
342
            {0x38, "StorageImageWriteWithoutFormat"},
343
            {0x39, "MultiViewport"},
344
            {0x3a, "SubgroupDispatch"},
345
            {0x3b, "NamedBarrier"},
346
            {0x3c, "PipeStorage"},
347
            {0x3d, "GroupNonUniform"},
348
            {0x3e, "GroupNonUniformVote"},
349
            {0x3f, "GroupNonUniformArithmetic"},
350
            {0x40, "GroupNonUniformBallot"},
351
            {0x41, "GroupNonUniformShuffle"},
352
            {0x42, "GroupNonUniformShuffleRelative"},
353
            {0x43, "GroupNonUniformClustered"},
354
            {0x44, "GroupNonUniformQuad"},
355
            {0x45, "ShaderLayer"},
356
            {0x46, "ShaderViewportIndex"},
357
            {0x47, "UniformDecoration"},
358
            {0x1045, "CoreBuiltinsARM"},
359
            {0x1046, "TileImageColorReadAccessEXT"},
360
            {0x1047, "TileImageDepthReadAccessEXT"},
361
            {0x1048, "TileImageStencilReadAccessEXT"},
362
            {0x1069, "CooperativeMatrixLayoutsARM"},
363
            {0x1146, "FragmentShadingRateKHR"},
364
            {0x1147, "SubgroupBallotKHR"},
365
            {0x114b, "DrawParameters"},
366
            {0x114c, "WorkgroupMemoryExplicitLayoutKHR"},
367
            {0x114d, "WorkgroupMemoryExplicitLayout8BitAccessKHR"},
368
            {0x114e, "WorkgroupMemoryExplicitLayout16BitAccessKHR"},
369
            {0x114f, "SubgroupVoteKHR"},
370
            {0x1151, "StorageBuffer16BitAccess"},
371
            {0x1152, "UniformAndStorageBuffer16BitAccess"},
372
            {0x1153, "StoragePushConstant16"},
373
            {0x1154, "StorageInputOutput16"},
374
            {0x1155, "DeviceGroup"},
375
            {0x1157, "MultiView"},
376
            {0x1159, "VariablePointersStorageBuffer"},
377
            {0x115a, "VariablePointers"},
378
            {0x115d, "AtomicStorageOps"},
379
            {0x115f, "SampleMaskPostDepthCoverage"},
380
            {0x1160, "StorageBuffer8BitAccess"},
381
            {0x1161, "UniformAndStorageBuffer8BitAccess"},
382
            {0x1162, "StoragePushConstant8"},
383
            {0x1170, "DenormPreserve"},
384
            {0x1171, "DenormFlushToZero"},
385
            {0x1172, "SignedZeroInfNanPreserve"},
386
            {0x1173, "RoundingModeRTE"},
387
            {0x1174, "RoundingModeRTZ"},
388
            {0x1177, "RayQueryProvisionalKHR"},
389
            {0x1178, "RayQueryKHR"},
390
            {0x1179, "UntypedPointersKHR"},
391
            {0x117e, "RayTraversalPrimitiveCullingKHR"},
392
            {0x117f, "RayTracingKHR"},
393
            {0x1184, "TextureSampleWeightedQCOM"},
394
            {0x1185, "TextureBoxFilterQCOM"},
395
            {0x1186, "TextureBlockMatchQCOM"},
396
            {0x118f, "TileShadingQCOM"},
397
            {0x1192, "TextureBlockMatch2QCOM"},
398
            {0x1390, "Float16ImageAMD"},
399
            {0x1391, "ImageGatherBiasLodAMD"},
400
            {0x1392, "FragmentMaskAMD"},
401
            {0x1395, "StencilExportEXT"},
402
            {0x1397, "ImageReadWriteLodAMD"},
403
            {0x1398, "Int64ImageEXT"},
404
            {0x13bf, "ShaderClockKHR"},
405
            {0x13cb, "ShaderEnqueueAMDX"},
406
            {0x13df, "QuadControlKHR"},
407
            {0x13fc, "BFloat16TypeKHR"},
408
            {0x13fd, "BFloat16DotProductKHR"},
409
            {0x13fe, "BFloat16CooperativeMatrixKHR"},
410
            {0x1481, "SampleMaskOverrideCoverageNV"},
411
            {0x1483, "GeometryShaderPassthroughNV"},
412
            {0x1486, "ShaderViewportIndexLayerEXT"},
413
            {0x1487, "ShaderViewportMaskNV"},
414
            {0x148b, "ShaderStereoViewNV"},
415
            {0x148c, "PerViewAttributesNV"},
416
            {0x1491, "FragmentFullyCoveredEXT"},
417
            {0x1492, "MeshShadingNV"},
418
            {0x14a2, "ImageFootprintNV"},
419
            {0x14a3, "MeshShadingEXT"},
420
            {0x14a4, "FragmentBarycentricKHR"},
421
            {0x14a8, "ComputeDerivativeGroupQuadsKHR"},
422
            {0x14ab, "FragmentDensityEXT"},
423
            {0x14b1, "GroupNonUniformPartitionedNV"},
424
            {0x14b5, "ShaderNonUniform"},
425
            {0x14b6, "RuntimeDescriptorArray"},
426
            {0x14b7, "InputAttachmentArrayDynamicIndexing"},
427
            {0x14b8, "UniformTexelBufferArrayDynamicIndexing"},
428
            {0x14b9, "StorageTexelBufferArrayDynamicIndexing"},
429
            {0x14ba, "UniformBufferArrayNonUniformIndexing"},
430
            {0x14bb, "SampledImageArrayNonUniformIndexing"},
431
            {0x14bc, "StorageBufferArrayNonUniformIndexing"},
432
            {0x14bd, "StorageImageArrayNonUniformIndexing"},
433
            {0x14be, "InputAttachmentArrayNonUniformIndexing"},
434
            {0x14bf, "UniformTexelBufferArrayNonUniformIndexing"},
435
            {0x14c0, "StorageTexelBufferArrayNonUniformIndexing"},
436
            {0x14d8, "RayTracingPositionFetchKHR"},
437
            {0x14dc, "RayTracingNV"},
438
            {0x14dd, "RayTracingMotionBlurNV"},
439
            {0x14e1, "VulkanMemoryModel"},
440
            {0x14e2, "VulkanMemoryModelDeviceScope"},
441
            {0x14e3, "PhysicalStorageBufferAddresses"},
442
            {0x14e6, "ComputeDerivativeGroupLinearKHR"},
443
            {0x14e9, "RayTracingProvisionalKHR"},
444
            {0x14ed, "CooperativeMatrixNV"},
445
            {0x14f3, "FragmentShaderSampleInterlockEXT"},
446
            {0x14fc, "FragmentShaderShadingRateInterlockEXT"},
447
            {0x14fd, "ShaderSMBuiltinsNV"},
448
            {0x1502, "FragmentShaderPixelInterlockEXT"},
449
            {0x1503, "DemoteToHelperInvocation"},
450
            {0x1504, "DisplacementMicromapNV"},
451
            {0x1505, "RayTracingOpacityMicromapEXT"},
452
            {0x1507, "ShaderInvocationReorderNV"},
453
            {0x150e, "BindlessTextureNV"},
454
            {0x150f, "RayQueryPositionFetchKHR"},
455
            {0x1512, "CooperativeVectorNV"},
456
            {0x151c, "AtomicFloat16VectorNV"},
457
            {0x1521, "RayTracingDisplacementMicromapNV"},
458
            {0x1526, "RawAccessChainsNV"},
459
            {0x152a, "RayTracingSpheresGeometryNV"},
460
            {0x152b, "RayTracingLinearSweptSpheresGeometryNV"},
461
            {0x1536, "CooperativeMatrixReductionsNV"},
462
            {0x1537, "CooperativeMatrixConversionsNV"},
463
            {0x1538, "CooperativeMatrixPerElementOperationsNV"},
464
            {0x1539, "CooperativeMatrixTensorAddressingNV"},
465
            {0x153a, "CooperativeMatrixBlockLoadsNV"},
466
            {0x153b, "CooperativeVectorTrainingNV"},
467
            {0x153d, "RayTracingClusterAccelerationStructureNV"},
468
            {0x153f, "TensorAddressingNV"},
469
            {0x15c0, "SubgroupShuffleINTEL"},
470
            {0x15c1, "SubgroupBufferBlockIOINTEL"},
471
            {0x15c2, "SubgroupImageBlockIOINTEL"},
472
            {0x15cb, "SubgroupImageMediaBlockIOINTEL"},
473
            {0x15ce, "RoundToInfinityINTEL"},
474
            {0x15cf, "FloatingPointModeINTEL"},
475
            {0x15d0, "IntegerFunctions2INTEL"},
476
            {0x15e3, "FunctionPointersINTEL"},
477
            {0x15e4, "IndirectReferencesINTEL"},
478
            {0x15e6, "AsmINTEL"},
479
            {0x15ec, "AtomicFloat32MinMaxEXT"},
480
            {0x15ed, "AtomicFloat64MinMaxEXT"},
481
            {0x15f0, "AtomicFloat16MinMaxEXT"},
482
            {0x15f1, "VectorComputeINTEL"},
483
            {0x15f3, "VectorAnyINTEL"},
484
            {0x15fd, "ExpectAssumeKHR"},
485
            {0x1640, "SubgroupAvcMotionEstimationINTEL"},
486
            {0x1641, "SubgroupAvcMotionEstimationIntraINTEL"},
487
            {0x1642, "SubgroupAvcMotionEstimationChromaINTEL"},
488
            {0x16b9, "VariableLengthArrayINTEL"},
489
            {0x16bd, "FunctionFloatControlINTEL"},
490
            {0x16c0, "FPGAMemoryAttributesINTEL"},
491
            {0x16cd, "FPFastMathModeINTEL"},
492
            {0x16d4, "ArbitraryPrecisionIntegersINTEL"},
493
            {0x16d5, "ArbitraryPrecisionFloatingPointINTEL"},
494
            {0x16fe, "UnstructuredLoopControlsINTEL"},
495
            {0x1700, "FPGALoopControlsINTEL"},
496
            {0x1704, "KernelAttributesINTEL"},
497
            {0x1709, "FPGAKernelAttributesINTEL"},
498
            {0x170a, "FPGAMemoryAccessesINTEL"},
499
            {0x1710, "FPGAClusterAttributesINTEL"},
500
            {0x1712, "LoopFuseINTEL"},
501
            {0x1714, "FPGADSPControlINTEL"},
502
            {0x1716, "MemoryAccessAliasingINTEL"},
503
            {0x171c, "FPGAInvocationPipeliningAttributesINTEL"},
504
            {0x1720, "FPGABufferLocationINTEL"},
505
            {0x1722, "ArbitraryPrecisionFixedPointINTEL"},
506
            {0x172f, "USMStorageClassesINTEL"},
507
            {0x1733, "RuntimeAlignedAttributeINTEL"},
508
            {0x1737, "IOPipesINTEL"},
509
            {0x1739, "BlockingPipesINTEL"},
510
            {0x173c, "FPGARegINTEL"},
511
            {0x1780, "DotProductInputAll"},
512
            {0x1781, "DotProductInput4x8Bit"},
513
            {0x1782, "DotProductInput4x8BitPacked"},
514
            {0x1783, "DotProduct"},
515
            {0x1784, "RayCullMaskKHR"},
516
            {0x1786, "CooperativeMatrixKHR"},
517
            {0x1788, "ReplicatedCompositesEXT"},
518
            {0x1789, "BitInstructions"},
519
            {0x178a, "GroupNonUniformRotateKHR"},
520
            {0x178d, "FloatControls2"},
521
            {0x1791, "AtomicFloat32AddEXT"},
522
            {0x1792, "AtomicFloat64AddEXT"},
523
            {0x17c9, "LongCompositesINTEL"},
524
            {0x17ce, "OptNoneEXT"},
525
            {0x17cf, "AtomicFloat16AddEXT"},
526
            {0x17e2, "DebugInfoModuleINTEL"},
527
            {0x17e3, "BFloat16ConversionINTEL"},
528
            {0x17fd, "SplitBarrierINTEL"},
529
            {0x1800, "ArithmeticFenceEXT"},
530
            {0x1806, "FPGAClusterAttributesV2INTEL"},
531
            {0x1811, "FPGAKernelAttributesv2INTEL"},
532
            {0x1812, "TaskSequenceINTEL"},
533
            {0x1819, "FPMaxErrorINTEL"},
534
            {0x181b, "FPGALatencyControlINTEL"},
535
            {0x181e, "FPGAArgumentInterfacesINTEL"},
536
            {0x182b, "GlobalVariableHostAccessINTEL"},
537
            {0x182d, "GlobalVariableFPGADecorationsINTEL"},
538
            {0x184c, "SubgroupBufferPrefetchINTEL"},
539
            {0x1854, "Subgroup2DBlockIOINTEL"},
540
            {0x1855, "Subgroup2DBlockTransformINTEL"},
541
            {0x1856, "Subgroup2DBlockTransposeINTEL"},
542
            {0x185c, "SubgroupMatrixMultiplyAccumulateINTEL"},
543
            {0x1861, "TernaryBitwiseFunctionINTEL"},
544
            {0x1900, "GroupUniformArithmeticKHR"},
545
            {0x1919, "TensorFloat32RoundingINTEL"},
546
            {0x191b, "MaskedGatherScatterINTEL"},
547
            {0x1929, "CacheControlsINTEL"},
548
            {0x193c, "RegisterLimitsINTEL"},
549
        }
550
    },
551
    [SPIRV_PARSER_OPERAND_TYPE_COMPONENT_TYPE] =
552
    {
553
        "ComponentType", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 15,
554
        (struct spirv_parser_enumerant[])
555
        {
556
            {0, "Float16NV"},
557
            {0x1, "Float32NV"},
558
            {0x2, "Float64NV"},
559
            {0x3, "SignedInt8NV"},
560
            {0x4, "SignedInt16NV"},
561
            {0x5, "SignedInt32NV"},
562
            {0x6, "SignedInt64NV"},
563
            {0x7, "UnsignedInt8NV"},
564
            {0x8, "UnsignedInt16NV"},
565
            {0x9, "UnsignedInt32NV"},
566
            {0xa, "UnsignedInt64NV"},
567
            {0x3ba247f8, "SignedInt8PackedNV"},
568
            {0x3ba247f9, "UnsignedInt8PackedNV"},
569
            {0x3ba247fa, "FloatE4M3NV"},
570
            {0x3ba247fb, "FloatE5M2NV"},
571
        }
572
    },
573
    [SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT] =
574
    {
575
        "CooperativeMatrixLayout", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
576
        (struct spirv_parser_enumerant[])
577
        {
578
            {0, "RowMajorKHR"},
579
            {0x1, "ColumnMajorKHR"},
580
            {0x106a, "RowBlockedInterleavedARM"},
581
            {0x106b, "ColumnBlockedInterleavedARM"},
582
        }
583
    },
584
    [SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS] =
585
    {
586
        "CooperativeMatrixOperands", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 6,
587
        (struct spirv_parser_enumerant[])
588
        {
589
            {0, "NoneKHR"},
590
            {0x1, "MatrixASignedComponentsKHR"},
591
            {0x2, "MatrixBSignedComponentsKHR"},
592
            {0x4, "MatrixCSignedComponentsKHR"},
593
            {0x8, "MatrixResultSignedComponentsKHR"},
594
            {0x10, "SaturatingAccumulationKHR"},
595
        }
596
    },
597
    [SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE] =
598
    {
599
        "CooperativeMatrixReduce", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 3,
600
        (struct spirv_parser_enumerant[])
601
        {
602
            {0x1, "Row"},
603
            {0x2, "Column"},
604
            {0x4, "2x2"},
605
        }
606
    },
607
    [SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_USE] =
608
    {
609
        "CooperativeMatrixUse", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 3,
610
        (struct spirv_parser_enumerant[])
611
        {
612
            {0, "MatrixAKHR"},
613
            {0x1, "MatrixBKHR"},
614
            {0x2, "MatrixAccumulatorKHR"},
615
        }
616
    },
617
    [SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT] =
618
    {
619
        "CooperativeVectorMatrixLayout", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
620
        (struct spirv_parser_enumerant[])
621
        {
622
            {0, "RowMajorNV"},
623
            {0x1, "ColumnMajorNV"},
624
            {0x2, "InferencingOptimalNV"},
625
            {0x3, "TrainingOptimalNV"},
626
        }
627
    },
628
    [SPIRV_PARSER_OPERAND_TYPE_DECORATION] =
629
    {
630
        "Decoration", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 142,
631
        (struct spirv_parser_enumerant[])
632
        {
633
            {0, "RelaxedPrecision"},
634
            {
635
                0x1, "SpecId", 1,
636
                (enum spirv_parser_operand_type[])
637
                {
638
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
639
                }
640
            },
641
            {0x2, "Block"},
642
            {0x3, "BufferBlock"},
643
            {0x4, "RowMajor"},
644
            {0x5, "ColMajor"},
645
            {
646
                0x6, "ArrayStride", 1,
647
                (enum spirv_parser_operand_type[])
648
                {
649
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
650
                }
651
            },
652
            {
653
                0x7, "MatrixStride", 1,
654
                (enum spirv_parser_operand_type[])
655
                {
656
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
657
                }
658
            },
659
            {0x8, "GLSLShared"},
660
            {0x9, "GLSLPacked"},
661
            {0xa, "CPacked"},
662
            {
663
                0xb, "BuiltIn", 1,
664
                (enum spirv_parser_operand_type[])
665
                {
666
                    SPIRV_PARSER_OPERAND_TYPE_BUILT_IN,
667
                }
668
            },
669
            {0xd, "NoPerspective"},
670
            {0xe, "Flat"},
671
            {0xf, "Patch"},
672
            {0x10, "Centroid"},
673
            {0x11, "Sample"},
674
            {0x12, "Invariant"},
675
            {0x13, "Restrict"},
676
            {0x14, "Aliased"},
677
            {0x15, "Volatile"},
678
            {0x16, "Constant"},
679
            {0x17, "Coherent"},
680
            {0x18, "NonWritable"},
681
            {0x19, "NonReadable"},
682
            {0x1a, "Uniform"},
683
            {
684
                0x1b, "UniformId", 1,
685
                (enum spirv_parser_operand_type[])
686
                {
687
                    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
688
                }
689
            },
690
            {0x1c, "SaturatedConversion"},
691
            {
692
                0x1d, "Stream", 1,
693
                (enum spirv_parser_operand_type[])
694
                {
695
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
696
                }
697
            },
698
            {
699
                0x1e, "Location", 1,
700
                (enum spirv_parser_operand_type[])
701
                {
702
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
703
                }
704
            },
705
            {
706
                0x1f, "Component", 1,
707
                (enum spirv_parser_operand_type[])
708
                {
709
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
710
                }
711
            },
712
            {
713
                0x20, "Index", 1,
714
                (enum spirv_parser_operand_type[])
715
                {
716
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
717
                }
718
            },
719
            {
720
                0x21, "Binding", 1,
721
                (enum spirv_parser_operand_type[])
722
                {
723
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
724
                }
725
            },
726
            {
727
                0x22, "DescriptorSet", 1,
728
                (enum spirv_parser_operand_type[])
729
                {
730
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
731
                }
732
            },
733
            {
734
                0x23, "Offset", 1,
735
                (enum spirv_parser_operand_type[])
736
                {
737
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
738
                }
739
            },
740
            {
741
                0x24, "XfbBuffer", 1,
742
                (enum spirv_parser_operand_type[])
743
                {
744
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
745
                }
746
            },
747
            {
748
                0x25, "XfbStride", 1,
749
                (enum spirv_parser_operand_type[])
750
                {
751
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
752
                }
753
            },
754
            {
755
                0x26, "FuncParamAttr", 1,
756
                (enum spirv_parser_operand_type[])
757
                {
758
                    SPIRV_PARSER_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
759
                }
760
            },
761
            {
762
                0x27, "FPRoundingMode", 1,
763
                (enum spirv_parser_operand_type[])
764
                {
765
                    SPIRV_PARSER_OPERAND_TYPE_FPROUNDING_MODE,
766
                }
767
            },
768
            {
769
                0x28, "FPFastMathMode", 1,
770
                (enum spirv_parser_operand_type[])
771
                {
772
                    SPIRV_PARSER_OPERAND_TYPE_FPFAST_MATH_MODE,
773
                }
774
            },
775
            {
776
                0x29, "LinkageAttributes", 2,
777
                (enum spirv_parser_operand_type[])
778
                {
779
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
780
                    SPIRV_PARSER_OPERAND_TYPE_LINKAGE_TYPE,
781
                }
782
            },
783
            {0x2a, "NoContraction"},
784
            {
785
                0x2b, "InputAttachmentIndex", 1,
786
                (enum spirv_parser_operand_type[])
787
                {
788
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
789
                }
790
            },
791
            {
792
                0x2c, "Alignment", 1,
793
                (enum spirv_parser_operand_type[])
794
                {
795
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
796
                }
797
            },
798
            {
799
                0x2d, "MaxByteOffset", 1,
800
                (enum spirv_parser_operand_type[])
801
                {
802
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
803
                }
804
            },
805
            {
806
                0x2e, "AlignmentId", 1,
807
                (enum spirv_parser_operand_type[])
808
                {
809
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
810
                }
811
            },
812
            {
813
                0x2f, "MaxByteOffsetId", 1,
814
                (enum spirv_parser_operand_type[])
815
                {
816
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
817
                }
818
            },
819
            {0x1175, "NoSignedWrap"},
820
            {0x1176, "NoUnsignedWrap"},
821
            {0x1187, "WeightTextureQCOM"},
822
            {0x1188, "BlockMatchTextureQCOM"},
823
            {0x1193, "BlockMatchSamplerQCOM"},
824
            {0x1387, "ExplicitInterpAMD"},
825
            {
826
                0x139b, "NodeSharesPayloadLimitsWithAMDX", 1,
827
                (enum spirv_parser_operand_type[])
828
                {
829
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
830
                }
831
            },
832
            {
833
                0x139c, "NodeMaxPayloadsAMDX", 1,
834
                (enum spirv_parser_operand_type[])
835
                {
836
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
837
                }
838
            },
839
            {0x13d6, "TrackFinishWritingAMDX"},
840
            {
841
                0x13e3, "PayloadNodeNameAMDX", 1,
842
                (enum spirv_parser_operand_type[])
843
                {
844
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
845
                }
846
            },
847
            {
848
                0x13ea, "PayloadNodeBaseIndexAMDX", 1,
849
                (enum spirv_parser_operand_type[])
850
                {
851
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
852
                }
853
            },
854
            {0x13eb, "PayloadNodeSparseArrayAMDX"},
855
            {
856
                0x13ec, "PayloadNodeArraySizeAMDX", 1,
857
                (enum spirv_parser_operand_type[])
858
                {
859
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
860
                }
861
            },
862
            {0x13f1, "PayloadDispatchIndirectAMDX"},
863
            {0x1480, "OverrideCoverageNV"},
864
            {0x1482, "PassthroughNV"},
865
            {0x1484, "ViewportRelativeNV"},
866
            {
867
                0x1488, "SecondaryViewportRelativeNV", 1,
868
                (enum spirv_parser_operand_type[])
869
                {
870
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
871
                }
872
            },
873
            {0x1497, "PerPrimitiveEXT"},
874
            {0x1498, "PerViewNV"},
875
            {0x1499, "PerTaskNV"},
876
            {0x14a5, "PerVertexKHR"},
877
            {0x14b4, "NonUniform"},
878
            {0x14eb, "RestrictPointer"},
879
            {0x14ec, "AliasedPointer"},
880
            {0x150a, "HitObjectShaderRecordBufferNV"},
881
            {0x1516, "BindlessSamplerNV"},
882
            {0x1517, "BindlessImageNV"},
883
            {0x1518, "BoundSamplerNV"},
884
            {0x1519, "BoundImageNV"},
885
            {
886
                0x15df, "SIMTCallINTEL", 1,
887
                (enum spirv_parser_operand_type[])
888
                {
889
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
890
                }
891
            },
892
            {0x15e2, "ReferencedIndirectlyINTEL"},
893
            {
894
                0x15e7, "ClobberINTEL", 1,
895
                (enum spirv_parser_operand_type[])
896
                {
897
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
898
                }
899
            },
900
            {0x15e8, "SideEffectsINTEL"},
901
            {0x15f8, "VectorComputeVariableINTEL"},
902
            {
903
                0x15f9, "FuncParamIOKindINTEL", 1,
904
                (enum spirv_parser_operand_type[])
905
                {
906
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
907
                }
908
            },
909
            {0x15fa, "VectorComputeFunctionINTEL"},
910
            {0x15fb, "StackCallINTEL"},
911
            {
912
                0x15fc, "GlobalVariableOffsetINTEL", 1,
913
                (enum spirv_parser_operand_type[])
914
                {
915
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
916
                }
917
            },
918
            {
919
                0x1602, "CounterBuffer", 1,
920
                (enum spirv_parser_operand_type[])
921
                {
922
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
923
                }
924
            },
925
            {
926
                0x1603, "UserSemantic", 1,
927
                (enum spirv_parser_operand_type[])
928
                {
929
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
930
                }
931
            },
932
            {
933
                0x1604, "UserTypeGOOGLE", 1,
934
                (enum spirv_parser_operand_type[])
935
                {
936
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
937
                }
938
            },
939
            {
940
                0x16be, "FunctionRoundingModeINTEL", 2,
941
                (enum spirv_parser_operand_type[])
942
                {
943
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
944
                    SPIRV_PARSER_OPERAND_TYPE_FPROUNDING_MODE,
945
                }
946
            },
947
            {
948
                0x16bf, "FunctionDenormModeINTEL", 2,
949
                (enum spirv_parser_operand_type[])
950
                {
951
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
952
                    SPIRV_PARSER_OPERAND_TYPE_FPDENORM_MODE,
953
                }
954
            },
955
            {0x16c1, "RegisterINTEL"},
956
            {
957
                0x16c2, "MemoryINTEL", 1,
958
                (enum spirv_parser_operand_type[])
959
                {
960
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
961
                }
962
            },
963
            {
964
                0x16c3, "NumbanksINTEL", 1,
965
                (enum spirv_parser_operand_type[])
966
                {
967
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
968
                }
969
            },
970
            {
971
                0x16c4, "BankwidthINTEL", 1,
972
                (enum spirv_parser_operand_type[])
973
                {
974
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
975
                }
976
            },
977
            {
978
                0x16c5, "MaxPrivateCopiesINTEL", 1,
979
                (enum spirv_parser_operand_type[])
980
                {
981
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
982
                }
983
            },
984
            {0x16c6, "SinglepumpINTEL"},
985
            {0x16c7, "DoublepumpINTEL"},
986
            {
987
                0x16c8, "MaxReplicatesINTEL", 1,
988
                (enum spirv_parser_operand_type[])
989
                {
990
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
991
                }
992
            },
993
            {0x16c9, "SimpleDualPortINTEL"},
994
            {
995
                0x16ca, "MergeINTEL", 2,
996
                (enum spirv_parser_operand_type[])
997
                {
998
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
999
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
1000
                }
1001
            },
1002
            {
1003
                0x16cb, "BankBitsINTEL", 1,
1004
                (enum spirv_parser_operand_type[])
1005
                {
1006
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1007
                }
1008
            },
1009
            {
1010
                0x16cc, "ForcePow2DepthINTEL", 1,
1011
                (enum spirv_parser_operand_type[])
1012
                {
1013
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1014
                }
1015
            },
1016
            {
1017
                0x16fb, "StridesizeINTEL", 1,
1018
                (enum spirv_parser_operand_type[])
1019
                {
1020
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1021
                }
1022
            },
1023
            {
1024
                0x16fc, "WordsizeINTEL", 1,
1025
                (enum spirv_parser_operand_type[])
1026
                {
1027
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1028
                }
1029
            },
1030
            {0x16fd, "TrueDualPortINTEL"},
1031
            {0x170b, "BurstCoalesceINTEL"},
1032
            {
1033
                0x170c, "CacheSizeINTEL", 1,
1034
                (enum spirv_parser_operand_type[])
1035
                {
1036
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1037
                }
1038
            },
1039
            {0x170d, "DontStaticallyCoalesceINTEL"},
1040
            {
1041
                0x170e, "PrefetchINTEL", 1,
1042
                (enum spirv_parser_operand_type[])
1043
                {
1044
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1045
                }
1046
            },
1047
            {0x1711, "StallEnableINTEL"},
1048
            {0x1713, "FuseLoopsInFunctionINTEL"},
1049
            {
1050
                0x1715, "MathOpDSPModeINTEL", 2,
1051
                (enum spirv_parser_operand_type[])
1052
                {
1053
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1054
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1055
                }
1056
            },
1057
            {
1058
                0x171a, "AliasScopeINTEL", 1,
1059
                (enum spirv_parser_operand_type[])
1060
                {
1061
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1062
                }
1063
            },
1064
            {
1065
                0x171b, "NoAliasINTEL", 1,
1066
                (enum spirv_parser_operand_type[])
1067
                {
1068
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1069
                }
1070
            },
1071
            {
1072
                0x171d, "InitiationIntervalINTEL", 1,
1073
                (enum spirv_parser_operand_type[])
1074
                {
1075
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1076
                }
1077
            },
1078
            {
1079
                0x171e, "MaxConcurrencyINTEL", 1,
1080
                (enum spirv_parser_operand_type[])
1081
                {
1082
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1083
                }
1084
            },
1085
            {
1086
                0x171f, "PipelineEnableINTEL", 1,
1087
                (enum spirv_parser_operand_type[])
1088
                {
1089
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1090
                }
1091
            },
1092
            {
1093
                0x1721, "BufferLocationINTEL", 1,
1094
                (enum spirv_parser_operand_type[])
1095
                {
1096
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1097
                }
1098
            },
1099
            {
1100
                0x1738, "IOPipeStorageINTEL", 1,
1101
                (enum spirv_parser_operand_type[])
1102
                {
1103
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1104
                }
1105
            },
1106
            {
1107
                0x17c0, "FunctionFloatingPointModeINTEL", 2,
1108
                (enum spirv_parser_operand_type[])
1109
                {
1110
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1111
                    SPIRV_PARSER_OPERAND_TYPE_FPOPERATION_MODE,
1112
                }
1113
            },
1114
            {0x17c5, "SingleElementVectorINTEL"},
1115
            {0x17c7, "VectorComputeCallableFunctionINTEL"},
1116
            {0x17fc, "MediaBlockIOINTEL"},
1117
            {0x1807, "StallFreeINTEL"},
1118
            {
1119
                0x181a, "FPMaxErrorDecorationINTEL", 1,
1120
                (enum spirv_parser_operand_type[])
1121
                {
1122
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_FLOAT,
1123
                }
1124
            },
1125
            {
1126
                0x181c, "LatencyControlLabelINTEL", 1,
1127
                (enum spirv_parser_operand_type[])
1128
                {
1129
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1130
                }
1131
            },
1132
            {
1133
                0x181d, "LatencyControlConstraintINTEL", 3,
1134
                (enum spirv_parser_operand_type[])
1135
                {
1136
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1137
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1138
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1139
                }
1140
            },
1141
            {0x181f, "ConduitKernelArgumentINTEL"},
1142
            {0x1820, "RegisterMapKernelArgumentINTEL"},
1143
            {
1144
                0x1821, "MMHostInterfaceAddressWidthINTEL", 1,
1145
                (enum spirv_parser_operand_type[])
1146
                {
1147
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1148
                }
1149
            },
1150
            {
1151
                0x1822, "MMHostInterfaceDataWidthINTEL", 1,
1152
                (enum spirv_parser_operand_type[])
1153
                {
1154
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1155
                }
1156
            },
1157
            {
1158
                0x1823, "MMHostInterfaceLatencyINTEL", 1,
1159
                (enum spirv_parser_operand_type[])
1160
                {
1161
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1162
                }
1163
            },
1164
            {
1165
                0x1824, "MMHostInterfaceReadWriteModeINTEL", 1,
1166
                (enum spirv_parser_operand_type[])
1167
                {
1168
                    SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER,
1169
                }
1170
            },
1171
            {
1172
                0x1825, "MMHostInterfaceMaxBurstINTEL", 1,
1173
                (enum spirv_parser_operand_type[])
1174
                {
1175
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1176
                }
1177
            },
1178
            {
1179
                0x1826, "MMHostInterfaceWaitRequestINTEL", 1,
1180
                (enum spirv_parser_operand_type[])
1181
                {
1182
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1183
                }
1184
            },
1185
            {0x1827, "StableKernelArgumentINTEL"},
1186
            {
1187
                0x182c, "HostAccessINTEL", 2,
1188
                (enum spirv_parser_operand_type[])
1189
                {
1190
                    SPIRV_PARSER_OPERAND_TYPE_HOST_ACCESS_QUALIFIER,
1191
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING,
1192
                }
1193
            },
1194
            {
1195
                0x182e, "InitModeINTEL", 1,
1196
                (enum spirv_parser_operand_type[])
1197
                {
1198
                    SPIRV_PARSER_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER,
1199
                }
1200
            },
1201
            {
1202
                0x182f, "ImplementInRegisterMapINTEL", 1,
1203
                (enum spirv_parser_operand_type[])
1204
                {
1205
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1206
                }
1207
            },
1208
            {
1209
                0x192a, "CacheControlLoadINTEL", 2,
1210
                (enum spirv_parser_operand_type[])
1211
                {
1212
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1213
                    SPIRV_PARSER_OPERAND_TYPE_LOAD_CACHE_CONTROL,
1214
                }
1215
            },
1216
            {
1217
                0x192b, "CacheControlStoreINTEL", 2,
1218
                (enum spirv_parser_operand_type[])
1219
                {
1220
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1221
                    SPIRV_PARSER_OPERAND_TYPE_STORE_CACHE_CONTROL,
1222
                }
1223
            },
1224
        }
1225
    },
1226
    [SPIRV_PARSER_OPERAND_TYPE_DIM] =
1227
    {
1228
        "Dim", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 8,
1229
        (struct spirv_parser_enumerant[])
1230
        {
1231
            {0, "1D"},
1232
            {0x1, "2D"},
1233
            {0x2, "3D"},
1234
            {0x3, "Cube"},
1235
            {0x4, "Rect"},
1236
            {0x5, "Buffer"},
1237
            {0x6, "SubpassData"},
1238
            {0x104d, "TileImageDataEXT"},
1239
        }
1240
    },
1241
    [SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODE] =
1242
    {
1243
        "ExecutionMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 96,
1244
        (struct spirv_parser_enumerant[])
1245
        {
1246
            {
1247
                0, "Invocations", 1,
1248
                (enum spirv_parser_operand_type[])
1249
                {
1250
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1251
                }
1252
            },
1253
            {0x1, "SpacingEqual"},
1254
            {0x2, "SpacingFractionalEven"},
1255
            {0x3, "SpacingFractionalOdd"},
1256
            {0x4, "VertexOrderCw"},
1257
            {0x5, "VertexOrderCcw"},
1258
            {0x6, "PixelCenterInteger"},
1259
            {0x7, "OriginUpperLeft"},
1260
            {0x8, "OriginLowerLeft"},
1261
            {0x9, "EarlyFragmentTests"},
1262
            {0xa, "PointMode"},
1263
            {0xb, "Xfb"},
1264
            {0xc, "DepthReplacing"},
1265
            {0xe, "DepthGreater"},
1266
            {0xf, "DepthLess"},
1267
            {0x10, "DepthUnchanged"},
1268
            {
1269
                0x11, "LocalSize", 3,
1270
                (enum spirv_parser_operand_type[])
1271
                {
1272
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1273
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1274
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1275
                }
1276
            },
1277
            {
1278
                0x12, "LocalSizeHint", 3,
1279
                (enum spirv_parser_operand_type[])
1280
                {
1281
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1282
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1283
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1284
                }
1285
            },
1286
            {0x13, "InputPoints"},
1287
            {0x14, "InputLines"},
1288
            {0x15, "InputLinesAdjacency"},
1289
            {0x16, "Triangles"},
1290
            {0x17, "InputTrianglesAdjacency"},
1291
            {0x18, "Quads"},
1292
            {0x19, "Isolines"},
1293
            {
1294
                0x1a, "OutputVertices", 1,
1295
                (enum spirv_parser_operand_type[])
1296
                {
1297
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1298
                }
1299
            },
1300
            {0x1b, "OutputPoints"},
1301
            {0x1c, "OutputLineStrip"},
1302
            {0x1d, "OutputTriangleStrip"},
1303
            {
1304
                0x1e, "VecTypeHint", 1,
1305
                (enum spirv_parser_operand_type[])
1306
                {
1307
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1308
                }
1309
            },
1310
            {0x1f, "ContractionOff"},
1311
            {0x21, "Initializer"},
1312
            {0x22, "Finalizer"},
1313
            {
1314
                0x23, "SubgroupSize", 1,
1315
                (enum spirv_parser_operand_type[])
1316
                {
1317
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1318
                }
1319
            },
1320
            {
1321
                0x24, "SubgroupsPerWorkgroup", 1,
1322
                (enum spirv_parser_operand_type[])
1323
                {
1324
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1325
                }
1326
            },
1327
            {
1328
                0x25, "SubgroupsPerWorkgroupId", 1,
1329
                (enum spirv_parser_operand_type[])
1330
                {
1331
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1332
                }
1333
            },
1334
            {
1335
                0x26, "LocalSizeId", 3,
1336
                (enum spirv_parser_operand_type[])
1337
                {
1338
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1339
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1340
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1341
                }
1342
            },
1343
            {
1344
                0x27, "LocalSizeHintId", 3,
1345
                (enum spirv_parser_operand_type[])
1346
                {
1347
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1348
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1349
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1350
                }
1351
            },
1352
            {0x1049, "NonCoherentColorAttachmentReadEXT"},
1353
            {0x104a, "NonCoherentDepthAttachmentReadEXT"},
1354
            {0x104b, "NonCoherentStencilAttachmentReadEXT"},
1355
            {0x1145, "SubgroupUniformControlFlowKHR"},
1356
            {0x115e, "PostDepthCoverage"},
1357
            {
1358
                0x116b, "DenormPreserve", 1,
1359
                (enum spirv_parser_operand_type[])
1360
                {
1361
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1362
                }
1363
            },
1364
            {
1365
                0x116c, "DenormFlushToZero", 1,
1366
                (enum spirv_parser_operand_type[])
1367
                {
1368
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1369
                }
1370
            },
1371
            {
1372
                0x116d, "SignedZeroInfNanPreserve", 1,
1373
                (enum spirv_parser_operand_type[])
1374
                {
1375
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1376
                }
1377
            },
1378
            {
1379
                0x116e, "RoundingModeRTE", 1,
1380
                (enum spirv_parser_operand_type[])
1381
                {
1382
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1383
                }
1384
            },
1385
            {
1386
                0x116f, "RoundingModeRTZ", 1,
1387
                (enum spirv_parser_operand_type[])
1388
                {
1389
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1390
                }
1391
            },
1392
            {0x1189, "NonCoherentTileAttachmentReadQCOM"},
1393
            {
1394
                0x118a, "TileShadingRateQCOM", 3,
1395
                (enum spirv_parser_operand_type[])
1396
                {
1397
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1398
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1399
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1400
                }
1401
            },
1402
            {0x1399, "EarlyAndLateFragmentTestsAMD"},
1403
            {0x13a3, "StencilRefReplacingEXT"},
1404
            {0x13cd, "CoalescingAMDX"},
1405
            {
1406
                0x13ce, "IsApiEntryAMDX", 1,
1407
                (enum spirv_parser_operand_type[])
1408
                {
1409
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1410
                }
1411
            },
1412
            {
1413
                0x13cf, "MaxNodeRecursionAMDX", 1,
1414
                (enum spirv_parser_operand_type[])
1415
                {
1416
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1417
                }
1418
            },
1419
            {
1420
                0x13d0, "StaticNumWorkgroupsAMDX", 3,
1421
                (enum spirv_parser_operand_type[])
1422
                {
1423
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1424
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1425
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1426
                }
1427
            },
1428
            {
1429
                0x13d1, "ShaderIndexAMDX", 1,
1430
                (enum spirv_parser_operand_type[])
1431
                {
1432
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1433
                }
1434
            },
1435
            {
1436
                0x13d5, "MaxNumWorkgroupsAMDX", 3,
1437
                (enum spirv_parser_operand_type[])
1438
                {
1439
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1440
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1441
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1442
                }
1443
            },
1444
            {0x13d7, "StencilRefUnchangedFrontAMD"},
1445
            {0x13d8, "StencilRefGreaterFrontAMD"},
1446
            {0x13d9, "StencilRefLessFrontAMD"},
1447
            {0x13da, "StencilRefUnchangedBackAMD"},
1448
            {0x13db, "StencilRefGreaterBackAMD"},
1449
            {0x13dc, "StencilRefLessBackAMD"},
1450
            {0x13e0, "QuadDerivativesKHR"},
1451
            {0x13e1, "RequireFullQuadsKHR"},
1452
            {
1453
                0x13ee, "SharesInputWithAMDX", 2,
1454
                (enum spirv_parser_operand_type[])
1455
                {
1456
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1457
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1458
                }
1459
            },
1460
            {0x1495, "OutputLinesEXT"},
1461
            {
1462
                0x1496, "OutputPrimitivesEXT", 1,
1463
                (enum spirv_parser_operand_type[])
1464
                {
1465
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1466
                }
1467
            },
1468
            {0x14a9, "DerivativeGroupQuadsKHR"},
1469
            {0x14aa, "DerivativeGroupLinearKHR"},
1470
            {0x14b2, "OutputTrianglesEXT"},
1471
            {0x14f6, "PixelInterlockOrderedEXT"},
1472
            {0x14f7, "PixelInterlockUnorderedEXT"},
1473
            {0x14f8, "SampleInterlockOrderedEXT"},
1474
            {0x14f9, "SampleInterlockUnorderedEXT"},
1475
            {0x14fa, "ShadingRateInterlockOrderedEXT"},
1476
            {0x14fb, "ShadingRateInterlockUnorderedEXT"},
1477
            {
1478
                0x15f2, "SharedLocalMemorySizeINTEL", 1,
1479
                (enum spirv_parser_operand_type[])
1480
                {
1481
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1482
                }
1483
            },
1484
            {
1485
                0x15f4, "RoundingModeRTPINTEL", 1,
1486
                (enum spirv_parser_operand_type[])
1487
                {
1488
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1489
                }
1490
            },
1491
            {
1492
                0x15f5, "RoundingModeRTNINTEL", 1,
1493
                (enum spirv_parser_operand_type[])
1494
                {
1495
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1496
                }
1497
            },
1498
            {
1499
                0x15f6, "FloatingPointModeALTINTEL", 1,
1500
                (enum spirv_parser_operand_type[])
1501
                {
1502
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1503
                }
1504
            },
1505
            {
1506
                0x15f7, "FloatingPointModeIEEEINTEL", 1,
1507
                (enum spirv_parser_operand_type[])
1508
                {
1509
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1510
                }
1511
            },
1512
            {
1513
                0x1705, "MaxWorkgroupSizeINTEL", 3,
1514
                (enum spirv_parser_operand_type[])
1515
                {
1516
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1517
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1518
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1519
                }
1520
            },
1521
            {
1522
                0x1706, "MaxWorkDimINTEL", 1,
1523
                (enum spirv_parser_operand_type[])
1524
                {
1525
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1526
                }
1527
            },
1528
            {0x1707, "NoGlobalOffsetINTEL"},
1529
            {
1530
                0x1708, "NumSIMDWorkitemsINTEL", 1,
1531
                (enum spirv_parser_operand_type[])
1532
                {
1533
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1534
                }
1535
            },
1536
            {
1537
                0x170f, "SchedulerTargetFmaxMhzINTEL", 1,
1538
                (enum spirv_parser_operand_type[])
1539
                {
1540
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1541
                }
1542
            },
1543
            {0x1787, "MaximallyReconvergesKHR"},
1544
            {
1545
                0x178c, "FPFastMathDefault", 2,
1546
                (enum spirv_parser_operand_type[])
1547
                {
1548
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1549
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1550
                }
1551
            },
1552
            {
1553
                0x180a, "StreamingInterfaceINTEL", 1,
1554
                (enum spirv_parser_operand_type[])
1555
                {
1556
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1557
                }
1558
            },
1559
            {
1560
                0x1810, "RegisterMapInterfaceINTEL", 1,
1561
                (enum spirv_parser_operand_type[])
1562
                {
1563
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1564
                }
1565
            },
1566
            {
1567
                0x1911, "NamedBarrierCountINTEL", 1,
1568
                (enum spirv_parser_operand_type[])
1569
                {
1570
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1571
                }
1572
            },
1573
            {
1574
                0x193d, "MaximumRegistersINTEL", 1,
1575
                (enum spirv_parser_operand_type[])
1576
                {
1577
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
1578
                }
1579
            },
1580
            {
1581
                0x193e, "MaximumRegistersIdINTEL", 1,
1582
                (enum spirv_parser_operand_type[])
1583
                {
1584
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1585
                }
1586
            },
1587
            {
1588
                0x193f, "NamedMaximumRegistersINTEL", 1,
1589
                (enum spirv_parser_operand_type[])
1590
                {
1591
                    SPIRV_PARSER_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS,
1592
                }
1593
            },
1594
        }
1595
    },
1596
    [SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODEL] =
1597
    {
1598
        "ExecutionModel", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 17,
1599
        (struct spirv_parser_enumerant[])
1600
        {
1601
            {0, "Vertex"},
1602
            {0x1, "TessellationControl"},
1603
            {0x2, "TessellationEvaluation"},
1604
            {0x3, "Geometry"},
1605
            {0x4, "Fragment"},
1606
            {0x5, "GLCompute"},
1607
            {0x6, "Kernel"},
1608
            {0x1493, "TaskNV"},
1609
            {0x1494, "MeshNV"},
1610
            {0x14c1, "RayGenerationKHR"},
1611
            {0x14c2, "IntersectionKHR"},
1612
            {0x14c3, "AnyHitKHR"},
1613
            {0x14c4, "ClosestHitKHR"},
1614
            {0x14c5, "MissKHR"},
1615
            {0x14c6, "CallableKHR"},
1616
            {0x14f4, "TaskEXT"},
1617
            {0x14f5, "MeshEXT"},
1618
        }
1619
    },
1620
    [SPIRV_PARSER_OPERAND_TYPE_FPDENORM_MODE] =
1621
    {
1622
        "FPDenormMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
1623
        (struct spirv_parser_enumerant[])
1624
        {
1625
            {0, "Preserve"},
1626
            {0x1, "FlushToZero"},
1627
        }
1628
    },
1629
    [SPIRV_PARSER_OPERAND_TYPE_FPENCODING] =
1630
    {
1631
        "FPEncoding", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 1,
1632
        (struct spirv_parser_enumerant[])
1633
        {
1634
            {0, "BFloat16KHR"},
1635
        }
1636
    },
1637
    [SPIRV_PARSER_OPERAND_TYPE_FPFAST_MATH_MODE] =
1638
    {
1639
        "FPFastMathMode", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 9,
1640
        (struct spirv_parser_enumerant[])
1641
        {
1642
            {0, "None"},
1643
            {0x1, "NotNaN"},
1644
            {0x2, "NotInf"},
1645
            {0x4, "NSZ"},
1646
            {0x8, "AllowRecip"},
1647
            {0x10, "Fast"},
1648
            {0x10000, "AllowContract"},
1649
            {0x20000, "AllowReassoc"},
1650
            {0x40000, "AllowTransform"},
1651
        }
1652
    },
1653
    [SPIRV_PARSER_OPERAND_TYPE_FPOPERATION_MODE] =
1654
    {
1655
        "FPOperationMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
1656
        (struct spirv_parser_enumerant[])
1657
        {
1658
            {0, "IEEE"},
1659
            {0x1, "ALT"},
1660
        }
1661
    },
1662
    [SPIRV_PARSER_OPERAND_TYPE_FPROUNDING_MODE] =
1663
    {
1664
        "FPRoundingMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
1665
        (struct spirv_parser_enumerant[])
1666
        {
1667
            {0, "RTE"},
1668
            {0x1, "RTZ"},
1669
            {0x2, "RTP"},
1670
            {0x3, "RTN"},
1671
        }
1672
    },
1673
    [SPIRV_PARSER_OPERAND_TYPE_FRAGMENT_SHADING_RATE] =
1674
    {
1675
        "FragmentShadingRate", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 4,
1676
        (struct spirv_parser_enumerant[])
1677
        {
1678
            {0x1, "Vertical2Pixels"},
1679
            {0x2, "Vertical4Pixels"},
1680
            {0x4, "Horizontal2Pixels"},
1681
            {0x8, "Horizontal4Pixels"},
1682
        }
1683
    },
1684
    [SPIRV_PARSER_OPERAND_TYPE_FUNCTION_CONTROL] =
1685
    {
1686
        "FunctionControl", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 6,
1687
        (struct spirv_parser_enumerant[])
1688
        {
1689
            {0, "None"},
1690
            {0x1, "Inline"},
1691
            {0x2, "DontInline"},
1692
            {0x4, "Pure"},
1693
            {0x8, "Const"},
1694
            {0x10000, "OptNoneEXT"},
1695
        }
1696
    },
1697
    [SPIRV_PARSER_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE] =
1698
    {
1699
        "FunctionParameterAttribute", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 9,
1700
        (struct spirv_parser_enumerant[])
1701
        {
1702
            {0, "Zext"},
1703
            {0x1, "Sext"},
1704
            {0x2, "ByVal"},
1705
            {0x3, "Sret"},
1706
            {0x4, "NoAlias"},
1707
            {0x5, "NoCapture"},
1708
            {0x6, "NoWrite"},
1709
            {0x7, "NoReadWrite"},
1710
            {0x1734, "RuntimeAlignedINTEL"},
1711
        }
1712
    },
1713
    [SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION] =
1714
    {
1715
        "GroupOperation", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 7,
1716
        (struct spirv_parser_enumerant[])
1717
        {
1718
            {0, "Reduce"},
1719
            {0x1, "InclusiveScan"},
1720
            {0x2, "ExclusiveScan"},
1721
            {0x3, "ClusteredReduce"},
1722
            {0x6, "PartitionedReduceNV"},
1723
            {0x7, "PartitionedInclusiveScanNV"},
1724
            {0x8, "PartitionedExclusiveScanNV"},
1725
        }
1726
    },
1727
    [SPIRV_PARSER_OPERAND_TYPE_HOST_ACCESS_QUALIFIER] =
1728
    {
1729
        "HostAccessQualifier", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
1730
        (struct spirv_parser_enumerant[])
1731
        {
1732
            {0, "NoneINTEL"},
1733
            {0x1, "ReadINTEL"},
1734
            {0x2, "WriteINTEL"},
1735
            {0x3, "ReadWriteINTEL"},
1736
        }
1737
    },
1738
    [SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS] =
1739
    {
1740
        "IdMemorySemantics", SPIRV_PARSER_OPERAND_CATEGORY_ID
1741
    },
1742
    [SPIRV_PARSER_OPERAND_TYPE_ID_REF] =
1743
    {
1744
        "IdRef", SPIRV_PARSER_OPERAND_CATEGORY_ID
1745
    },
1746
    [SPIRV_PARSER_OPERAND_TYPE_ID_RESULT] =
1747
    {
1748
        "IdResult", SPIRV_PARSER_OPERAND_CATEGORY_ID
1749
    },
1750
    [SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE] =
1751
    {
1752
        "IdResultType", SPIRV_PARSER_OPERAND_CATEGORY_ID
1753
    },
1754
    [SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE] =
1755
    {
1756
        "IdScope", SPIRV_PARSER_OPERAND_CATEGORY_ID
1757
    },
1758
    [SPIRV_PARSER_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE] =
1759
    {
1760
        "ImageChannelDataType", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 26,
1761
        (struct spirv_parser_enumerant[])
1762
        {
1763
            {0, "SnormInt8"},
1764
            {0x1, "SnormInt16"},
1765
            {0x2, "UnormInt8"},
1766
            {0x3, "UnormInt16"},
1767
            {0x4, "UnormShort565"},
1768
            {0x5, "UnormShort555"},
1769
            {0x6, "UnormInt101010"},
1770
            {0x7, "SignedInt8"},
1771
            {0x8, "SignedInt16"},
1772
            {0x9, "SignedInt32"},
1773
            {0xa, "UnsignedInt8"},
1774
            {0xb, "UnsignedInt16"},
1775
            {0xc, "UnsignedInt32"},
1776
            {0xd, "HalfFloat"},
1777
            {0xe, "Float"},
1778
            {0xf, "UnormInt24"},
1779
            {0x10, "UnormInt101010_2"},
1780
            {0x11, "UnormInt10X6EXT"},
1781
            {0x13, "UnsignedIntRaw10EXT"},
1782
            {0x14, "UnsignedIntRaw12EXT"},
1783
            {0x15, "UnormInt2_101010EXT"},
1784
            {0x16, "UnsignedInt10X6EXT"},
1785
            {0x17, "UnsignedInt12X4EXT"},
1786
            {0x18, "UnsignedInt14X2EXT"},
1787
            {0x19, "UnormInt12X4EXT"},
1788
            {0x1a, "UnormInt14X2EXT"},
1789
        }
1790
    },
1791
    [SPIRV_PARSER_OPERAND_TYPE_IMAGE_CHANNEL_ORDER] =
1792
    {
1793
        "ImageChannelOrder", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 20,
1794
        (struct spirv_parser_enumerant[])
1795
        {
1796
            {0, "R"},
1797
            {0x1, "A"},
1798
            {0x2, "RG"},
1799
            {0x3, "RA"},
1800
            {0x4, "RGB"},
1801
            {0x5, "RGBA"},
1802
            {0x6, "BGRA"},
1803
            {0x7, "ARGB"},
1804
            {0x8, "Intensity"},
1805
            {0x9, "Luminance"},
1806
            {0xa, "Rx"},
1807
            {0xb, "RGx"},
1808
            {0xc, "RGBx"},
1809
            {0xd, "Depth"},
1810
            {0xe, "DepthStencil"},
1811
            {0xf, "sRGB"},
1812
            {0x10, "sRGBx"},
1813
            {0x11, "sRGBA"},
1814
            {0x12, "sBGRA"},
1815
            {0x13, "ABGR"},
1816
        }
1817
    },
1818
    [SPIRV_PARSER_OPERAND_TYPE_IMAGE_FORMAT] =
1819
    {
1820
        "ImageFormat", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 42,
1821
        (struct spirv_parser_enumerant[])
1822
        {
1823
            {0, "Unknown"},
1824
            {0x1, "Rgba32f"},
1825
            {0x2, "Rgba16f"},
1826
            {0x3, "R32f"},
1827
            {0x4, "Rgba8"},
1828
            {0x5, "Rgba8Snorm"},
1829
            {0x6, "Rg32f"},
1830
            {0x7, "Rg16f"},
1831
            {0x8, "R11fG11fB10f"},
1832
            {0x9, "R16f"},
1833
            {0xa, "Rgba16"},
1834
            {0xb, "Rgb10A2"},
1835
            {0xc, "Rg16"},
1836
            {0xd, "Rg8"},
1837
            {0xe, "R16"},
1838
            {0xf, "R8"},
1839
            {0x10, "Rgba16Snorm"},
1840
            {0x11, "Rg16Snorm"},
1841
            {0x12, "Rg8Snorm"},
1842
            {0x13, "R16Snorm"},
1843
            {0x14, "R8Snorm"},
1844
            {0x15, "Rgba32i"},
1845
            {0x16, "Rgba16i"},
1846
            {0x17, "Rgba8i"},
1847
            {0x18, "R32i"},
1848
            {0x19, "Rg32i"},
1849
            {0x1a, "Rg16i"},
1850
            {0x1b, "Rg8i"},
1851
            {0x1c, "R16i"},
1852
            {0x1d, "R8i"},
1853
            {0x1e, "Rgba32ui"},
1854
            {0x1f, "Rgba16ui"},
1855
            {0x20, "Rgba8ui"},
1856
            {0x21, "R32ui"},
1857
            {0x22, "Rgb10a2ui"},
1858
            {0x23, "Rg32ui"},
1859
            {0x24, "Rg16ui"},
1860
            {0x25, "Rg8ui"},
1861
            {0x26, "R16ui"},
1862
            {0x27, "R8ui"},
1863
            {0x28, "R64ui"},
1864
            {0x29, "R64i"},
1865
        }
1866
    },
1867
    [SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS] =
1868
    {
1869
        "ImageOperands", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 17,
1870
        (struct spirv_parser_enumerant[])
1871
        {
1872
            {0, "None"},
1873
            {
1874
                0x1, "Bias", 1,
1875
                (enum spirv_parser_operand_type[])
1876
                {
1877
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1878
                }
1879
            },
1880
            {
1881
                0x2, "Lod", 1,
1882
                (enum spirv_parser_operand_type[])
1883
                {
1884
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1885
                }
1886
            },
1887
            {
1888
                0x4, "Grad", 2,
1889
                (enum spirv_parser_operand_type[])
1890
                {
1891
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1892
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1893
                }
1894
            },
1895
            {
1896
                0x8, "ConstOffset", 1,
1897
                (enum spirv_parser_operand_type[])
1898
                {
1899
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1900
                }
1901
            },
1902
            {
1903
                0x10, "Offset", 1,
1904
                (enum spirv_parser_operand_type[])
1905
                {
1906
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1907
                }
1908
            },
1909
            {
1910
                0x20, "ConstOffsets", 1,
1911
                (enum spirv_parser_operand_type[])
1912
                {
1913
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1914
                }
1915
            },
1916
            {
1917
                0x40, "Sample", 1,
1918
                (enum spirv_parser_operand_type[])
1919
                {
1920
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1921
                }
1922
            },
1923
            {
1924
                0x80, "MinLod", 1,
1925
                (enum spirv_parser_operand_type[])
1926
                {
1927
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1928
                }
1929
            },
1930
            {
1931
                0x100, "MakeTexelAvailable", 1,
1932
                (enum spirv_parser_operand_type[])
1933
                {
1934
                    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
1935
                }
1936
            },
1937
            {
1938
                0x200, "MakeTexelVisible", 1,
1939
                (enum spirv_parser_operand_type[])
1940
                {
1941
                    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
1942
                }
1943
            },
1944
            {0x400, "NonPrivateTexel"},
1945
            {0x800, "VolatileTexel"},
1946
            {0x1000, "SignExtend"},
1947
            {0x2000, "ZeroExtend"},
1948
            {0x4000, "Nontemporal"},
1949
            {
1950
                0x10000, "Offsets", 1,
1951
                (enum spirv_parser_operand_type[])
1952
                {
1953
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
1954
                }
1955
            },
1956
        }
1957
    },
1958
    [SPIRV_PARSER_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER] =
1959
    {
1960
        "InitializationModeQualifier", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
1961
        (struct spirv_parser_enumerant[])
1962
        {
1963
            {0, "InitOnDeviceReprogramINTEL"},
1964
            {0x1, "InitOnDeviceResetINTEL"},
1965
        }
1966
    },
1967
    [SPIRV_PARSER_OPERAND_TYPE_KERNEL_ENQUEUE_FLAGS] =
1968
    {
1969
        "KernelEnqueueFlags", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 3,
1970
        (struct spirv_parser_enumerant[])
1971
        {
1972
            {0, "NoWait"},
1973
            {0x1, "WaitKernel"},
1974
            {0x2, "WaitWorkGroup"},
1975
        }
1976
    },
1977
    [SPIRV_PARSER_OPERAND_TYPE_KERNEL_PROFILING_INFO] =
1978
    {
1979
        "KernelProfilingInfo", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 2,
1980
        (struct spirv_parser_enumerant[])
1981
        {
1982
            {0, "None"},
1983
            {0x1, "CmdExecTime"},
1984
        }
1985
    },
1986
    [SPIRV_PARSER_OPERAND_TYPE_LINKAGE_TYPE] =
1987
    {
1988
        "LinkageType", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 3,
1989
        (struct spirv_parser_enumerant[])
1990
        {
1991
            {0, "Export"},
1992
            {0x1, "Import"},
1993
            {0x2, "LinkOnceODR"},
1994
        }
1995
    },
1996
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_CONTEXT_DEPENDENT_NUMBER] =
1997
    {
1998
        "LiteralContextDependentNumber", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
1999
    },
2000
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_EXT_INST_INTEGER] =
2001
    {
2002
        "LiteralExtInstInteger", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
2003
    },
2004
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_FLOAT] =
2005
    {
2006
        "LiteralFloat", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
2007
    },
2008
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER] =
2009
    {
2010
        "LiteralInteger", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
2011
    },
2012
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_SPEC_CONSTANT_OP_INTEGER] =
2013
    {
2014
        "LiteralSpecConstantOpInteger", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
2015
    },
2016
    [SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING] =
2017
    {
2018
        "LiteralString", SPIRV_PARSER_OPERAND_CATEGORY_LITERAL
2019
    },
2020
    [SPIRV_PARSER_OPERAND_TYPE_LOAD_CACHE_CONTROL] =
2021
    {
2022
        "LoadCacheControl", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 5,
2023
        (struct spirv_parser_enumerant[])
2024
        {
2025
            {0, "UncachedINTEL"},
2026
            {0x1, "CachedINTEL"},
2027
            {0x2, "StreamingINTEL"},
2028
            {0x3, "InvalidateAfterReadINTEL"},
2029
            {0x4, "ConstCachedINTEL"},
2030
        }
2031
    },
2032
    [SPIRV_PARSER_OPERAND_TYPE_LOOP_CONTROL] =
2033
    {
2034
        "LoopControl", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 20,
2035
        (struct spirv_parser_enumerant[])
2036
        {
2037
            {0, "None"},
2038
            {0x1, "Unroll"},
2039
            {0x2, "DontUnroll"},
2040
            {0x4, "DependencyInfinite"},
2041
            {
2042
                0x8, "DependencyLength", 1,
2043
                (enum spirv_parser_operand_type[])
2044
                {
2045
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2046
                }
2047
            },
2048
            {
2049
                0x10, "MinIterations", 1,
2050
                (enum spirv_parser_operand_type[])
2051
                {
2052
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2053
                }
2054
            },
2055
            {
2056
                0x20, "MaxIterations", 1,
2057
                (enum spirv_parser_operand_type[])
2058
                {
2059
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2060
                }
2061
            },
2062
            {
2063
                0x40, "IterationMultiple", 1,
2064
                (enum spirv_parser_operand_type[])
2065
                {
2066
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2067
                }
2068
            },
2069
            {
2070
                0x80, "PeelCount", 1,
2071
                (enum spirv_parser_operand_type[])
2072
                {
2073
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2074
                }
2075
            },
2076
            {
2077
                0x100, "PartialCount", 1,
2078
                (enum spirv_parser_operand_type[])
2079
                {
2080
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2081
                }
2082
            },
2083
            {
2084
                0x10000, "InitiationIntervalINTEL", 1,
2085
                (enum spirv_parser_operand_type[])
2086
                {
2087
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2088
                }
2089
            },
2090
            {
2091
                0x20000, "MaxConcurrencyINTEL", 1,
2092
                (enum spirv_parser_operand_type[])
2093
                {
2094
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2095
                }
2096
            },
2097
            {
2098
                0x40000, "DependencyArrayINTEL", 1,
2099
                (enum spirv_parser_operand_type[])
2100
                {
2101
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2102
                }
2103
            },
2104
            {
2105
                0x80000, "PipelineEnableINTEL", 1,
2106
                (enum spirv_parser_operand_type[])
2107
                {
2108
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2109
                }
2110
            },
2111
            {
2112
                0x100000, "LoopCoalesceINTEL", 1,
2113
                (enum spirv_parser_operand_type[])
2114
                {
2115
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2116
                }
2117
            },
2118
            {
2119
                0x200000, "MaxInterleavingINTEL", 1,
2120
                (enum spirv_parser_operand_type[])
2121
                {
2122
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2123
                }
2124
            },
2125
            {
2126
                0x400000, "SpeculatedIterationsINTEL", 1,
2127
                (enum spirv_parser_operand_type[])
2128
                {
2129
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2130
                }
2131
            },
2132
            {0x800000, "NoFusionINTEL"},
2133
            {
2134
                0x1000000, "LoopCountINTEL", 1,
2135
                (enum spirv_parser_operand_type[])
2136
                {
2137
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2138
                }
2139
            },
2140
            {
2141
                0x2000000, "MaxReinvocationDelayINTEL", 1,
2142
                (enum spirv_parser_operand_type[])
2143
                {
2144
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2145
                }
2146
            },
2147
        }
2148
    },
2149
    [SPIRV_PARSER_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS] =
2150
    {
2151
        "MatrixMultiplyAccumulateOperands", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 15,
2152
        (struct spirv_parser_enumerant[])
2153
        {
2154
            {0, "None"},
2155
            {0x1, "MatrixASignedComponentsINTEL"},
2156
            {0x2, "MatrixBSignedComponentsINTEL"},
2157
            {0x4, "MatrixCBFloat16INTEL"},
2158
            {0x8, "MatrixResultBFloat16INTEL"},
2159
            {0x10, "MatrixAPackedInt8INTEL"},
2160
            {0x20, "MatrixBPackedInt8INTEL"},
2161
            {0x40, "MatrixAPackedInt4INTEL"},
2162
            {0x80, "MatrixBPackedInt4INTEL"},
2163
            {0x100, "MatrixATF32INTEL"},
2164
            {0x200, "MatrixBTF32INTEL"},
2165
            {0x400, "MatrixAPackedFloat16INTEL"},
2166
            {0x800, "MatrixBPackedFloat16INTEL"},
2167
            {0x1000, "MatrixAPackedBFloat16INTEL"},
2168
            {0x2000, "MatrixBPackedBFloat16INTEL"},
2169
        }
2170
    },
2171
    [SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS] =
2172
    {
2173
        "MemoryAccess", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 9,
2174
        (struct spirv_parser_enumerant[])
2175
        {
2176
            {0, "None"},
2177
            {0x1, "Volatile"},
2178
            {
2179
                0x2, "Aligned", 1,
2180
                (enum spirv_parser_operand_type[])
2181
                {
2182
                    SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER,
2183
                }
2184
            },
2185
            {0x4, "Nontemporal"},
2186
            {
2187
                0x8, "MakePointerAvailable", 1,
2188
                (enum spirv_parser_operand_type[])
2189
                {
2190
                    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
2191
                }
2192
            },
2193
            {
2194
                0x10, "MakePointerVisible", 1,
2195
                (enum spirv_parser_operand_type[])
2196
                {
2197
                    SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE,
2198
                }
2199
            },
2200
            {0x20, "NonPrivatePointer"},
2201
            {
2202
                0x10000, "AliasScopeINTELMask", 1,
2203
                (enum spirv_parser_operand_type[])
2204
                {
2205
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
2206
                }
2207
            },
2208
            {
2209
                0x20000, "NoAliasINTELMask", 1,
2210
                (enum spirv_parser_operand_type[])
2211
                {
2212
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
2213
                }
2214
            },
2215
        }
2216
    },
2217
    [SPIRV_PARSER_OPERAND_TYPE_MEMORY_MODEL] =
2218
    {
2219
        "MemoryModel", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
2220
        (struct spirv_parser_enumerant[])
2221
        {
2222
            {0, "Simple"},
2223
            {0x1, "GLSL450"},
2224
            {0x2, "OpenCL"},
2225
            {0x3, "Vulkan"},
2226
        }
2227
    },
2228
    [SPIRV_PARSER_OPERAND_TYPE_MEMORY_SEMANTICS] =
2229
    {
2230
        "MemorySemantics", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 15,
2231
        (struct spirv_parser_enumerant[])
2232
        {
2233
            {0, "Relaxed"},
2234
            {0x2, "Acquire"},
2235
            {0x4, "Release"},
2236
            {0x8, "AcquireRelease"},
2237
            {0x10, "SequentiallyConsistent"},
2238
            {0x40, "UniformMemory"},
2239
            {0x80, "SubgroupMemory"},
2240
            {0x100, "WorkgroupMemory"},
2241
            {0x200, "CrossWorkgroupMemory"},
2242
            {0x400, "AtomicCounterMemory"},
2243
            {0x800, "ImageMemory"},
2244
            {0x1000, "OutputMemory"},
2245
            {0x2000, "MakeAvailable"},
2246
            {0x4000, "MakeVisible"},
2247
            {0x8000, "Volatile"},
2248
        }
2249
    },
2250
    [SPIRV_PARSER_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS] =
2251
    {
2252
        "NamedMaximumNumberOfRegisters", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 1,
2253
        (struct spirv_parser_enumerant[])
2254
        {
2255
            {0, "AutoINTEL"},
2256
        }
2257
    },
2258
    [SPIRV_PARSER_OPERAND_TYPE_OVERFLOW_MODES] =
2259
    {
2260
        "OverflowModes", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
2261
        (struct spirv_parser_enumerant[])
2262
        {
2263
            {0, "WRAP"},
2264
            {0x1, "SAT"},
2265
            {0x2, "SAT_ZERO"},
2266
            {0x3, "SAT_SYM"},
2267
        }
2268
    },
2269
    [SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT] =
2270
    {
2271
        "PackedVectorFormat", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 1,
2272
        (struct spirv_parser_enumerant[])
2273
        {
2274
            {0, "PackedVectorFormat4x8Bit"},
2275
        }
2276
    },
2277
    [SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_ID_REF] =
2278
    {
2279
        "PairIdRefIdRef", SPIRV_PARSER_OPERAND_CATEGORY_COMPOSITE
2280
    },
2281
    [SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_LITERAL_INTEGER] =
2282
    {
2283
        "PairIdRefLiteralInteger", SPIRV_PARSER_OPERAND_CATEGORY_COMPOSITE
2284
    },
2285
    [SPIRV_PARSER_OPERAND_TYPE_PAIR_LITERAL_INTEGER_ID_REF] =
2286
    {
2287
        "PairLiteralIntegerIdRef", SPIRV_PARSER_OPERAND_CATEGORY_COMPOSITE
2288
    },
2289
    [SPIRV_PARSER_OPERAND_TYPE_QUANTIZATION_MODES] =
2290
    {
2291
        "QuantizationModes", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 8,
2292
        (struct spirv_parser_enumerant[])
2293
        {
2294
            {0, "TRN"},
2295
            {0x1, "TRN_ZERO"},
2296
            {0x2, "RND"},
2297
            {0x3, "RND_ZERO"},
2298
            {0x4, "RND_INF"},
2299
            {0x5, "RND_MIN_INF"},
2300
            {0x6, "RND_CONV"},
2301
            {0x7, "RND_CONV_ODD"},
2302
        }
2303
    },
2304
    [SPIRV_PARSER_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS] =
2305
    {
2306
        "RawAccessChainOperands", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 3,
2307
        (struct spirv_parser_enumerant[])
2308
        {
2309
            {0, "None"},
2310
            {0x1, "RobustnessPerComponentNV"},
2311
            {0x2, "RobustnessPerElementNV"},
2312
        }
2313
    },
2314
    [SPIRV_PARSER_OPERAND_TYPE_RAY_FLAGS] =
2315
    {
2316
        "RayFlags", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 12,
2317
        (struct spirv_parser_enumerant[])
2318
        {
2319
            {0, "NoneKHR"},
2320
            {0x1, "OpaqueKHR"},
2321
            {0x2, "NoOpaqueKHR"},
2322
            {0x4, "TerminateOnFirstHitKHR"},
2323
            {0x8, "SkipClosestHitShaderKHR"},
2324
            {0x10, "CullBackFacingTrianglesKHR"},
2325
            {0x20, "CullFrontFacingTrianglesKHR"},
2326
            {0x40, "CullOpaqueKHR"},
2327
            {0x80, "CullNoOpaqueKHR"},
2328
            {0x100, "SkipTrianglesKHR"},
2329
            {0x200, "SkipAABBsKHR"},
2330
            {0x400, "ForceOpacityMicromap2StateEXT"},
2331
        }
2332
    },
2333
    [SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE] =
2334
    {
2335
        "RayQueryCandidateIntersectionType", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
2336
        (struct spirv_parser_enumerant[])
2337
        {
2338
            {0, "RayQueryCandidateIntersectionTriangleKHR"},
2339
            {0x1, "RayQueryCandidateIntersectionAABBKHR"},
2340
        }
2341
    },
2342
    [SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE] =
2343
    {
2344
        "RayQueryCommittedIntersectionType", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 3,
2345
        (struct spirv_parser_enumerant[])
2346
        {
2347
            {0, "RayQueryCommittedIntersectionNoneKHR"},
2348
            {0x1, "RayQueryCommittedIntersectionTriangleKHR"},
2349
            {0x2, "RayQueryCommittedIntersectionGeneratedKHR"},
2350
        }
2351
    },
2352
    [SPIRV_PARSER_OPERAND_TYPE_RAY_QUERY_INTERSECTION] =
2353
    {
2354
        "RayQueryIntersection", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
2355
        (struct spirv_parser_enumerant[])
2356
        {
2357
            {0, "RayQueryCandidateIntersectionKHR"},
2358
            {0x1, "RayQueryCommittedIntersectionKHR"},
2359
        }
2360
    },
2361
    [SPIRV_PARSER_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE] =
2362
    {
2363
        "SamplerAddressingMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 5,
2364
        (struct spirv_parser_enumerant[])
2365
        {
2366
            {0, "None"},
2367
            {0x1, "ClampToEdge"},
2368
            {0x2, "Clamp"},
2369
            {0x3, "Repeat"},
2370
            {0x4, "RepeatMirrored"},
2371
        }
2372
    },
2373
    [SPIRV_PARSER_OPERAND_TYPE_SAMPLER_FILTER_MODE] =
2374
    {
2375
        "SamplerFilterMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 2,
2376
        (struct spirv_parser_enumerant[])
2377
        {
2378
            {0, "Nearest"},
2379
            {0x1, "Linear"},
2380
        }
2381
    },
2382
    [SPIRV_PARSER_OPERAND_TYPE_SCOPE] =
2383
    {
2384
        "Scope", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 7,
2385
        (struct spirv_parser_enumerant[])
2386
        {
2387
            {0, "CrossDevice"},
2388
            {0x1, "Device"},
2389
            {0x2, "Workgroup"},
2390
            {0x3, "Subgroup"},
2391
            {0x4, "Invocation"},
2392
            {0x5, "QueueFamily"},
2393
            {0x6, "ShaderCallKHR"},
2394
        }
2395
    },
2396
    [SPIRV_PARSER_OPERAND_TYPE_SELECTION_CONTROL] =
2397
    {
2398
        "SelectionControl", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 3,
2399
        (struct spirv_parser_enumerant[])
2400
        {
2401
            {0, "None"},
2402
            {0x1, "Flatten"},
2403
            {0x2, "DontFlatten"},
2404
        }
2405
    },
2406
    [SPIRV_PARSER_OPERAND_TYPE_SOURCE_LANGUAGE] =
2407
    {
2408
        "SourceLanguage", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 14,
2409
        (struct spirv_parser_enumerant[])
2410
        {
2411
            {0, "Unknown"},
2412
            {0x1, "ESSL"},
2413
            {0x2, "GLSL"},
2414
            {0x3, "OpenCL_C"},
2415
            {0x4, "OpenCL_CPP"},
2416
            {0x5, "HLSL"},
2417
            {0x6, "CPP_for_OpenCL"},
2418
            {0x7, "SYCL"},
2419
            {0x8, "HERO_C"},
2420
            {0x9, "NZSL"},
2421
            {0xa, "WGSL"},
2422
            {0xb, "Slang"},
2423
            {0xc, "Zig"},
2424
            {0xd, "Rust"},
2425
        }
2426
    },
2427
    [SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS] =
2428
    {
2429
        "StorageClass", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 28,
2430
        (struct spirv_parser_enumerant[])
2431
        {
2432
            {0, "UniformConstant"},
2433
            {0x1, "Input"},
2434
            {0x2, "Uniform"},
2435
            {0x3, "Output"},
2436
            {0x4, "Workgroup"},
2437
            {0x5, "CrossWorkgroup"},
2438
            {0x6, "Private"},
2439
            {0x7, "Function"},
2440
            {0x8, "Generic"},
2441
            {0x9, "PushConstant"},
2442
            {0xa, "AtomicCounter"},
2443
            {0xb, "Image"},
2444
            {0xc, "StorageBuffer"},
2445
            {0x104c, "TileImageEXT"},
2446
            {0x118b, "TileAttachmentQCOM"},
2447
            {0x13cc, "NodePayloadAMDX"},
2448
            {0x14d0, "CallableDataKHR"},
2449
            {0x14d1, "IncomingCallableDataKHR"},
2450
            {0x14da, "RayPayloadKHR"},
2451
            {0x14db, "HitAttributeKHR"},
2452
            {0x14de, "IncomingRayPayloadKHR"},
2453
            {0x14df, "ShaderRecordBufferKHR"},
2454
            {0x14e5, "PhysicalStorageBuffer"},
2455
            {0x1509, "HitObjectAttributeNV"},
2456
            {0x151a, "TaskPayloadWorkgroupEXT"},
2457
            {0x15e5, "CodeSectionINTEL"},
2458
            {0x1730, "DeviceOnlyINTEL"},
2459
            {0x1731, "HostOnlyINTEL"},
2460
        }
2461
    },
2462
    [SPIRV_PARSER_OPERAND_TYPE_STORE_CACHE_CONTROL] =
2463
    {
2464
        "StoreCacheControl", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 4,
2465
        (struct spirv_parser_enumerant[])
2466
        {
2467
            {0, "UncachedINTEL"},
2468
            {0x1, "WriteThroughINTEL"},
2469
            {0x2, "WriteBackINTEL"},
2470
            {0x3, "StreamingINTEL"},
2471
        }
2472
    },
2473
    [SPIRV_PARSER_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS] =
2474
    {
2475
        "TensorAddressingOperands", SPIRV_PARSER_OPERAND_CATEGORY_BIT_ENUM, 3,
2476
        (struct spirv_parser_enumerant[])
2477
        {
2478
            {0, "None"},
2479
            {
2480
                0x1, "TensorView", 1,
2481
                (enum spirv_parser_operand_type[])
2482
                {
2483
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
2484
                }
2485
            },
2486
            {
2487
                0x2, "DecodeFunc", 1,
2488
                (enum spirv_parser_operand_type[])
2489
                {
2490
                    SPIRV_PARSER_OPERAND_TYPE_ID_REF,
2491
                }
2492
            },
2493
        }
2494
    },
2495
    [SPIRV_PARSER_OPERAND_TYPE_TENSOR_CLAMP_MODE] =
2496
    {
2497
        "TensorClampMode", SPIRV_PARSER_OPERAND_CATEGORY_VALUE_ENUM, 5,
2498
        (struct spirv_parser_enumerant[])
2499
        {
2500
            {0, "Undefined"},
2501
            {0x1, "Constant"},
2502
            {0x2, "ClampToEdge"},
2503
            {0x3, "Repeat"},
2504
            {0x4, "RepeatMirrored"},
2505
        }
2506
    },
2507
};
2508

2509
static const struct spirv_parser_opcode_info
2510
{
2511
    uint16_t op;
2512
    const char *name;
2513
    size_t operand_count;
2514
    const struct spirv_parser_instruction_operand
2515
    {
2516
        enum spirv_parser_operand_type type;
2517
        char quantifier;
2518
    } *operands;
2519
}
2520
spirv_parser_opcode_info[] =
2521
{
2522
    {0x0000, "OpNop"},
2523
    {
2524
        0x0001, "OpUndef", 2,
2525
        (struct spirv_parser_instruction_operand[])
2526
        {
2527
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2528
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2529
        }
2530
    },
2531
    {
2532
        0x0002, "OpSourceContinued", 1,
2533
        (struct spirv_parser_instruction_operand[])
2534
        {
2535
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2536
        }
2537
    },
2538
    {
2539
        0x0003, "OpSource", 4,
2540
        (struct spirv_parser_instruction_operand[])
2541
        {
2542
            {SPIRV_PARSER_OPERAND_TYPE_SOURCE_LANGUAGE},
2543
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2544
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
2545
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING, '?'},
2546
        }
2547
    },
2548
    {
2549
        0x0004, "OpSourceExtension", 1,
2550
        (struct spirv_parser_instruction_operand[])
2551
        {
2552
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2553
        }
2554
    },
2555
    {
2556
        0x0005, "OpName", 2,
2557
        (struct spirv_parser_instruction_operand[])
2558
        {
2559
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2560
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2561
        }
2562
    },
2563
    {
2564
        0x0006, "OpMemberName", 3,
2565
        (struct spirv_parser_instruction_operand[])
2566
        {
2567
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2568
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2569
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2570
        }
2571
    },
2572
    {
2573
        0x0007, "OpString", 2,
2574
        (struct spirv_parser_instruction_operand[])
2575
        {
2576
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2577
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2578
        }
2579
    },
2580
    {
2581
        0x0008, "OpLine", 3,
2582
        (struct spirv_parser_instruction_operand[])
2583
        {
2584
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2585
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2586
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2587
        }
2588
    },
2589
    {
2590
        0x000a, "OpExtension", 1,
2591
        (struct spirv_parser_instruction_operand[])
2592
        {
2593
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2594
        }
2595
    },
2596
    {
2597
        0x000b, "OpExtInstImport", 2,
2598
        (struct spirv_parser_instruction_operand[])
2599
        {
2600
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2601
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2602
        }
2603
    },
2604
    {
2605
        0x000c, "OpExtInst", 5,
2606
        (struct spirv_parser_instruction_operand[])
2607
        {
2608
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2609
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2610
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2611
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_EXT_INST_INTEGER},
2612
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2613
        }
2614
    },
2615
    {
2616
        0x000e, "OpMemoryModel", 2,
2617
        (struct spirv_parser_instruction_operand[])
2618
        {
2619
            {SPIRV_PARSER_OPERAND_TYPE_ADDRESSING_MODEL},
2620
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_MODEL},
2621
        }
2622
    },
2623
    {
2624
        0x000f, "OpEntryPoint", 4,
2625
        (struct spirv_parser_instruction_operand[])
2626
        {
2627
            {SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODEL},
2628
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2629
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2630
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2631
        }
2632
    },
2633
    {
2634
        0x0010, "OpExecutionMode", 2,
2635
        (struct spirv_parser_instruction_operand[])
2636
        {
2637
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2638
            {SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODE},
2639
        }
2640
    },
2641
    {
2642
        0x0011, "OpCapability", 1,
2643
        (struct spirv_parser_instruction_operand[])
2644
        {
2645
            {SPIRV_PARSER_OPERAND_TYPE_CAPABILITY},
2646
        }
2647
    },
2648
    {
2649
        0x0013, "OpTypeVoid", 1,
2650
        (struct spirv_parser_instruction_operand[])
2651
        {
2652
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2653
        }
2654
    },
2655
    {
2656
        0x0014, "OpTypeBool", 1,
2657
        (struct spirv_parser_instruction_operand[])
2658
        {
2659
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2660
        }
2661
    },
2662
    {
2663
        0x0015, "OpTypeInt", 3,
2664
        (struct spirv_parser_instruction_operand[])
2665
        {
2666
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2667
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2668
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2669
        }
2670
    },
2671
    {
2672
        0x0016, "OpTypeFloat", 3,
2673
        (struct spirv_parser_instruction_operand[])
2674
        {
2675
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2676
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2677
            {SPIRV_PARSER_OPERAND_TYPE_FPENCODING, '?'},
2678
        }
2679
    },
2680
    {
2681
        0x0017, "OpTypeVector", 3,
2682
        (struct spirv_parser_instruction_operand[])
2683
        {
2684
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2685
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2686
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2687
        }
2688
    },
2689
    {
2690
        0x0018, "OpTypeMatrix", 3,
2691
        (struct spirv_parser_instruction_operand[])
2692
        {
2693
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2694
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2695
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2696
        }
2697
    },
2698
    {
2699
        0x0019, "OpTypeImage", 9,
2700
        (struct spirv_parser_instruction_operand[])
2701
        {
2702
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2703
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2704
            {SPIRV_PARSER_OPERAND_TYPE_DIM},
2705
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2706
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2707
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2708
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2709
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_FORMAT},
2710
            {SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER, '?'},
2711
        }
2712
    },
2713
    {
2714
        0x001a, "OpTypeSampler", 1,
2715
        (struct spirv_parser_instruction_operand[])
2716
        {
2717
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2718
        }
2719
    },
2720
    {
2721
        0x001b, "OpTypeSampledImage", 2,
2722
        (struct spirv_parser_instruction_operand[])
2723
        {
2724
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2725
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2726
        }
2727
    },
2728
    {
2729
        0x001c, "OpTypeArray", 3,
2730
        (struct spirv_parser_instruction_operand[])
2731
        {
2732
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2733
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2734
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2735
        }
2736
    },
2737
    {
2738
        0x001d, "OpTypeRuntimeArray", 2,
2739
        (struct spirv_parser_instruction_operand[])
2740
        {
2741
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2742
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2743
        }
2744
    },
2745
    {
2746
        0x001e, "OpTypeStruct", 2,
2747
        (struct spirv_parser_instruction_operand[])
2748
        {
2749
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2750
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2751
        }
2752
    },
2753
    {
2754
        0x001f, "OpTypeOpaque", 2,
2755
        (struct spirv_parser_instruction_operand[])
2756
        {
2757
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2758
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
2759
        }
2760
    },
2761
    {
2762
        0x0020, "OpTypePointer", 3,
2763
        (struct spirv_parser_instruction_operand[])
2764
        {
2765
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2766
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
2767
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2768
        }
2769
    },
2770
    {
2771
        0x0021, "OpTypeFunction", 3,
2772
        (struct spirv_parser_instruction_operand[])
2773
        {
2774
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2775
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2776
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2777
        }
2778
    },
2779
    {
2780
        0x0022, "OpTypeEvent", 1,
2781
        (struct spirv_parser_instruction_operand[])
2782
        {
2783
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2784
        }
2785
    },
2786
    {
2787
        0x0023, "OpTypeDeviceEvent", 1,
2788
        (struct spirv_parser_instruction_operand[])
2789
        {
2790
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2791
        }
2792
    },
2793
    {
2794
        0x0024, "OpTypeReserveId", 1,
2795
        (struct spirv_parser_instruction_operand[])
2796
        {
2797
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2798
        }
2799
    },
2800
    {
2801
        0x0025, "OpTypeQueue", 1,
2802
        (struct spirv_parser_instruction_operand[])
2803
        {
2804
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2805
        }
2806
    },
2807
    {
2808
        0x0026, "OpTypePipe", 2,
2809
        (struct spirv_parser_instruction_operand[])
2810
        {
2811
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2812
            {SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER},
2813
        }
2814
    },
2815
    {
2816
        0x0027, "OpTypeForwardPointer", 2,
2817
        (struct spirv_parser_instruction_operand[])
2818
        {
2819
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2820
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
2821
        }
2822
    },
2823
    {
2824
        0x0029, "OpConstantTrue", 2,
2825
        (struct spirv_parser_instruction_operand[])
2826
        {
2827
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2828
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2829
        }
2830
    },
2831
    {
2832
        0x002a, "OpConstantFalse", 2,
2833
        (struct spirv_parser_instruction_operand[])
2834
        {
2835
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2836
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2837
        }
2838
    },
2839
    {
2840
        0x002b, "OpConstant", 3,
2841
        (struct spirv_parser_instruction_operand[])
2842
        {
2843
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2844
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2845
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_CONTEXT_DEPENDENT_NUMBER},
2846
        }
2847
    },
2848
    {
2849
        0x002c, "OpConstantComposite", 3,
2850
        (struct spirv_parser_instruction_operand[])
2851
        {
2852
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2853
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2854
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2855
        }
2856
    },
2857
    {
2858
        0x002d, "OpConstantSampler", 5,
2859
        (struct spirv_parser_instruction_operand[])
2860
        {
2861
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2862
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2863
            {SPIRV_PARSER_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE},
2864
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
2865
            {SPIRV_PARSER_OPERAND_TYPE_SAMPLER_FILTER_MODE},
2866
        }
2867
    },
2868
    {
2869
        0x002e, "OpConstantNull", 2,
2870
        (struct spirv_parser_instruction_operand[])
2871
        {
2872
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2873
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2874
        }
2875
    },
2876
    {
2877
        0x0030, "OpSpecConstantTrue", 2,
2878
        (struct spirv_parser_instruction_operand[])
2879
        {
2880
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2881
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2882
        }
2883
    },
2884
    {
2885
        0x0031, "OpSpecConstantFalse", 2,
2886
        (struct spirv_parser_instruction_operand[])
2887
        {
2888
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2889
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2890
        }
2891
    },
2892
    {
2893
        0x0032, "OpSpecConstant", 3,
2894
        (struct spirv_parser_instruction_operand[])
2895
        {
2896
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2897
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2898
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_CONTEXT_DEPENDENT_NUMBER},
2899
        }
2900
    },
2901
    {
2902
        0x0033, "OpSpecConstantComposite", 3,
2903
        (struct spirv_parser_instruction_operand[])
2904
        {
2905
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2906
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2907
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2908
        }
2909
    },
2910
    {
2911
        0x0034, "OpSpecConstantOp", 3,
2912
        (struct spirv_parser_instruction_operand[])
2913
        {
2914
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2915
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2916
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_SPEC_CONSTANT_OP_INTEGER},
2917
        }
2918
    },
2919
    {
2920
        0x0036, "OpFunction", 4,
2921
        (struct spirv_parser_instruction_operand[])
2922
        {
2923
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2924
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2925
            {SPIRV_PARSER_OPERAND_TYPE_FUNCTION_CONTROL},
2926
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2927
        }
2928
    },
2929
    {
2930
        0x0037, "OpFunctionParameter", 2,
2931
        (struct spirv_parser_instruction_operand[])
2932
        {
2933
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2934
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2935
        }
2936
    },
2937
    {0x0038, "OpFunctionEnd"},
2938
    {
2939
        0x0039, "OpFunctionCall", 4,
2940
        (struct spirv_parser_instruction_operand[])
2941
        {
2942
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2943
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2944
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2945
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
2946
        }
2947
    },
2948
    {
2949
        0x003b, "OpVariable", 4,
2950
        (struct spirv_parser_instruction_operand[])
2951
        {
2952
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2953
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2954
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
2955
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
2956
        }
2957
    },
2958
    {
2959
        0x003c, "OpImageTexelPointer", 5,
2960
        (struct spirv_parser_instruction_operand[])
2961
        {
2962
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2963
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2964
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2965
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2966
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2967
        }
2968
    },
2969
    {
2970
        0x003d, "OpLoad", 4,
2971
        (struct spirv_parser_instruction_operand[])
2972
        {
2973
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
2974
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
2975
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2976
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
2977
        }
2978
    },
2979
    {
2980
        0x003e, "OpStore", 3,
2981
        (struct spirv_parser_instruction_operand[])
2982
        {
2983
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2984
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2985
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
2986
        }
2987
    },
2988
    {
2989
        0x003f, "OpCopyMemory", 4,
2990
        (struct spirv_parser_instruction_operand[])
2991
        {
2992
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2993
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
2994
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
2995
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
2996
        }
2997
    },
2998
    {
2999
        0x0040, "OpCopyMemorySized", 5,
3000
        (struct spirv_parser_instruction_operand[])
3001
        {
3002
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3003
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3004
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3005
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
3006
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
3007
        }
3008
    },
3009
    {
3010
        0x0041, "OpAccessChain", 4,
3011
        (struct spirv_parser_instruction_operand[])
3012
        {
3013
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3014
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3015
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3016
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3017
        }
3018
    },
3019
    {
3020
        0x0042, "OpInBoundsAccessChain", 4,
3021
        (struct spirv_parser_instruction_operand[])
3022
        {
3023
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3024
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3025
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3026
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3027
        }
3028
    },
3029
    {
3030
        0x0043, "OpPtrAccessChain", 5,
3031
        (struct spirv_parser_instruction_operand[])
3032
        {
3033
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3034
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3035
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3036
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3037
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3038
        }
3039
    },
3040
    {
3041
        0x0044, "OpArrayLength", 4,
3042
        (struct spirv_parser_instruction_operand[])
3043
        {
3044
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3045
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3046
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3047
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
3048
        }
3049
    },
3050
    {
3051
        0x0045, "OpGenericPtrMemSemantics", 3,
3052
        (struct spirv_parser_instruction_operand[])
3053
        {
3054
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3055
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3056
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3057
        }
3058
    },
3059
    {
3060
        0x0046, "OpInBoundsPtrAccessChain", 5,
3061
        (struct spirv_parser_instruction_operand[])
3062
        {
3063
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3064
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3065
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3066
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3067
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3068
        }
3069
    },
3070
    {
3071
        0x0047, "OpDecorate", 2,
3072
        (struct spirv_parser_instruction_operand[])
3073
        {
3074
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3075
            {SPIRV_PARSER_OPERAND_TYPE_DECORATION},
3076
        }
3077
    },
3078
    {
3079
        0x0048, "OpMemberDecorate", 3,
3080
        (struct spirv_parser_instruction_operand[])
3081
        {
3082
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3083
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
3084
            {SPIRV_PARSER_OPERAND_TYPE_DECORATION},
3085
        }
3086
    },
3087
    {
3088
        0x0049, "OpDecorationGroup", 1,
3089
        (struct spirv_parser_instruction_operand[])
3090
        {
3091
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3092
        }
3093
    },
3094
    {
3095
        0x004a, "OpGroupDecorate", 2,
3096
        (struct spirv_parser_instruction_operand[])
3097
        {
3098
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3099
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3100
        }
3101
    },
3102
    {
3103
        0x004b, "OpGroupMemberDecorate", 2,
3104
        (struct spirv_parser_instruction_operand[])
3105
        {
3106
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3107
            {SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_LITERAL_INTEGER, '*'},
3108
        }
3109
    },
3110
    {
3111
        0x004d, "OpVectorExtractDynamic", 4,
3112
        (struct spirv_parser_instruction_operand[])
3113
        {
3114
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3115
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3116
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3117
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3118
        }
3119
    },
3120
    {
3121
        0x004e, "OpVectorInsertDynamic", 5,
3122
        (struct spirv_parser_instruction_operand[])
3123
        {
3124
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3125
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3126
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3127
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3128
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3129
        }
3130
    },
3131
    {
3132
        0x004f, "OpVectorShuffle", 5,
3133
        (struct spirv_parser_instruction_operand[])
3134
        {
3135
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3136
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3137
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3138
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3139
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER, '*'},
3140
        }
3141
    },
3142
    {
3143
        0x0050, "OpCompositeConstruct", 3,
3144
        (struct spirv_parser_instruction_operand[])
3145
        {
3146
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3147
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3148
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
3149
        }
3150
    },
3151
    {
3152
        0x0051, "OpCompositeExtract", 4,
3153
        (struct spirv_parser_instruction_operand[])
3154
        {
3155
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3156
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3157
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3158
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER, '*'},
3159
        }
3160
    },
3161
    {
3162
        0x0052, "OpCompositeInsert", 5,
3163
        (struct spirv_parser_instruction_operand[])
3164
        {
3165
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3166
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3167
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3168
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3169
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER, '*'},
3170
        }
3171
    },
3172
    {
3173
        0x0053, "OpCopyObject", 3,
3174
        (struct spirv_parser_instruction_operand[])
3175
        {
3176
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3177
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3178
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3179
        }
3180
    },
3181
    {
3182
        0x0054, "OpTranspose", 3,
3183
        (struct spirv_parser_instruction_operand[])
3184
        {
3185
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3186
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3187
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3188
        }
3189
    },
3190
    {
3191
        0x0056, "OpSampledImage", 4,
3192
        (struct spirv_parser_instruction_operand[])
3193
        {
3194
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3195
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3196
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3197
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3198
        }
3199
    },
3200
    {
3201
        0x0057, "OpImageSampleImplicitLod", 5,
3202
        (struct spirv_parser_instruction_operand[])
3203
        {
3204
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3205
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3206
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3207
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3208
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3209
        }
3210
    },
3211
    {
3212
        0x0058, "OpImageSampleExplicitLod", 5,
3213
        (struct spirv_parser_instruction_operand[])
3214
        {
3215
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3216
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3217
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3218
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3219
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
3220
        }
3221
    },
3222
    {
3223
        0x0059, "OpImageSampleDrefImplicitLod", 6,
3224
        (struct spirv_parser_instruction_operand[])
3225
        {
3226
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3227
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3228
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3229
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3230
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3231
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3232
        }
3233
    },
3234
    {
3235
        0x005a, "OpImageSampleDrefExplicitLod", 6,
3236
        (struct spirv_parser_instruction_operand[])
3237
        {
3238
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3239
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3240
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3241
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3242
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3243
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
3244
        }
3245
    },
3246
    {
3247
        0x005b, "OpImageSampleProjImplicitLod", 5,
3248
        (struct spirv_parser_instruction_operand[])
3249
        {
3250
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3251
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3252
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3253
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3254
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3255
        }
3256
    },
3257
    {
3258
        0x005c, "OpImageSampleProjExplicitLod", 5,
3259
        (struct spirv_parser_instruction_operand[])
3260
        {
3261
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3262
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3263
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3264
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3265
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
3266
        }
3267
    },
3268
    {
3269
        0x005d, "OpImageSampleProjDrefImplicitLod", 6,
3270
        (struct spirv_parser_instruction_operand[])
3271
        {
3272
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3273
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3274
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3275
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3276
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3277
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3278
        }
3279
    },
3280
    {
3281
        0x005e, "OpImageSampleProjDrefExplicitLod", 6,
3282
        (struct spirv_parser_instruction_operand[])
3283
        {
3284
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3285
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3286
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3287
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3288
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3289
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
3290
        }
3291
    },
3292
    {
3293
        0x005f, "OpImageFetch", 5,
3294
        (struct spirv_parser_instruction_operand[])
3295
        {
3296
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3297
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3298
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3299
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3300
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3301
        }
3302
    },
3303
    {
3304
        0x0060, "OpImageGather", 6,
3305
        (struct spirv_parser_instruction_operand[])
3306
        {
3307
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3308
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3309
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3310
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3311
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3312
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3313
        }
3314
    },
3315
    {
3316
        0x0061, "OpImageDrefGather", 6,
3317
        (struct spirv_parser_instruction_operand[])
3318
        {
3319
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3320
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3321
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3322
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3323
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3324
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3325
        }
3326
    },
3327
    {
3328
        0x0062, "OpImageRead", 5,
3329
        (struct spirv_parser_instruction_operand[])
3330
        {
3331
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3332
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3333
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3334
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3335
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3336
        }
3337
    },
3338
    {
3339
        0x0063, "OpImageWrite", 4,
3340
        (struct spirv_parser_instruction_operand[])
3341
        {
3342
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3343
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3344
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3345
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
3346
        }
3347
    },
3348
    {
3349
        0x0064, "OpImage", 3,
3350
        (struct spirv_parser_instruction_operand[])
3351
        {
3352
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3353
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3354
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3355
        }
3356
    },
3357
    {
3358
        0x0065, "OpImageQueryFormat", 3,
3359
        (struct spirv_parser_instruction_operand[])
3360
        {
3361
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3362
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3363
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3364
        }
3365
    },
3366
    {
3367
        0x0066, "OpImageQueryOrder", 3,
3368
        (struct spirv_parser_instruction_operand[])
3369
        {
3370
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3371
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3372
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3373
        }
3374
    },
3375
    {
3376
        0x0067, "OpImageQuerySizeLod", 4,
3377
        (struct spirv_parser_instruction_operand[])
3378
        {
3379
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3380
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3381
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3382
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3383
        }
3384
    },
3385
    {
3386
        0x0068, "OpImageQuerySize", 3,
3387
        (struct spirv_parser_instruction_operand[])
3388
        {
3389
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3390
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3391
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3392
        }
3393
    },
3394
    {
3395
        0x0069, "OpImageQueryLod", 4,
3396
        (struct spirv_parser_instruction_operand[])
3397
        {
3398
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3399
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3400
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3401
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3402
        }
3403
    },
3404
    {
3405
        0x006a, "OpImageQueryLevels", 3,
3406
        (struct spirv_parser_instruction_operand[])
3407
        {
3408
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3409
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3410
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3411
        }
3412
    },
3413
    {
3414
        0x006b, "OpImageQuerySamples", 3,
3415
        (struct spirv_parser_instruction_operand[])
3416
        {
3417
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3418
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3419
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3420
        }
3421
    },
3422
    {
3423
        0x006d, "OpConvertFToU", 3,
3424
        (struct spirv_parser_instruction_operand[])
3425
        {
3426
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3427
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3428
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3429
        }
3430
    },
3431
    {
3432
        0x006e, "OpConvertFToS", 3,
3433
        (struct spirv_parser_instruction_operand[])
3434
        {
3435
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3436
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3437
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3438
        }
3439
    },
3440
    {
3441
        0x006f, "OpConvertSToF", 3,
3442
        (struct spirv_parser_instruction_operand[])
3443
        {
3444
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3445
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3446
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3447
        }
3448
    },
3449
    {
3450
        0x0070, "OpConvertUToF", 3,
3451
        (struct spirv_parser_instruction_operand[])
3452
        {
3453
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3454
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3455
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3456
        }
3457
    },
3458
    {
3459
        0x0071, "OpUConvert", 3,
3460
        (struct spirv_parser_instruction_operand[])
3461
        {
3462
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3463
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3464
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3465
        }
3466
    },
3467
    {
3468
        0x0072, "OpSConvert", 3,
3469
        (struct spirv_parser_instruction_operand[])
3470
        {
3471
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3472
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3473
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3474
        }
3475
    },
3476
    {
3477
        0x0073, "OpFConvert", 3,
3478
        (struct spirv_parser_instruction_operand[])
3479
        {
3480
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3481
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3482
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3483
        }
3484
    },
3485
    {
3486
        0x0074, "OpQuantizeToF16", 3,
3487
        (struct spirv_parser_instruction_operand[])
3488
        {
3489
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3490
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3491
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3492
        }
3493
    },
3494
    {
3495
        0x0075, "OpConvertPtrToU", 3,
3496
        (struct spirv_parser_instruction_operand[])
3497
        {
3498
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3499
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3500
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3501
        }
3502
    },
3503
    {
3504
        0x0076, "OpSatConvertSToU", 3,
3505
        (struct spirv_parser_instruction_operand[])
3506
        {
3507
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3508
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3509
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3510
        }
3511
    },
3512
    {
3513
        0x0077, "OpSatConvertUToS", 3,
3514
        (struct spirv_parser_instruction_operand[])
3515
        {
3516
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3517
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3518
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3519
        }
3520
    },
3521
    {
3522
        0x0078, "OpConvertUToPtr", 3,
3523
        (struct spirv_parser_instruction_operand[])
3524
        {
3525
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3526
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3527
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3528
        }
3529
    },
3530
    {
3531
        0x0079, "OpPtrCastToGeneric", 3,
3532
        (struct spirv_parser_instruction_operand[])
3533
        {
3534
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3535
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3536
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3537
        }
3538
    },
3539
    {
3540
        0x007a, "OpGenericCastToPtr", 3,
3541
        (struct spirv_parser_instruction_operand[])
3542
        {
3543
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3544
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3545
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3546
        }
3547
    },
3548
    {
3549
        0x007b, "OpGenericCastToPtrExplicit", 4,
3550
        (struct spirv_parser_instruction_operand[])
3551
        {
3552
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3553
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3554
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3555
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
3556
        }
3557
    },
3558
    {
3559
        0x007c, "OpBitcast", 3,
3560
        (struct spirv_parser_instruction_operand[])
3561
        {
3562
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3563
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3564
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3565
        }
3566
    },
3567
    {
3568
        0x007e, "OpSNegate", 3,
3569
        (struct spirv_parser_instruction_operand[])
3570
        {
3571
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3572
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3573
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3574
        }
3575
    },
3576
    {
3577
        0x007f, "OpFNegate", 3,
3578
        (struct spirv_parser_instruction_operand[])
3579
        {
3580
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3581
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3582
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3583
        }
3584
    },
3585
    {
3586
        0x0080, "OpIAdd", 4,
3587
        (struct spirv_parser_instruction_operand[])
3588
        {
3589
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3590
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3591
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3592
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3593
        }
3594
    },
3595
    {
3596
        0x0081, "OpFAdd", 4,
3597
        (struct spirv_parser_instruction_operand[])
3598
        {
3599
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3600
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3601
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3602
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3603
        }
3604
    },
3605
    {
3606
        0x0082, "OpISub", 4,
3607
        (struct spirv_parser_instruction_operand[])
3608
        {
3609
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3610
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3611
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3612
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3613
        }
3614
    },
3615
    {
3616
        0x0083, "OpFSub", 4,
3617
        (struct spirv_parser_instruction_operand[])
3618
        {
3619
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3620
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3621
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3622
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3623
        }
3624
    },
3625
    {
3626
        0x0084, "OpIMul", 4,
3627
        (struct spirv_parser_instruction_operand[])
3628
        {
3629
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3630
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3631
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3632
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3633
        }
3634
    },
3635
    {
3636
        0x0085, "OpFMul", 4,
3637
        (struct spirv_parser_instruction_operand[])
3638
        {
3639
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3640
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3641
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3642
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3643
        }
3644
    },
3645
    {
3646
        0x0086, "OpUDiv", 4,
3647
        (struct spirv_parser_instruction_operand[])
3648
        {
3649
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3650
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3651
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3652
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3653
        }
3654
    },
3655
    {
3656
        0x0087, "OpSDiv", 4,
3657
        (struct spirv_parser_instruction_operand[])
3658
        {
3659
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3660
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3661
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3662
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3663
        }
3664
    },
3665
    {
3666
        0x0088, "OpFDiv", 4,
3667
        (struct spirv_parser_instruction_operand[])
3668
        {
3669
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3670
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3671
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3672
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3673
        }
3674
    },
3675
    {
3676
        0x0089, "OpUMod", 4,
3677
        (struct spirv_parser_instruction_operand[])
3678
        {
3679
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3680
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3681
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3682
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3683
        }
3684
    },
3685
    {
3686
        0x008a, "OpSRem", 4,
3687
        (struct spirv_parser_instruction_operand[])
3688
        {
3689
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3690
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3691
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3692
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3693
        }
3694
    },
3695
    {
3696
        0x008b, "OpSMod", 4,
3697
        (struct spirv_parser_instruction_operand[])
3698
        {
3699
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3700
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3701
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3702
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3703
        }
3704
    },
3705
    {
3706
        0x008c, "OpFRem", 4,
3707
        (struct spirv_parser_instruction_operand[])
3708
        {
3709
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3710
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3711
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3712
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3713
        }
3714
    },
3715
    {
3716
        0x008d, "OpFMod", 4,
3717
        (struct spirv_parser_instruction_operand[])
3718
        {
3719
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3720
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3721
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3722
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3723
        }
3724
    },
3725
    {
3726
        0x008e, "OpVectorTimesScalar", 4,
3727
        (struct spirv_parser_instruction_operand[])
3728
        {
3729
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3730
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3731
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3732
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3733
        }
3734
    },
3735
    {
3736
        0x008f, "OpMatrixTimesScalar", 4,
3737
        (struct spirv_parser_instruction_operand[])
3738
        {
3739
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3740
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3741
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3742
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3743
        }
3744
    },
3745
    {
3746
        0x0090, "OpVectorTimesMatrix", 4,
3747
        (struct spirv_parser_instruction_operand[])
3748
        {
3749
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3750
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3751
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3752
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3753
        }
3754
    },
3755
    {
3756
        0x0091, "OpMatrixTimesVector", 4,
3757
        (struct spirv_parser_instruction_operand[])
3758
        {
3759
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3760
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3761
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3762
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3763
        }
3764
    },
3765
    {
3766
        0x0092, "OpMatrixTimesMatrix", 4,
3767
        (struct spirv_parser_instruction_operand[])
3768
        {
3769
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3770
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3771
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3772
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3773
        }
3774
    },
3775
    {
3776
        0x0093, "OpOuterProduct", 4,
3777
        (struct spirv_parser_instruction_operand[])
3778
        {
3779
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3780
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3781
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3782
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3783
        }
3784
    },
3785
    {
3786
        0x0094, "OpDot", 4,
3787
        (struct spirv_parser_instruction_operand[])
3788
        {
3789
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3790
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3791
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3792
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3793
        }
3794
    },
3795
    {
3796
        0x0095, "OpIAddCarry", 4,
3797
        (struct spirv_parser_instruction_operand[])
3798
        {
3799
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3800
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3801
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3802
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3803
        }
3804
    },
3805
    {
3806
        0x0096, "OpISubBorrow", 4,
3807
        (struct spirv_parser_instruction_operand[])
3808
        {
3809
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3810
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3811
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3812
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3813
        }
3814
    },
3815
    {
3816
        0x0097, "OpUMulExtended", 4,
3817
        (struct spirv_parser_instruction_operand[])
3818
        {
3819
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3820
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3821
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3822
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3823
        }
3824
    },
3825
    {
3826
        0x0098, "OpSMulExtended", 4,
3827
        (struct spirv_parser_instruction_operand[])
3828
        {
3829
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3830
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3831
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3832
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3833
        }
3834
    },
3835
    {
3836
        0x009a, "OpAny", 3,
3837
        (struct spirv_parser_instruction_operand[])
3838
        {
3839
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3840
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3841
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3842
        }
3843
    },
3844
    {
3845
        0x009b, "OpAll", 3,
3846
        (struct spirv_parser_instruction_operand[])
3847
        {
3848
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3849
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3850
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3851
        }
3852
    },
3853
    {
3854
        0x009c, "OpIsNan", 3,
3855
        (struct spirv_parser_instruction_operand[])
3856
        {
3857
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3858
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3859
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3860
        }
3861
    },
3862
    {
3863
        0x009d, "OpIsInf", 3,
3864
        (struct spirv_parser_instruction_operand[])
3865
        {
3866
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3867
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3868
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3869
        }
3870
    },
3871
    {
3872
        0x009e, "OpIsFinite", 3,
3873
        (struct spirv_parser_instruction_operand[])
3874
        {
3875
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3876
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3877
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3878
        }
3879
    },
3880
    {
3881
        0x009f, "OpIsNormal", 3,
3882
        (struct spirv_parser_instruction_operand[])
3883
        {
3884
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3885
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3886
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3887
        }
3888
    },
3889
    {
3890
        0x00a0, "OpSignBitSet", 3,
3891
        (struct spirv_parser_instruction_operand[])
3892
        {
3893
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3894
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3895
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3896
        }
3897
    },
3898
    {
3899
        0x00a1, "OpLessOrGreater", 4,
3900
        (struct spirv_parser_instruction_operand[])
3901
        {
3902
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3903
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3904
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3905
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3906
        }
3907
    },
3908
    {
3909
        0x00a2, "OpOrdered", 4,
3910
        (struct spirv_parser_instruction_operand[])
3911
        {
3912
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3913
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3914
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3915
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3916
        }
3917
    },
3918
    {
3919
        0x00a3, "OpUnordered", 4,
3920
        (struct spirv_parser_instruction_operand[])
3921
        {
3922
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3923
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3924
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3925
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3926
        }
3927
    },
3928
    {
3929
        0x00a4, "OpLogicalEqual", 4,
3930
        (struct spirv_parser_instruction_operand[])
3931
        {
3932
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3933
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3934
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3935
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3936
        }
3937
    },
3938
    {
3939
        0x00a5, "OpLogicalNotEqual", 4,
3940
        (struct spirv_parser_instruction_operand[])
3941
        {
3942
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3943
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3944
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3945
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3946
        }
3947
    },
3948
    {
3949
        0x00a6, "OpLogicalOr", 4,
3950
        (struct spirv_parser_instruction_operand[])
3951
        {
3952
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3953
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3954
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3955
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3956
        }
3957
    },
3958
    {
3959
        0x00a7, "OpLogicalAnd", 4,
3960
        (struct spirv_parser_instruction_operand[])
3961
        {
3962
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3963
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3964
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3965
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3966
        }
3967
    },
3968
    {
3969
        0x00a8, "OpLogicalNot", 3,
3970
        (struct spirv_parser_instruction_operand[])
3971
        {
3972
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3973
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3974
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3975
        }
3976
    },
3977
    {
3978
        0x00a9, "OpSelect", 5,
3979
        (struct spirv_parser_instruction_operand[])
3980
        {
3981
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3982
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3983
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3984
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3985
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3986
        }
3987
    },
3988
    {
3989
        0x00aa, "OpIEqual", 4,
3990
        (struct spirv_parser_instruction_operand[])
3991
        {
3992
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
3993
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
3994
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3995
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
3996
        }
3997
    },
3998
    {
3999
        0x00ab, "OpINotEqual", 4,
4000
        (struct spirv_parser_instruction_operand[])
4001
        {
4002
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4003
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4004
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4005
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4006
        }
4007
    },
4008
    {
4009
        0x00ac, "OpUGreaterThan", 4,
4010
        (struct spirv_parser_instruction_operand[])
4011
        {
4012
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4013
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4014
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4015
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4016
        }
4017
    },
4018
    {
4019
        0x00ad, "OpSGreaterThan", 4,
4020
        (struct spirv_parser_instruction_operand[])
4021
        {
4022
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4023
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4024
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4025
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4026
        }
4027
    },
4028
    {
4029
        0x00ae, "OpUGreaterThanEqual", 4,
4030
        (struct spirv_parser_instruction_operand[])
4031
        {
4032
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4033
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4034
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4035
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4036
        }
4037
    },
4038
    {
4039
        0x00af, "OpSGreaterThanEqual", 4,
4040
        (struct spirv_parser_instruction_operand[])
4041
        {
4042
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4043
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4044
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4045
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4046
        }
4047
    },
4048
    {
4049
        0x00b0, "OpULessThan", 4,
4050
        (struct spirv_parser_instruction_operand[])
4051
        {
4052
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4053
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4054
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4055
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4056
        }
4057
    },
4058
    {
4059
        0x00b1, "OpSLessThan", 4,
4060
        (struct spirv_parser_instruction_operand[])
4061
        {
4062
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4063
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4064
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4065
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4066
        }
4067
    },
4068
    {
4069
        0x00b2, "OpULessThanEqual", 4,
4070
        (struct spirv_parser_instruction_operand[])
4071
        {
4072
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4073
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4074
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4075
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4076
        }
4077
    },
4078
    {
4079
        0x00b3, "OpSLessThanEqual", 4,
4080
        (struct spirv_parser_instruction_operand[])
4081
        {
4082
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4083
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4084
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4085
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4086
        }
4087
    },
4088
    {
4089
        0x00b4, "OpFOrdEqual", 4,
4090
        (struct spirv_parser_instruction_operand[])
4091
        {
4092
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4093
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4094
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4095
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4096
        }
4097
    },
4098
    {
4099
        0x00b5, "OpFUnordEqual", 4,
4100
        (struct spirv_parser_instruction_operand[])
4101
        {
4102
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4103
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4104
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4105
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4106
        }
4107
    },
4108
    {
4109
        0x00b6, "OpFOrdNotEqual", 4,
4110
        (struct spirv_parser_instruction_operand[])
4111
        {
4112
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4113
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4114
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4115
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4116
        }
4117
    },
4118
    {
4119
        0x00b7, "OpFUnordNotEqual", 4,
4120
        (struct spirv_parser_instruction_operand[])
4121
        {
4122
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4123
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4124
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4125
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4126
        }
4127
    },
4128
    {
4129
        0x00b8, "OpFOrdLessThan", 4,
4130
        (struct spirv_parser_instruction_operand[])
4131
        {
4132
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4133
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4134
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4135
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4136
        }
4137
    },
4138
    {
4139
        0x00b9, "OpFUnordLessThan", 4,
4140
        (struct spirv_parser_instruction_operand[])
4141
        {
4142
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4143
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4144
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4145
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4146
        }
4147
    },
4148
    {
4149
        0x00ba, "OpFOrdGreaterThan", 4,
4150
        (struct spirv_parser_instruction_operand[])
4151
        {
4152
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4153
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4154
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4155
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4156
        }
4157
    },
4158
    {
4159
        0x00bb, "OpFUnordGreaterThan", 4,
4160
        (struct spirv_parser_instruction_operand[])
4161
        {
4162
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4163
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4164
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4165
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4166
        }
4167
    },
4168
    {
4169
        0x00bc, "OpFOrdLessThanEqual", 4,
4170
        (struct spirv_parser_instruction_operand[])
4171
        {
4172
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4173
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4174
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4175
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4176
        }
4177
    },
4178
    {
4179
        0x00bd, "OpFUnordLessThanEqual", 4,
4180
        (struct spirv_parser_instruction_operand[])
4181
        {
4182
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4183
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4184
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4185
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4186
        }
4187
    },
4188
    {
4189
        0x00be, "OpFOrdGreaterThanEqual", 4,
4190
        (struct spirv_parser_instruction_operand[])
4191
        {
4192
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4193
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4194
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4195
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4196
        }
4197
    },
4198
    {
4199
        0x00bf, "OpFUnordGreaterThanEqual", 4,
4200
        (struct spirv_parser_instruction_operand[])
4201
        {
4202
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4203
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4204
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4205
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4206
        }
4207
    },
4208
    {
4209
        0x00c2, "OpShiftRightLogical", 4,
4210
        (struct spirv_parser_instruction_operand[])
4211
        {
4212
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4213
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4214
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4215
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4216
        }
4217
    },
4218
    {
4219
        0x00c3, "OpShiftRightArithmetic", 4,
4220
        (struct spirv_parser_instruction_operand[])
4221
        {
4222
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4223
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4224
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4225
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4226
        }
4227
    },
4228
    {
4229
        0x00c4, "OpShiftLeftLogical", 4,
4230
        (struct spirv_parser_instruction_operand[])
4231
        {
4232
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4233
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4234
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4235
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4236
        }
4237
    },
4238
    {
4239
        0x00c5, "OpBitwiseOr", 4,
4240
        (struct spirv_parser_instruction_operand[])
4241
        {
4242
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4243
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4244
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4245
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4246
        }
4247
    },
4248
    {
4249
        0x00c6, "OpBitwiseXor", 4,
4250
        (struct spirv_parser_instruction_operand[])
4251
        {
4252
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4253
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4254
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4255
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4256
        }
4257
    },
4258
    {
4259
        0x00c7, "OpBitwiseAnd", 4,
4260
        (struct spirv_parser_instruction_operand[])
4261
        {
4262
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4263
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4264
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4265
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4266
        }
4267
    },
4268
    {
4269
        0x00c8, "OpNot", 3,
4270
        (struct spirv_parser_instruction_operand[])
4271
        {
4272
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4273
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4274
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4275
        }
4276
    },
4277
    {
4278
        0x00c9, "OpBitFieldInsert", 6,
4279
        (struct spirv_parser_instruction_operand[])
4280
        {
4281
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4282
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4283
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4284
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4285
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4286
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4287
        }
4288
    },
4289
    {
4290
        0x00ca, "OpBitFieldSExtract", 5,
4291
        (struct spirv_parser_instruction_operand[])
4292
        {
4293
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4294
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4295
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4296
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4297
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4298
        }
4299
    },
4300
    {
4301
        0x00cb, "OpBitFieldUExtract", 5,
4302
        (struct spirv_parser_instruction_operand[])
4303
        {
4304
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4305
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4306
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4307
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4308
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4309
        }
4310
    },
4311
    {
4312
        0x00cc, "OpBitReverse", 3,
4313
        (struct spirv_parser_instruction_operand[])
4314
        {
4315
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4316
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4317
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4318
        }
4319
    },
4320
    {
4321
        0x00cd, "OpBitCount", 3,
4322
        (struct spirv_parser_instruction_operand[])
4323
        {
4324
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4325
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4326
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4327
        }
4328
    },
4329
    {
4330
        0x00cf, "OpDPdx", 3,
4331
        (struct spirv_parser_instruction_operand[])
4332
        {
4333
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4334
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4335
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4336
        }
4337
    },
4338
    {
4339
        0x00d0, "OpDPdy", 3,
4340
        (struct spirv_parser_instruction_operand[])
4341
        {
4342
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4343
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4344
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4345
        }
4346
    },
4347
    {
4348
        0x00d1, "OpFwidth", 3,
4349
        (struct spirv_parser_instruction_operand[])
4350
        {
4351
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4352
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4353
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4354
        }
4355
    },
4356
    {
4357
        0x00d2, "OpDPdxFine", 3,
4358
        (struct spirv_parser_instruction_operand[])
4359
        {
4360
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4361
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4362
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4363
        }
4364
    },
4365
    {
4366
        0x00d3, "OpDPdyFine", 3,
4367
        (struct spirv_parser_instruction_operand[])
4368
        {
4369
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4370
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4371
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4372
        }
4373
    },
4374
    {
4375
        0x00d4, "OpFwidthFine", 3,
4376
        (struct spirv_parser_instruction_operand[])
4377
        {
4378
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4379
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4380
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4381
        }
4382
    },
4383
    {
4384
        0x00d5, "OpDPdxCoarse", 3,
4385
        (struct spirv_parser_instruction_operand[])
4386
        {
4387
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4388
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4389
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4390
        }
4391
    },
4392
    {
4393
        0x00d6, "OpDPdyCoarse", 3,
4394
        (struct spirv_parser_instruction_operand[])
4395
        {
4396
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4397
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4398
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4399
        }
4400
    },
4401
    {
4402
        0x00d7, "OpFwidthCoarse", 3,
4403
        (struct spirv_parser_instruction_operand[])
4404
        {
4405
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4406
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4407
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4408
        }
4409
    },
4410
    {0x00da, "OpEmitVertex"},
4411
    {0x00db, "OpEndPrimitive"},
4412
    {
4413
        0x00dc, "OpEmitStreamVertex", 1,
4414
        (struct spirv_parser_instruction_operand[])
4415
        {
4416
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4417
        }
4418
    },
4419
    {
4420
        0x00dd, "OpEndStreamPrimitive", 1,
4421
        (struct spirv_parser_instruction_operand[])
4422
        {
4423
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4424
        }
4425
    },
4426
    {
4427
        0x00e0, "OpControlBarrier", 3,
4428
        (struct spirv_parser_instruction_operand[])
4429
        {
4430
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4431
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4432
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4433
        }
4434
    },
4435
    {
4436
        0x00e1, "OpMemoryBarrier", 2,
4437
        (struct spirv_parser_instruction_operand[])
4438
        {
4439
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4440
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4441
        }
4442
    },
4443
    {
4444
        0x00e3, "OpAtomicLoad", 5,
4445
        (struct spirv_parser_instruction_operand[])
4446
        {
4447
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4448
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4449
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4450
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4451
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4452
        }
4453
    },
4454
    {
4455
        0x00e4, "OpAtomicStore", 4,
4456
        (struct spirv_parser_instruction_operand[])
4457
        {
4458
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4459
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4460
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4461
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4462
        }
4463
    },
4464
    {
4465
        0x00e5, "OpAtomicExchange", 6,
4466
        (struct spirv_parser_instruction_operand[])
4467
        {
4468
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4469
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4470
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4471
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4472
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4473
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4474
        }
4475
    },
4476
    {
4477
        0x00e6, "OpAtomicCompareExchange", 8,
4478
        (struct spirv_parser_instruction_operand[])
4479
        {
4480
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4481
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4482
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4483
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4484
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4485
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4486
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4487
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4488
        }
4489
    },
4490
    {
4491
        0x00e7, "OpAtomicCompareExchangeWeak", 8,
4492
        (struct spirv_parser_instruction_operand[])
4493
        {
4494
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4495
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4496
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4497
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4498
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4499
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4500
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4501
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4502
        }
4503
    },
4504
    {
4505
        0x00e8, "OpAtomicIIncrement", 5,
4506
        (struct spirv_parser_instruction_operand[])
4507
        {
4508
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4509
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4510
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4511
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4512
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4513
        }
4514
    },
4515
    {
4516
        0x00e9, "OpAtomicIDecrement", 5,
4517
        (struct spirv_parser_instruction_operand[])
4518
        {
4519
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4520
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4521
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4522
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4523
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4524
        }
4525
    },
4526
    {
4527
        0x00ea, "OpAtomicIAdd", 6,
4528
        (struct spirv_parser_instruction_operand[])
4529
        {
4530
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4531
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4532
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4533
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4534
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4535
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4536
        }
4537
    },
4538
    {
4539
        0x00eb, "OpAtomicISub", 6,
4540
        (struct spirv_parser_instruction_operand[])
4541
        {
4542
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4543
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4544
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4545
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4546
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4547
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4548
        }
4549
    },
4550
    {
4551
        0x00ec, "OpAtomicSMin", 6,
4552
        (struct spirv_parser_instruction_operand[])
4553
        {
4554
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4555
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4556
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4557
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4558
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4559
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4560
        }
4561
    },
4562
    {
4563
        0x00ed, "OpAtomicUMin", 6,
4564
        (struct spirv_parser_instruction_operand[])
4565
        {
4566
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4567
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4568
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4569
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4570
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4571
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4572
        }
4573
    },
4574
    {
4575
        0x00ee, "OpAtomicSMax", 6,
4576
        (struct spirv_parser_instruction_operand[])
4577
        {
4578
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4579
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4580
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4581
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4582
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4583
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4584
        }
4585
    },
4586
    {
4587
        0x00ef, "OpAtomicUMax", 6,
4588
        (struct spirv_parser_instruction_operand[])
4589
        {
4590
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4591
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4592
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4593
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4594
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4595
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4596
        }
4597
    },
4598
    {
4599
        0x00f0, "OpAtomicAnd", 6,
4600
        (struct spirv_parser_instruction_operand[])
4601
        {
4602
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4603
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4604
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4605
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4606
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4607
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4608
        }
4609
    },
4610
    {
4611
        0x00f1, "OpAtomicOr", 6,
4612
        (struct spirv_parser_instruction_operand[])
4613
        {
4614
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4615
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4616
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4617
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4618
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4619
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4620
        }
4621
    },
4622
    {
4623
        0x00f2, "OpAtomicXor", 6,
4624
        (struct spirv_parser_instruction_operand[])
4625
        {
4626
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4627
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4628
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4629
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4630
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
4631
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4632
        }
4633
    },
4634
    {
4635
        0x00f5, "OpPhi", 3,
4636
        (struct spirv_parser_instruction_operand[])
4637
        {
4638
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4639
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4640
            {SPIRV_PARSER_OPERAND_TYPE_PAIR_ID_REF_ID_REF, '*'},
4641
        }
4642
    },
4643
    {
4644
        0x00f6, "OpLoopMerge", 3,
4645
        (struct spirv_parser_instruction_operand[])
4646
        {
4647
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4648
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4649
            {SPIRV_PARSER_OPERAND_TYPE_LOOP_CONTROL},
4650
        }
4651
    },
4652
    {
4653
        0x00f7, "OpSelectionMerge", 2,
4654
        (struct spirv_parser_instruction_operand[])
4655
        {
4656
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4657
            {SPIRV_PARSER_OPERAND_TYPE_SELECTION_CONTROL},
4658
        }
4659
    },
4660
    {
4661
        0x00f8, "OpLabel", 1,
4662
        (struct spirv_parser_instruction_operand[])
4663
        {
4664
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4665
        }
4666
    },
4667
    {
4668
        0x00f9, "OpBranch", 1,
4669
        (struct spirv_parser_instruction_operand[])
4670
        {
4671
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4672
        }
4673
    },
4674
    {
4675
        0x00fa, "OpBranchConditional", 4,
4676
        (struct spirv_parser_instruction_operand[])
4677
        {
4678
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4679
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4680
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4681
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER, '*'},
4682
        }
4683
    },
4684
    {
4685
        0x00fb, "OpSwitch", 3,
4686
        (struct spirv_parser_instruction_operand[])
4687
        {
4688
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4689
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4690
            {SPIRV_PARSER_OPERAND_TYPE_PAIR_LITERAL_INTEGER_ID_REF, '*'},
4691
        }
4692
    },
4693
    {0x00fc, "OpKill"},
4694
    {0x00fd, "OpReturn"},
4695
    {
4696
        0x00fe, "OpReturnValue", 1,
4697
        (struct spirv_parser_instruction_operand[])
4698
        {
4699
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4700
        }
4701
    },
4702
    {0x00ff, "OpUnreachable"},
4703
    {
4704
        0x0100, "OpLifetimeStart", 2,
4705
        (struct spirv_parser_instruction_operand[])
4706
        {
4707
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4708
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
4709
        }
4710
    },
4711
    {
4712
        0x0101, "OpLifetimeStop", 2,
4713
        (struct spirv_parser_instruction_operand[])
4714
        {
4715
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4716
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
4717
        }
4718
    },
4719
    {
4720
        0x0103, "OpGroupAsyncCopy", 8,
4721
        (struct spirv_parser_instruction_operand[])
4722
        {
4723
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4724
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4725
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4726
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4727
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4728
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4729
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4730
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4731
        }
4732
    },
4733
    {
4734
        0x0104, "OpGroupWaitEvents", 3,
4735
        (struct spirv_parser_instruction_operand[])
4736
        {
4737
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4738
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4739
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4740
        }
4741
    },
4742
    {
4743
        0x0105, "OpGroupAll", 4,
4744
        (struct spirv_parser_instruction_operand[])
4745
        {
4746
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4747
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4748
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4749
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4750
        }
4751
    },
4752
    {
4753
        0x0106, "OpGroupAny", 4,
4754
        (struct spirv_parser_instruction_operand[])
4755
        {
4756
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4757
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4758
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4759
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4760
        }
4761
    },
4762
    {
4763
        0x0107, "OpGroupBroadcast", 5,
4764
        (struct spirv_parser_instruction_operand[])
4765
        {
4766
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4767
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4768
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4769
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4770
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4771
        }
4772
    },
4773
    {
4774
        0x0108, "OpGroupIAdd", 5,
4775
        (struct spirv_parser_instruction_operand[])
4776
        {
4777
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4778
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4779
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4780
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4781
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4782
        }
4783
    },
4784
    {
4785
        0x0109, "OpGroupFAdd", 5,
4786
        (struct spirv_parser_instruction_operand[])
4787
        {
4788
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4789
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4790
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4791
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4792
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4793
        }
4794
    },
4795
    {
4796
        0x010a, "OpGroupFMin", 5,
4797
        (struct spirv_parser_instruction_operand[])
4798
        {
4799
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4800
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4801
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4802
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4803
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4804
        }
4805
    },
4806
    {
4807
        0x010b, "OpGroupUMin", 5,
4808
        (struct spirv_parser_instruction_operand[])
4809
        {
4810
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4811
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4812
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4813
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4814
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4815
        }
4816
    },
4817
    {
4818
        0x010c, "OpGroupSMin", 5,
4819
        (struct spirv_parser_instruction_operand[])
4820
        {
4821
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4822
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4823
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4824
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4825
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4826
        }
4827
    },
4828
    {
4829
        0x010d, "OpGroupFMax", 5,
4830
        (struct spirv_parser_instruction_operand[])
4831
        {
4832
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4833
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4834
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4835
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4836
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4837
        }
4838
    },
4839
    {
4840
        0x010e, "OpGroupUMax", 5,
4841
        (struct spirv_parser_instruction_operand[])
4842
        {
4843
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4844
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4845
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4846
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4847
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4848
        }
4849
    },
4850
    {
4851
        0x010f, "OpGroupSMax", 5,
4852
        (struct spirv_parser_instruction_operand[])
4853
        {
4854
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4855
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4856
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4857
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
4858
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4859
        }
4860
    },
4861
    {
4862
        0x0112, "OpReadPipe", 6,
4863
        (struct spirv_parser_instruction_operand[])
4864
        {
4865
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4866
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4867
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4868
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4869
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4870
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4871
        }
4872
    },
4873
    {
4874
        0x0113, "OpWritePipe", 6,
4875
        (struct spirv_parser_instruction_operand[])
4876
        {
4877
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4878
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4879
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4880
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4881
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4882
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4883
        }
4884
    },
4885
    {
4886
        0x0114, "OpReservedReadPipe", 8,
4887
        (struct spirv_parser_instruction_operand[])
4888
        {
4889
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4890
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4891
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4892
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4893
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4894
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4895
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4896
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4897
        }
4898
    },
4899
    {
4900
        0x0115, "OpReservedWritePipe", 8,
4901
        (struct spirv_parser_instruction_operand[])
4902
        {
4903
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4904
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4905
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4906
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4907
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4908
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4909
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4910
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4911
        }
4912
    },
4913
    {
4914
        0x0116, "OpReserveReadPipePackets", 6,
4915
        (struct spirv_parser_instruction_operand[])
4916
        {
4917
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4918
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4919
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4920
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4921
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4922
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4923
        }
4924
    },
4925
    {
4926
        0x0117, "OpReserveWritePipePackets", 6,
4927
        (struct spirv_parser_instruction_operand[])
4928
        {
4929
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4930
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4931
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4932
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4933
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4934
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4935
        }
4936
    },
4937
    {
4938
        0x0118, "OpCommitReadPipe", 4,
4939
        (struct spirv_parser_instruction_operand[])
4940
        {
4941
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4942
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4943
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4944
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4945
        }
4946
    },
4947
    {
4948
        0x0119, "OpCommitWritePipe", 4,
4949
        (struct spirv_parser_instruction_operand[])
4950
        {
4951
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4952
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4953
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4954
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4955
        }
4956
    },
4957
    {
4958
        0x011a, "OpIsValidReserveId", 3,
4959
        (struct spirv_parser_instruction_operand[])
4960
        {
4961
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4962
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4963
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4964
        }
4965
    },
4966
    {
4967
        0x011b, "OpGetNumPipePackets", 5,
4968
        (struct spirv_parser_instruction_operand[])
4969
        {
4970
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4971
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4972
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4973
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4974
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4975
        }
4976
    },
4977
    {
4978
        0x011c, "OpGetMaxPipePackets", 5,
4979
        (struct spirv_parser_instruction_operand[])
4980
        {
4981
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4982
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4983
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4984
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4985
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4986
        }
4987
    },
4988
    {
4989
        0x011d, "OpGroupReserveReadPipePackets", 7,
4990
        (struct spirv_parser_instruction_operand[])
4991
        {
4992
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
4993
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
4994
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
4995
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4996
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4997
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4998
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
4999
        }
5000
    },
5001
    {
5002
        0x011e, "OpGroupReserveWritePipePackets", 7,
5003
        (struct spirv_parser_instruction_operand[])
5004
        {
5005
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5006
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5007
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5008
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5009
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5010
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5011
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5012
        }
5013
    },
5014
    {
5015
        0x011f, "OpGroupCommitReadPipe", 5,
5016
        (struct spirv_parser_instruction_operand[])
5017
        {
5018
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5019
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5020
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5021
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5022
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5023
        }
5024
    },
5025
    {
5026
        0x0120, "OpGroupCommitWritePipe", 5,
5027
        (struct spirv_parser_instruction_operand[])
5028
        {
5029
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5030
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5031
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5032
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5033
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5034
        }
5035
    },
5036
    {
5037
        0x0123, "OpEnqueueMarker", 6,
5038
        (struct spirv_parser_instruction_operand[])
5039
        {
5040
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5041
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5042
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5043
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5044
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5045
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5046
        }
5047
    },
5048
    {
5049
        0x0124, "OpEnqueueKernel", 13,
5050
        (struct spirv_parser_instruction_operand[])
5051
        {
5052
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5053
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5054
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5055
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5056
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5057
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5058
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5059
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5060
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5061
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5062
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5063
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5064
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
5065
        }
5066
    },
5067
    {
5068
        0x0125, "OpGetKernelNDrangeSubGroupCount", 7,
5069
        (struct spirv_parser_instruction_operand[])
5070
        {
5071
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5072
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5073
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5074
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5075
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5076
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5077
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5078
        }
5079
    },
5080
    {
5081
        0x0126, "OpGetKernelNDrangeMaxSubGroupSize", 7,
5082
        (struct spirv_parser_instruction_operand[])
5083
        {
5084
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5085
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5086
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5087
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5088
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5089
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5090
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5091
        }
5092
    },
5093
    {
5094
        0x0127, "OpGetKernelWorkGroupSize", 6,
5095
        (struct spirv_parser_instruction_operand[])
5096
        {
5097
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5098
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5099
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5100
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5101
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5102
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5103
        }
5104
    },
5105
    {
5106
        0x0128, "OpGetKernelPreferredWorkGroupSizeMultiple", 6,
5107
        (struct spirv_parser_instruction_operand[])
5108
        {
5109
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5110
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5111
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5112
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5113
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5114
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5115
        }
5116
    },
5117
    {
5118
        0x0129, "OpRetainEvent", 1,
5119
        (struct spirv_parser_instruction_operand[])
5120
        {
5121
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5122
        }
5123
    },
5124
    {
5125
        0x012a, "OpReleaseEvent", 1,
5126
        (struct spirv_parser_instruction_operand[])
5127
        {
5128
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5129
        }
5130
    },
5131
    {
5132
        0x012b, "OpCreateUserEvent", 2,
5133
        (struct spirv_parser_instruction_operand[])
5134
        {
5135
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5136
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5137
        }
5138
    },
5139
    {
5140
        0x012c, "OpIsValidEvent", 3,
5141
        (struct spirv_parser_instruction_operand[])
5142
        {
5143
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5144
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5145
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5146
        }
5147
    },
5148
    {
5149
        0x012d, "OpSetUserEventStatus", 2,
5150
        (struct spirv_parser_instruction_operand[])
5151
        {
5152
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5153
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5154
        }
5155
    },
5156
    {
5157
        0x012e, "OpCaptureEventProfilingInfo", 3,
5158
        (struct spirv_parser_instruction_operand[])
5159
        {
5160
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5161
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5162
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5163
        }
5164
    },
5165
    {
5166
        0x012f, "OpGetDefaultQueue", 2,
5167
        (struct spirv_parser_instruction_operand[])
5168
        {
5169
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5170
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5171
        }
5172
    },
5173
    {
5174
        0x0130, "OpBuildNDRange", 5,
5175
        (struct spirv_parser_instruction_operand[])
5176
        {
5177
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5178
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5179
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5180
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5181
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5182
        }
5183
    },
5184
    {
5185
        0x0131, "OpImageSparseSampleImplicitLod", 5,
5186
        (struct spirv_parser_instruction_operand[])
5187
        {
5188
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5189
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5190
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5191
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5192
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5193
        }
5194
    },
5195
    {
5196
        0x0132, "OpImageSparseSampleExplicitLod", 5,
5197
        (struct spirv_parser_instruction_operand[])
5198
        {
5199
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5200
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5201
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5202
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5203
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
5204
        }
5205
    },
5206
    {
5207
        0x0133, "OpImageSparseSampleDrefImplicitLod", 6,
5208
        (struct spirv_parser_instruction_operand[])
5209
        {
5210
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5211
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5212
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5213
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5214
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5215
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5216
        }
5217
    },
5218
    {
5219
        0x0134, "OpImageSparseSampleDrefExplicitLod", 6,
5220
        (struct spirv_parser_instruction_operand[])
5221
        {
5222
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5223
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5224
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5225
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5226
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5227
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
5228
        }
5229
    },
5230
    {
5231
        0x0135, "OpImageSparseSampleProjImplicitLod", 5,
5232
        (struct spirv_parser_instruction_operand[])
5233
        {
5234
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5235
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5236
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5237
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5238
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5239
        }
5240
    },
5241
    {
5242
        0x0136, "OpImageSparseSampleProjExplicitLod", 5,
5243
        (struct spirv_parser_instruction_operand[])
5244
        {
5245
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5246
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5247
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5248
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5249
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
5250
        }
5251
    },
5252
    {
5253
        0x0137, "OpImageSparseSampleProjDrefImplicitLod", 6,
5254
        (struct spirv_parser_instruction_operand[])
5255
        {
5256
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5257
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5258
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5259
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5260
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5261
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5262
        }
5263
    },
5264
    {
5265
        0x0138, "OpImageSparseSampleProjDrefExplicitLod", 6,
5266
        (struct spirv_parser_instruction_operand[])
5267
        {
5268
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5269
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5270
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5271
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5272
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5273
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS},
5274
        }
5275
    },
5276
    {
5277
        0x0139, "OpImageSparseFetch", 5,
5278
        (struct spirv_parser_instruction_operand[])
5279
        {
5280
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5281
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5282
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5283
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5284
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5285
        }
5286
    },
5287
    {
5288
        0x013a, "OpImageSparseGather", 6,
5289
        (struct spirv_parser_instruction_operand[])
5290
        {
5291
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5292
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5293
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5294
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5295
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5296
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5297
        }
5298
    },
5299
    {
5300
        0x013b, "OpImageSparseDrefGather", 6,
5301
        (struct spirv_parser_instruction_operand[])
5302
        {
5303
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5304
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5305
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5306
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5307
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5308
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5309
        }
5310
    },
5311
    {
5312
        0x013c, "OpImageSparseTexelsResident", 3,
5313
        (struct spirv_parser_instruction_operand[])
5314
        {
5315
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5316
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5317
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5318
        }
5319
    },
5320
    {0x013d, "OpNoLine"},
5321
    {
5322
        0x013e, "OpAtomicFlagTestAndSet", 5,
5323
        (struct spirv_parser_instruction_operand[])
5324
        {
5325
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5326
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5327
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5328
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5329
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
5330
        }
5331
    },
5332
    {
5333
        0x013f, "OpAtomicFlagClear", 3,
5334
        (struct spirv_parser_instruction_operand[])
5335
        {
5336
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5337
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5338
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
5339
        }
5340
    },
5341
    {
5342
        0x0140, "OpImageSparseRead", 5,
5343
        (struct spirv_parser_instruction_operand[])
5344
        {
5345
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5346
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5347
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5348
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5349
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
5350
        }
5351
    },
5352
    {
5353
        0x0141, "OpSizeOf", 3,
5354
        (struct spirv_parser_instruction_operand[])
5355
        {
5356
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5357
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5358
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5359
        }
5360
    },
5361
    {
5362
        0x0142, "OpTypePipeStorage", 1,
5363
        (struct spirv_parser_instruction_operand[])
5364
        {
5365
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5366
        }
5367
    },
5368
    {
5369
        0x0143, "OpConstantPipeStorage", 5,
5370
        (struct spirv_parser_instruction_operand[])
5371
        {
5372
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5373
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5374
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
5375
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
5376
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
5377
        }
5378
    },
5379
    {
5380
        0x0144, "OpCreatePipeFromPipeStorage", 3,
5381
        (struct spirv_parser_instruction_operand[])
5382
        {
5383
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5384
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5385
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5386
        }
5387
    },
5388
    {
5389
        0x0145, "OpGetKernelLocalSizeForSubgroupCount", 7,
5390
        (struct spirv_parser_instruction_operand[])
5391
        {
5392
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5393
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5394
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5395
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5396
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5397
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5398
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5399
        }
5400
    },
5401
    {
5402
        0x0146, "OpGetKernelMaxNumSubgroups", 6,
5403
        (struct spirv_parser_instruction_operand[])
5404
        {
5405
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5406
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5407
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5408
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5409
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5410
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5411
        }
5412
    },
5413
    {
5414
        0x0147, "OpTypeNamedBarrier", 1,
5415
        (struct spirv_parser_instruction_operand[])
5416
        {
5417
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5418
        }
5419
    },
5420
    {
5421
        0x0148, "OpNamedBarrierInitialize", 3,
5422
        (struct spirv_parser_instruction_operand[])
5423
        {
5424
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5425
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5426
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5427
        }
5428
    },
5429
    {
5430
        0x0149, "OpMemoryNamedBarrier", 3,
5431
        (struct spirv_parser_instruction_operand[])
5432
        {
5433
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5434
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5435
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
5436
        }
5437
    },
5438
    {
5439
        0x014a, "OpModuleProcessed", 1,
5440
        (struct spirv_parser_instruction_operand[])
5441
        {
5442
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
5443
        }
5444
    },
5445
    {
5446
        0x014b, "OpExecutionModeId", 2,
5447
        (struct spirv_parser_instruction_operand[])
5448
        {
5449
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5450
            {SPIRV_PARSER_OPERAND_TYPE_EXECUTION_MODE},
5451
        }
5452
    },
5453
    {
5454
        0x014c, "OpDecorateId", 2,
5455
        (struct spirv_parser_instruction_operand[])
5456
        {
5457
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5458
            {SPIRV_PARSER_OPERAND_TYPE_DECORATION},
5459
        }
5460
    },
5461
    {
5462
        0x014d, "OpGroupNonUniformElect", 3,
5463
        (struct spirv_parser_instruction_operand[])
5464
        {
5465
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5466
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5467
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5468
        }
5469
    },
5470
    {
5471
        0x014e, "OpGroupNonUniformAll", 4,
5472
        (struct spirv_parser_instruction_operand[])
5473
        {
5474
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5475
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5476
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5477
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5478
        }
5479
    },
5480
    {
5481
        0x014f, "OpGroupNonUniformAny", 4,
5482
        (struct spirv_parser_instruction_operand[])
5483
        {
5484
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5485
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5486
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5487
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5488
        }
5489
    },
5490
    {
5491
        0x0150, "OpGroupNonUniformAllEqual", 4,
5492
        (struct spirv_parser_instruction_operand[])
5493
        {
5494
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5495
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5496
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5497
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5498
        }
5499
    },
5500
    {
5501
        0x0151, "OpGroupNonUniformBroadcast", 5,
5502
        (struct spirv_parser_instruction_operand[])
5503
        {
5504
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5505
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5506
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5507
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5508
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5509
        }
5510
    },
5511
    {
5512
        0x0152, "OpGroupNonUniformBroadcastFirst", 4,
5513
        (struct spirv_parser_instruction_operand[])
5514
        {
5515
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5516
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5517
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5518
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5519
        }
5520
    },
5521
    {
5522
        0x0153, "OpGroupNonUniformBallot", 4,
5523
        (struct spirv_parser_instruction_operand[])
5524
        {
5525
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5526
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5527
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5528
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5529
        }
5530
    },
5531
    {
5532
        0x0154, "OpGroupNonUniformInverseBallot", 4,
5533
        (struct spirv_parser_instruction_operand[])
5534
        {
5535
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5536
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5537
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5538
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5539
        }
5540
    },
5541
    {
5542
        0x0155, "OpGroupNonUniformBallotBitExtract", 5,
5543
        (struct spirv_parser_instruction_operand[])
5544
        {
5545
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5546
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5547
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5548
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5549
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5550
        }
5551
    },
5552
    {
5553
        0x0156, "OpGroupNonUniformBallotBitCount", 5,
5554
        (struct spirv_parser_instruction_operand[])
5555
        {
5556
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5557
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5558
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5559
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5560
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5561
        }
5562
    },
5563
    {
5564
        0x0157, "OpGroupNonUniformBallotFindLSB", 4,
5565
        (struct spirv_parser_instruction_operand[])
5566
        {
5567
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5568
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5569
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5570
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5571
        }
5572
    },
5573
    {
5574
        0x0158, "OpGroupNonUniformBallotFindMSB", 4,
5575
        (struct spirv_parser_instruction_operand[])
5576
        {
5577
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5578
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5579
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5580
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5581
        }
5582
    },
5583
    {
5584
        0x0159, "OpGroupNonUniformShuffle", 5,
5585
        (struct spirv_parser_instruction_operand[])
5586
        {
5587
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5588
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5589
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5590
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5591
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5592
        }
5593
    },
5594
    {
5595
        0x015a, "OpGroupNonUniformShuffleXor", 5,
5596
        (struct spirv_parser_instruction_operand[])
5597
        {
5598
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5599
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5600
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5601
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5602
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5603
        }
5604
    },
5605
    {
5606
        0x015b, "OpGroupNonUniformShuffleUp", 5,
5607
        (struct spirv_parser_instruction_operand[])
5608
        {
5609
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5610
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5611
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5612
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5613
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5614
        }
5615
    },
5616
    {
5617
        0x015c, "OpGroupNonUniformShuffleDown", 5,
5618
        (struct spirv_parser_instruction_operand[])
5619
        {
5620
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5621
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5622
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5623
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5624
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5625
        }
5626
    },
5627
    {
5628
        0x015d, "OpGroupNonUniformIAdd", 6,
5629
        (struct spirv_parser_instruction_operand[])
5630
        {
5631
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5632
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5633
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5634
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5635
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5636
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5637
        }
5638
    },
5639
    {
5640
        0x015e, "OpGroupNonUniformFAdd", 6,
5641
        (struct spirv_parser_instruction_operand[])
5642
        {
5643
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5644
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5645
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5646
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5647
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5648
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5649
        }
5650
    },
5651
    {
5652
        0x015f, "OpGroupNonUniformIMul", 6,
5653
        (struct spirv_parser_instruction_operand[])
5654
        {
5655
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5656
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5657
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5658
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5659
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5660
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5661
        }
5662
    },
5663
    {
5664
        0x0160, "OpGroupNonUniformFMul", 6,
5665
        (struct spirv_parser_instruction_operand[])
5666
        {
5667
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5668
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5669
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5670
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5671
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5672
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5673
        }
5674
    },
5675
    {
5676
        0x0161, "OpGroupNonUniformSMin", 6,
5677
        (struct spirv_parser_instruction_operand[])
5678
        {
5679
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5680
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5681
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5682
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5683
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5684
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5685
        }
5686
    },
5687
    {
5688
        0x0162, "OpGroupNonUniformUMin", 6,
5689
        (struct spirv_parser_instruction_operand[])
5690
        {
5691
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5692
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5693
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5694
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5695
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5696
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5697
        }
5698
    },
5699
    {
5700
        0x0163, "OpGroupNonUniformFMin", 6,
5701
        (struct spirv_parser_instruction_operand[])
5702
        {
5703
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5704
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5705
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5706
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5707
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5708
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5709
        }
5710
    },
5711
    {
5712
        0x0164, "OpGroupNonUniformSMax", 6,
5713
        (struct spirv_parser_instruction_operand[])
5714
        {
5715
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5716
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5717
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5718
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5719
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5720
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5721
        }
5722
    },
5723
    {
5724
        0x0165, "OpGroupNonUniformUMax", 6,
5725
        (struct spirv_parser_instruction_operand[])
5726
        {
5727
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5728
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5729
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5730
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5731
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5732
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5733
        }
5734
    },
5735
    {
5736
        0x0166, "OpGroupNonUniformFMax", 6,
5737
        (struct spirv_parser_instruction_operand[])
5738
        {
5739
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5740
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5741
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5742
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5743
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5744
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5745
        }
5746
    },
5747
    {
5748
        0x0167, "OpGroupNonUniformBitwiseAnd", 6,
5749
        (struct spirv_parser_instruction_operand[])
5750
        {
5751
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5752
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5753
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5754
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5755
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5756
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5757
        }
5758
    },
5759
    {
5760
        0x0168, "OpGroupNonUniformBitwiseOr", 6,
5761
        (struct spirv_parser_instruction_operand[])
5762
        {
5763
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5764
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5765
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5766
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5767
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5768
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5769
        }
5770
    },
5771
    {
5772
        0x0169, "OpGroupNonUniformBitwiseXor", 6,
5773
        (struct spirv_parser_instruction_operand[])
5774
        {
5775
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5776
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5777
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5778
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5779
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5780
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5781
        }
5782
    },
5783
    {
5784
        0x016a, "OpGroupNonUniformLogicalAnd", 6,
5785
        (struct spirv_parser_instruction_operand[])
5786
        {
5787
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5788
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5789
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5790
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5791
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5792
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5793
        }
5794
    },
5795
    {
5796
        0x016b, "OpGroupNonUniformLogicalOr", 6,
5797
        (struct spirv_parser_instruction_operand[])
5798
        {
5799
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5800
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5801
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5802
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5803
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5804
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5805
        }
5806
    },
5807
    {
5808
        0x016c, "OpGroupNonUniformLogicalXor", 6,
5809
        (struct spirv_parser_instruction_operand[])
5810
        {
5811
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5812
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5813
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5814
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
5815
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5816
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5817
        }
5818
    },
5819
    {
5820
        0x016d, "OpGroupNonUniformQuadBroadcast", 5,
5821
        (struct spirv_parser_instruction_operand[])
5822
        {
5823
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5824
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5825
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5826
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5827
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5828
        }
5829
    },
5830
    {
5831
        0x016e, "OpGroupNonUniformQuadSwap", 5,
5832
        (struct spirv_parser_instruction_operand[])
5833
        {
5834
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5835
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5836
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
5837
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5838
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5839
        }
5840
    },
5841
    {
5842
        0x0190, "OpCopyLogical", 3,
5843
        (struct spirv_parser_instruction_operand[])
5844
        {
5845
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5846
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5847
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5848
        }
5849
    },
5850
    {
5851
        0x0191, "OpPtrEqual", 4,
5852
        (struct spirv_parser_instruction_operand[])
5853
        {
5854
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5855
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5856
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5857
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5858
        }
5859
    },
5860
    {
5861
        0x0192, "OpPtrNotEqual", 4,
5862
        (struct spirv_parser_instruction_operand[])
5863
        {
5864
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5865
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5866
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5867
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5868
        }
5869
    },
5870
    {
5871
        0x0193, "OpPtrDiff", 4,
5872
        (struct spirv_parser_instruction_operand[])
5873
        {
5874
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5875
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5876
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5877
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5878
        }
5879
    },
5880
    {
5881
        0x1040, "OpColorAttachmentReadEXT", 4,
5882
        (struct spirv_parser_instruction_operand[])
5883
        {
5884
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5885
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5886
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5887
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5888
        }
5889
    },
5890
    {
5891
        0x1041, "OpDepthAttachmentReadEXT", 3,
5892
        (struct spirv_parser_instruction_operand[])
5893
        {
5894
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5895
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5896
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5897
        }
5898
    },
5899
    {
5900
        0x1042, "OpStencilAttachmentReadEXT", 3,
5901
        (struct spirv_parser_instruction_operand[])
5902
        {
5903
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5904
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5905
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5906
        }
5907
    },
5908
    {0x1140, "OpTerminateInvocation"},
5909
    {
5910
        0x1141, "OpTypeUntypedPointerKHR", 2,
5911
        (struct spirv_parser_instruction_operand[])
5912
        {
5913
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5914
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
5915
        }
5916
    },
5917
    {
5918
        0x1142, "OpUntypedVariableKHR", 5,
5919
        (struct spirv_parser_instruction_operand[])
5920
        {
5921
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5922
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5923
            {SPIRV_PARSER_OPERAND_TYPE_STORAGE_CLASS},
5924
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5925
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
5926
        }
5927
    },
5928
    {
5929
        0x1143, "OpUntypedAccessChainKHR", 5,
5930
        (struct spirv_parser_instruction_operand[])
5931
        {
5932
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5933
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5934
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5935
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5936
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
5937
        }
5938
    },
5939
    {
5940
        0x1144, "OpUntypedInBoundsAccessChainKHR", 5,
5941
        (struct spirv_parser_instruction_operand[])
5942
        {
5943
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5944
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5945
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5946
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5947
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
5948
        }
5949
    },
5950
    {
5951
        0x1145, "OpSubgroupBallotKHR", 3,
5952
        (struct spirv_parser_instruction_operand[])
5953
        {
5954
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5955
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5956
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5957
        }
5958
    },
5959
    {
5960
        0x1146, "OpSubgroupFirstInvocationKHR", 3,
5961
        (struct spirv_parser_instruction_operand[])
5962
        {
5963
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5964
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5965
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5966
        }
5967
    },
5968
    {
5969
        0x1147, "OpUntypedPtrAccessChainKHR", 6,
5970
        (struct spirv_parser_instruction_operand[])
5971
        {
5972
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5973
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5974
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5975
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5976
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5977
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
5978
        }
5979
    },
5980
    {
5981
        0x1148, "OpUntypedInBoundsPtrAccessChainKHR", 6,
5982
        (struct spirv_parser_instruction_operand[])
5983
        {
5984
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5985
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5986
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5987
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5988
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5989
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
5990
        }
5991
    },
5992
    {
5993
        0x1149, "OpUntypedArrayLengthKHR", 5,
5994
        (struct spirv_parser_instruction_operand[])
5995
        {
5996
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
5997
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
5998
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
5999
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6000
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
6001
        }
6002
    },
6003
    {
6004
        0x114a, "OpUntypedPrefetchKHR", 5,
6005
        (struct spirv_parser_instruction_operand[])
6006
        {
6007
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6008
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6009
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6010
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6011
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6012
        }
6013
    },
6014
    {
6015
        0x114c, "OpSubgroupAllKHR", 3,
6016
        (struct spirv_parser_instruction_operand[])
6017
        {
6018
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6019
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6020
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6021
        }
6022
    },
6023
    {
6024
        0x114d, "OpSubgroupAnyKHR", 3,
6025
        (struct spirv_parser_instruction_operand[])
6026
        {
6027
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6028
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6029
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6030
        }
6031
    },
6032
    {
6033
        0x114e, "OpSubgroupAllEqualKHR", 3,
6034
        (struct spirv_parser_instruction_operand[])
6035
        {
6036
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6037
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6038
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6039
        }
6040
    },
6041
    {
6042
        0x114f, "OpGroupNonUniformRotateKHR", 6,
6043
        (struct spirv_parser_instruction_operand[])
6044
        {
6045
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6046
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6047
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6048
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6049
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6050
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6051
        }
6052
    },
6053
    {
6054
        0x1150, "OpSubgroupReadInvocationKHR", 4,
6055
        (struct spirv_parser_instruction_operand[])
6056
        {
6057
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6058
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6059
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6060
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6061
        }
6062
    },
6063
    {
6064
        0x1151, "OpExtInstWithForwardRefsKHR", 5,
6065
        (struct spirv_parser_instruction_operand[])
6066
        {
6067
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6068
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6069
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6070
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_EXT_INST_INTEGER},
6071
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
6072
        }
6073
    },
6074
    {
6075
        0x115d, "OpTraceRayKHR", 11,
6076
        (struct spirv_parser_instruction_operand[])
6077
        {
6078
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6079
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6080
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6081
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6082
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6083
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6084
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6085
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6086
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6087
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6088
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6089
        }
6090
    },
6091
    {
6092
        0x115e, "OpExecuteCallableKHR", 2,
6093
        (struct spirv_parser_instruction_operand[])
6094
        {
6095
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6096
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6097
        }
6098
    },
6099
    {
6100
        0x115f, "OpConvertUToAccelerationStructureKHR", 3,
6101
        (struct spirv_parser_instruction_operand[])
6102
        {
6103
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6104
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6105
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6106
        }
6107
    },
6108
    {0x1160, "OpIgnoreIntersectionKHR"},
6109
    {0x1161, "OpTerminateRayKHR"},
6110
    {
6111
        0x1162, "OpSDot", 5,
6112
        (struct spirv_parser_instruction_operand[])
6113
        {
6114
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6115
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6116
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6117
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6118
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6119
        }
6120
    },
6121
    {
6122
        0x1163, "OpUDot", 5,
6123
        (struct spirv_parser_instruction_operand[])
6124
        {
6125
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6126
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6127
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6128
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6129
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6130
        }
6131
    },
6132
    {
6133
        0x1164, "OpSUDot", 5,
6134
        (struct spirv_parser_instruction_operand[])
6135
        {
6136
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6137
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6138
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6139
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6140
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6141
        }
6142
    },
6143
    {
6144
        0x1165, "OpSDotAccSat", 6,
6145
        (struct spirv_parser_instruction_operand[])
6146
        {
6147
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6148
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6149
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6150
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6151
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6152
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6153
        }
6154
    },
6155
    {
6156
        0x1166, "OpUDotAccSat", 6,
6157
        (struct spirv_parser_instruction_operand[])
6158
        {
6159
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6160
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6161
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6162
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6163
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6164
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6165
        }
6166
    },
6167
    {
6168
        0x1167, "OpSUDotAccSat", 6,
6169
        (struct spirv_parser_instruction_operand[])
6170
        {
6171
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6172
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6173
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6174
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6175
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6176
            {SPIRV_PARSER_OPERAND_TYPE_PACKED_VECTOR_FORMAT, '?'},
6177
        }
6178
    },
6179
    {
6180
        0x1168, "OpTypeCooperativeMatrixKHR", 6,
6181
        (struct spirv_parser_instruction_operand[])
6182
        {
6183
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6184
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6185
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6186
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6187
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6188
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6189
        }
6190
    },
6191
    {
6192
        0x1169, "OpCooperativeMatrixLoadKHR", 6,
6193
        (struct spirv_parser_instruction_operand[])
6194
        {
6195
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6196
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6197
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6198
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6199
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6200
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
6201
        }
6202
    },
6203
    {
6204
        0x116a, "OpCooperativeMatrixStoreKHR", 5,
6205
        (struct spirv_parser_instruction_operand[])
6206
        {
6207
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6208
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6209
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6210
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6211
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
6212
        }
6213
    },
6214
    {
6215
        0x116b, "OpCooperativeMatrixMulAddKHR", 6,
6216
        (struct spirv_parser_instruction_operand[])
6217
        {
6218
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6219
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6220
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6221
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6222
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6223
            {SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS, '?'},
6224
        }
6225
    },
6226
    {
6227
        0x116c, "OpCooperativeMatrixLengthKHR", 3,
6228
        (struct spirv_parser_instruction_operand[])
6229
        {
6230
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6231
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6232
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6233
        }
6234
    },
6235
    {
6236
        0x116d, "OpConstantCompositeReplicateEXT", 3,
6237
        (struct spirv_parser_instruction_operand[])
6238
        {
6239
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6240
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6241
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6242
        }
6243
    },
6244
    {
6245
        0x116e, "OpSpecConstantCompositeReplicateEXT", 3,
6246
        (struct spirv_parser_instruction_operand[])
6247
        {
6248
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6249
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6250
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6251
        }
6252
    },
6253
    {
6254
        0x116f, "OpCompositeConstructReplicateEXT", 3,
6255
        (struct spirv_parser_instruction_operand[])
6256
        {
6257
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6258
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6259
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6260
        }
6261
    },
6262
    {
6263
        0x1178, "OpTypeRayQueryKHR", 1,
6264
        (struct spirv_parser_instruction_operand[])
6265
        {
6266
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6267
        }
6268
    },
6269
    {
6270
        0x1179, "OpRayQueryInitializeKHR", 8,
6271
        (struct spirv_parser_instruction_operand[])
6272
        {
6273
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6274
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6275
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6276
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6277
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6278
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6279
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6280
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6281
        }
6282
    },
6283
    {
6284
        0x117a, "OpRayQueryTerminateKHR", 1,
6285
        (struct spirv_parser_instruction_operand[])
6286
        {
6287
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6288
        }
6289
    },
6290
    {
6291
        0x117b, "OpRayQueryGenerateIntersectionKHR", 2,
6292
        (struct spirv_parser_instruction_operand[])
6293
        {
6294
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6295
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6296
        }
6297
    },
6298
    {
6299
        0x117c, "OpRayQueryConfirmIntersectionKHR", 1,
6300
        (struct spirv_parser_instruction_operand[])
6301
        {
6302
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6303
        }
6304
    },
6305
    {
6306
        0x117d, "OpRayQueryProceedKHR", 3,
6307
        (struct spirv_parser_instruction_operand[])
6308
        {
6309
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6310
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6311
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6312
        }
6313
    },
6314
    {
6315
        0x117f, "OpRayQueryGetIntersectionTypeKHR", 4,
6316
        (struct spirv_parser_instruction_operand[])
6317
        {
6318
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6319
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6320
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6321
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6322
        }
6323
    },
6324
    {
6325
        0x1180, "OpImageSampleWeightedQCOM", 5,
6326
        (struct spirv_parser_instruction_operand[])
6327
        {
6328
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6329
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6330
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6331
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6332
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6333
        }
6334
    },
6335
    {
6336
        0x1181, "OpImageBoxFilterQCOM", 5,
6337
        (struct spirv_parser_instruction_operand[])
6338
        {
6339
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6340
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6341
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6342
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6343
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6344
        }
6345
    },
6346
    {
6347
        0x1182, "OpImageBlockMatchSSDQCOM", 7,
6348
        (struct spirv_parser_instruction_operand[])
6349
        {
6350
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6351
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6352
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6353
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6354
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6355
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6356
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6357
        }
6358
    },
6359
    {
6360
        0x1183, "OpImageBlockMatchSADQCOM", 7,
6361
        (struct spirv_parser_instruction_operand[])
6362
        {
6363
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6364
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6365
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6366
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6367
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6368
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6369
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6370
        }
6371
    },
6372
    {
6373
        0x1194, "OpImageBlockMatchWindowSSDQCOM", 7,
6374
        (struct spirv_parser_instruction_operand[])
6375
        {
6376
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6377
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6378
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6379
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6380
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6381
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6382
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6383
        }
6384
    },
6385
    {
6386
        0x1195, "OpImageBlockMatchWindowSADQCOM", 7,
6387
        (struct spirv_parser_instruction_operand[])
6388
        {
6389
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6390
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6391
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6392
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6393
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6394
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6395
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6396
        }
6397
    },
6398
    {
6399
        0x1196, "OpImageBlockMatchGatherSSDQCOM", 7,
6400
        (struct spirv_parser_instruction_operand[])
6401
        {
6402
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6403
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6404
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6405
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6406
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6407
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6408
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6409
        }
6410
    },
6411
    {
6412
        0x1197, "OpImageBlockMatchGatherSADQCOM", 7,
6413
        (struct spirv_parser_instruction_operand[])
6414
        {
6415
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6416
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6417
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6418
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6419
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6420
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6421
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6422
        }
6423
    },
6424
    {
6425
        0x1388, "OpGroupIAddNonUniformAMD", 5,
6426
        (struct spirv_parser_instruction_operand[])
6427
        {
6428
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6429
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6430
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6431
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6432
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6433
        }
6434
    },
6435
    {
6436
        0x1389, "OpGroupFAddNonUniformAMD", 5,
6437
        (struct spirv_parser_instruction_operand[])
6438
        {
6439
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6440
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6441
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6442
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6443
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6444
        }
6445
    },
6446
    {
6447
        0x138a, "OpGroupFMinNonUniformAMD", 5,
6448
        (struct spirv_parser_instruction_operand[])
6449
        {
6450
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6451
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6452
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6453
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6454
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6455
        }
6456
    },
6457
    {
6458
        0x138b, "OpGroupUMinNonUniformAMD", 5,
6459
        (struct spirv_parser_instruction_operand[])
6460
        {
6461
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6462
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6463
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6464
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6465
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6466
        }
6467
    },
6468
    {
6469
        0x138c, "OpGroupSMinNonUniformAMD", 5,
6470
        (struct spirv_parser_instruction_operand[])
6471
        {
6472
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6473
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6474
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6475
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6476
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6477
        }
6478
    },
6479
    {
6480
        0x138d, "OpGroupFMaxNonUniformAMD", 5,
6481
        (struct spirv_parser_instruction_operand[])
6482
        {
6483
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6484
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6485
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6486
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6487
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6488
        }
6489
    },
6490
    {
6491
        0x138e, "OpGroupUMaxNonUniformAMD", 5,
6492
        (struct spirv_parser_instruction_operand[])
6493
        {
6494
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6495
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6496
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6497
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6498
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6499
        }
6500
    },
6501
    {
6502
        0x138f, "OpGroupSMaxNonUniformAMD", 5,
6503
        (struct spirv_parser_instruction_operand[])
6504
        {
6505
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6506
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6507
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6508
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
6509
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6510
        }
6511
    },
6512
    {
6513
        0x1393, "OpFragmentMaskFetchAMD", 4,
6514
        (struct spirv_parser_instruction_operand[])
6515
        {
6516
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6517
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6518
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6519
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6520
        }
6521
    },
6522
    {
6523
        0x1394, "OpFragmentFetchAMD", 5,
6524
        (struct spirv_parser_instruction_operand[])
6525
        {
6526
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6527
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6528
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6529
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6530
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6531
        }
6532
    },
6533
    {
6534
        0x13c0, "OpReadClockKHR", 3,
6535
        (struct spirv_parser_instruction_operand[])
6536
        {
6537
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6538
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6539
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6540
        }
6541
    },
6542
    {
6543
        0x13d2, "OpAllocateNodePayloadsAMDX", 5,
6544
        (struct spirv_parser_instruction_operand[])
6545
        {
6546
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6547
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6548
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
6549
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6550
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6551
        }
6552
    },
6553
    {
6554
        0x13d3, "OpEnqueueNodePayloadsAMDX", 1,
6555
        (struct spirv_parser_instruction_operand[])
6556
        {
6557
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6558
        }
6559
    },
6560
    {
6561
        0x13d4, "OpTypeNodePayloadArrayAMDX", 2,
6562
        (struct spirv_parser_instruction_operand[])
6563
        {
6564
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6565
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6566
        }
6567
    },
6568
    {
6569
        0x13d6, "OpFinishWritingNodePayloadAMDX", 3,
6570
        (struct spirv_parser_instruction_operand[])
6571
        {
6572
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6573
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6574
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6575
        }
6576
    },
6577
    {
6578
        0x13e2, "OpNodePayloadArrayLengthAMDX", 3,
6579
        (struct spirv_parser_instruction_operand[])
6580
        {
6581
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6582
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6583
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6584
        }
6585
    },
6586
    {
6587
        0x13ed, "OpIsNodePayloadValidAMDX", 4,
6588
        (struct spirv_parser_instruction_operand[])
6589
        {
6590
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6591
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6592
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6593
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6594
        }
6595
    },
6596
    {
6597
        0x13ef, "OpConstantStringAMDX", 2,
6598
        (struct spirv_parser_instruction_operand[])
6599
        {
6600
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6601
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
6602
        }
6603
    },
6604
    {
6605
        0x13f0, "OpSpecConstantStringAMDX", 2,
6606
        (struct spirv_parser_instruction_operand[])
6607
        {
6608
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6609
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
6610
        }
6611
    },
6612
    {
6613
        0x13f6, "OpGroupNonUniformQuadAllKHR", 3,
6614
        (struct spirv_parser_instruction_operand[])
6615
        {
6616
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6617
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6618
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6619
        }
6620
    },
6621
    {
6622
        0x13f7, "OpGroupNonUniformQuadAnyKHR", 3,
6623
        (struct spirv_parser_instruction_operand[])
6624
        {
6625
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6626
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6627
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6628
        }
6629
    },
6630
    {
6631
        0x1481, "OpHitObjectRecordHitMotionNV", 14,
6632
        (struct spirv_parser_instruction_operand[])
6633
        {
6634
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6635
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6636
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6637
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6638
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6639
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6640
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6641
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6642
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6643
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6644
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6645
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6646
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6647
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6648
        }
6649
    },
6650
    {
6651
        0x1482, "OpHitObjectRecordHitWithIndexMotionNV", 13,
6652
        (struct spirv_parser_instruction_operand[])
6653
        {
6654
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6655
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6656
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6657
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6658
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6659
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6660
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6661
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6662
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6663
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6664
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6665
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6666
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6667
        }
6668
    },
6669
    {
6670
        0x1483, "OpHitObjectRecordMissMotionNV", 7,
6671
        (struct spirv_parser_instruction_operand[])
6672
        {
6673
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6674
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6675
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6676
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6677
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6678
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6679
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6680
        }
6681
    },
6682
    {
6683
        0x1484, "OpHitObjectGetWorldToObjectNV", 3,
6684
        (struct spirv_parser_instruction_operand[])
6685
        {
6686
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6687
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6688
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6689
        }
6690
    },
6691
    {
6692
        0x1485, "OpHitObjectGetObjectToWorldNV", 3,
6693
        (struct spirv_parser_instruction_operand[])
6694
        {
6695
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6696
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6697
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6698
        }
6699
    },
6700
    {
6701
        0x1486, "OpHitObjectGetObjectRayDirectionNV", 3,
6702
        (struct spirv_parser_instruction_operand[])
6703
        {
6704
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6705
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6706
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6707
        }
6708
    },
6709
    {
6710
        0x1487, "OpHitObjectGetObjectRayOriginNV", 3,
6711
        (struct spirv_parser_instruction_operand[])
6712
        {
6713
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6714
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6715
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6716
        }
6717
    },
6718
    {
6719
        0x1488, "OpHitObjectTraceRayMotionNV", 13,
6720
        (struct spirv_parser_instruction_operand[])
6721
        {
6722
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6723
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6724
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6725
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6726
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6727
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6728
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6729
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6730
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6731
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6732
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6733
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6734
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6735
        }
6736
    },
6737
    {
6738
        0x1489, "OpHitObjectGetShaderRecordBufferHandleNV", 3,
6739
        (struct spirv_parser_instruction_operand[])
6740
        {
6741
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6742
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6743
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6744
        }
6745
    },
6746
    {
6747
        0x148a, "OpHitObjectGetShaderBindingTableRecordIndexNV", 3,
6748
        (struct spirv_parser_instruction_operand[])
6749
        {
6750
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6751
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6752
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6753
        }
6754
    },
6755
    {
6756
        0x148b, "OpHitObjectRecordEmptyNV", 1,
6757
        (struct spirv_parser_instruction_operand[])
6758
        {
6759
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6760
        }
6761
    },
6762
    {
6763
        0x148c, "OpHitObjectTraceRayNV", 12,
6764
        (struct spirv_parser_instruction_operand[])
6765
        {
6766
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6767
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6768
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6769
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6770
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6771
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6772
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6773
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6774
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6775
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6776
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6777
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6778
        }
6779
    },
6780
    {
6781
        0x148d, "OpHitObjectRecordHitNV", 13,
6782
        (struct spirv_parser_instruction_operand[])
6783
        {
6784
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6785
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6786
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6787
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6788
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6789
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6790
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6791
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6792
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6793
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6794
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6795
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6796
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6797
        }
6798
    },
6799
    {
6800
        0x148e, "OpHitObjectRecordHitWithIndexNV", 12,
6801
        (struct spirv_parser_instruction_operand[])
6802
        {
6803
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6804
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6805
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6806
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6807
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6808
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6809
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6810
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6811
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6812
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6813
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6814
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6815
        }
6816
    },
6817
    {
6818
        0x148f, "OpHitObjectRecordMissNV", 6,
6819
        (struct spirv_parser_instruction_operand[])
6820
        {
6821
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6822
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6823
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6824
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6825
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6826
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6827
        }
6828
    },
6829
    {
6830
        0x1490, "OpHitObjectExecuteShaderNV", 2,
6831
        (struct spirv_parser_instruction_operand[])
6832
        {
6833
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6834
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6835
        }
6836
    },
6837
    {
6838
        0x1491, "OpHitObjectGetCurrentTimeNV", 3,
6839
        (struct spirv_parser_instruction_operand[])
6840
        {
6841
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6842
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6843
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6844
        }
6845
    },
6846
    {
6847
        0x1492, "OpHitObjectGetAttributesNV", 2,
6848
        (struct spirv_parser_instruction_operand[])
6849
        {
6850
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6851
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6852
        }
6853
    },
6854
    {
6855
        0x1493, "OpHitObjectGetHitKindNV", 3,
6856
        (struct spirv_parser_instruction_operand[])
6857
        {
6858
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6859
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6860
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6861
        }
6862
    },
6863
    {
6864
        0x1494, "OpHitObjectGetPrimitiveIndexNV", 3,
6865
        (struct spirv_parser_instruction_operand[])
6866
        {
6867
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6868
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6869
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6870
        }
6871
    },
6872
    {
6873
        0x1495, "OpHitObjectGetGeometryIndexNV", 3,
6874
        (struct spirv_parser_instruction_operand[])
6875
        {
6876
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6877
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6878
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6879
        }
6880
    },
6881
    {
6882
        0x1496, "OpHitObjectGetInstanceIdNV", 3,
6883
        (struct spirv_parser_instruction_operand[])
6884
        {
6885
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6886
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6887
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6888
        }
6889
    },
6890
    {
6891
        0x1497, "OpHitObjectGetInstanceCustomIndexNV", 3,
6892
        (struct spirv_parser_instruction_operand[])
6893
        {
6894
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6895
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6896
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6897
        }
6898
    },
6899
    {
6900
        0x1498, "OpHitObjectGetWorldRayDirectionNV", 3,
6901
        (struct spirv_parser_instruction_operand[])
6902
        {
6903
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6904
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6905
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6906
        }
6907
    },
6908
    {
6909
        0x1499, "OpHitObjectGetWorldRayOriginNV", 3,
6910
        (struct spirv_parser_instruction_operand[])
6911
        {
6912
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6913
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6914
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6915
        }
6916
    },
6917
    {
6918
        0x149a, "OpHitObjectGetRayTMaxNV", 3,
6919
        (struct spirv_parser_instruction_operand[])
6920
        {
6921
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6922
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6923
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6924
        }
6925
    },
6926
    {
6927
        0x149b, "OpHitObjectGetRayTMinNV", 3,
6928
        (struct spirv_parser_instruction_operand[])
6929
        {
6930
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6931
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6932
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6933
        }
6934
    },
6935
    {
6936
        0x149c, "OpHitObjectIsEmptyNV", 3,
6937
        (struct spirv_parser_instruction_operand[])
6938
        {
6939
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6940
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6941
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6942
        }
6943
    },
6944
    {
6945
        0x149d, "OpHitObjectIsHitNV", 3,
6946
        (struct spirv_parser_instruction_operand[])
6947
        {
6948
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6949
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6950
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6951
        }
6952
    },
6953
    {
6954
        0x149e, "OpHitObjectIsMissNV", 3,
6955
        (struct spirv_parser_instruction_operand[])
6956
        {
6957
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6958
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6959
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6960
        }
6961
    },
6962
    {
6963
        0x149f, "OpReorderThreadWithHitObjectNV", 3,
6964
        (struct spirv_parser_instruction_operand[])
6965
        {
6966
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6967
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6968
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
6969
        }
6970
    },
6971
    {
6972
        0x14a0, "OpReorderThreadWithHintNV", 2,
6973
        (struct spirv_parser_instruction_operand[])
6974
        {
6975
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6976
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6977
        }
6978
    },
6979
    {
6980
        0x14a1, "OpTypeHitObjectNV", 1,
6981
        (struct spirv_parser_instruction_operand[])
6982
        {
6983
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6984
        }
6985
    },
6986
    {
6987
        0x14a3, "OpImageSampleFootprintNV", 7,
6988
        (struct spirv_parser_instruction_operand[])
6989
        {
6990
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
6991
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
6992
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6993
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6994
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6995
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
6996
            {SPIRV_PARSER_OPERAND_TYPE_IMAGE_OPERANDS, '?'},
6997
        }
6998
    },
6999
    {
7000
        0x14a8, "OpTypeCooperativeVectorNV", 3,
7001
        (struct spirv_parser_instruction_operand[])
7002
        {
7003
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7004
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7005
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7006
        }
7007
    },
7008
    {
7009
        0x14a9, "OpCooperativeVectorMatrixMulNV", 13,
7010
        (struct spirv_parser_instruction_operand[])
7011
        {
7012
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7013
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7014
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7015
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7016
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7017
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7018
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7019
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7020
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7021
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7022
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7023
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
7024
            {SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS, '?'},
7025
        }
7026
    },
7027
    {
7028
        0x14aa, "OpCooperativeVectorOuterProductAccumulateNV", 7,
7029
        (struct spirv_parser_instruction_operand[])
7030
        {
7031
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7032
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7033
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7034
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7035
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7036
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7037
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
7038
        }
7039
    },
7040
    {
7041
        0x14ab, "OpCooperativeVectorReduceSumAccumulateNV", 3,
7042
        (struct spirv_parser_instruction_operand[])
7043
        {
7044
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7045
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7046
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7047
        }
7048
    },
7049
    {
7050
        0x14ac, "OpCooperativeVectorMatrixMulAddNV", 16,
7051
        (struct spirv_parser_instruction_operand[])
7052
        {
7053
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7054
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7055
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7056
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7057
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7058
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7059
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7060
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7061
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7062
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7063
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7064
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7065
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7066
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7067
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
7068
            {SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS, '?'},
7069
        }
7070
    },
7071
    {
7072
        0x14ad, "OpCooperativeMatrixConvertNV", 3,
7073
        (struct spirv_parser_instruction_operand[])
7074
        {
7075
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7076
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7077
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7078
        }
7079
    },
7080
    {
7081
        0x14ae, "OpEmitMeshTasksEXT", 4,
7082
        (struct spirv_parser_instruction_operand[])
7083
        {
7084
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7085
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7086
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7087
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
7088
        }
7089
    },
7090
    {
7091
        0x14af, "OpSetMeshOutputsEXT", 2,
7092
        (struct spirv_parser_instruction_operand[])
7093
        {
7094
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7095
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7096
        }
7097
    },
7098
    {
7099
        0x14b0, "OpGroupNonUniformPartitionNV", 3,
7100
        (struct spirv_parser_instruction_operand[])
7101
        {
7102
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7103
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7104
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7105
        }
7106
    },
7107
    {
7108
        0x14b3, "OpWritePackedPrimitiveIndices4x8NV", 2,
7109
        (struct spirv_parser_instruction_operand[])
7110
        {
7111
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7112
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7113
        }
7114
    },
7115
    {
7116
        0x14b4, "OpFetchMicroTriangleVertexPositionNV", 7,
7117
        (struct spirv_parser_instruction_operand[])
7118
        {
7119
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7120
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7121
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7122
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7123
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7124
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7125
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7126
        }
7127
    },
7128
    {
7129
        0x14b5, "OpFetchMicroTriangleVertexBarycentricNV", 7,
7130
        (struct spirv_parser_instruction_operand[])
7131
        {
7132
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7133
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7134
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7135
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7136
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7137
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7138
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7139
        }
7140
    },
7141
    {
7142
        0x14b6, "OpCooperativeVectorLoadNV", 5,
7143
        (struct spirv_parser_instruction_operand[])
7144
        {
7145
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7146
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7147
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7148
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7149
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
7150
        }
7151
    },
7152
    {
7153
        0x14b7, "OpCooperativeVectorStoreNV", 4,
7154
        (struct spirv_parser_instruction_operand[])
7155
        {
7156
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7157
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7158
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7159
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
7160
        }
7161
    },
7162
    {
7163
        0x14d6, "OpReportIntersectionKHR", 4,
7164
        (struct spirv_parser_instruction_operand[])
7165
        {
7166
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7167
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7168
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7169
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7170
        }
7171
    },
7172
    {0x14d7, "OpIgnoreIntersectionNV"},
7173
    {0x14d8, "OpTerminateRayNV"},
7174
    {
7175
        0x14d9, "OpTraceNV", 11,
7176
        (struct spirv_parser_instruction_operand[])
7177
        {
7178
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7179
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7180
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7181
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7182
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7183
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7184
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7185
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7186
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7187
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7188
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7189
        }
7190
    },
7191
    {
7192
        0x14da, "OpTraceMotionNV", 12,
7193
        (struct spirv_parser_instruction_operand[])
7194
        {
7195
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7196
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7197
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7198
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7199
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7200
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7201
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7202
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7203
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7204
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7205
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7206
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7207
        }
7208
    },
7209
    {
7210
        0x14db, "OpTraceRayMotionNV", 12,
7211
        (struct spirv_parser_instruction_operand[])
7212
        {
7213
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7214
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7215
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7216
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7217
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7218
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7219
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7220
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7221
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7222
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7223
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7224
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7225
        }
7226
    },
7227
    {
7228
        0x14dc, "OpRayQueryGetIntersectionTriangleVertexPositionsKHR", 4,
7229
        (struct spirv_parser_instruction_operand[])
7230
        {
7231
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7232
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7233
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7234
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7235
        }
7236
    },
7237
    {
7238
        0x14dd, "OpTypeAccelerationStructureKHR", 1,
7239
        (struct spirv_parser_instruction_operand[])
7240
        {
7241
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7242
        }
7243
    },
7244
    {
7245
        0x14e0, "OpExecuteCallableNV", 2,
7246
        (struct spirv_parser_instruction_operand[])
7247
        {
7248
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7249
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7250
        }
7251
    },
7252
    {
7253
        0x14e1, "OpRayQueryGetClusterIdNV", 4,
7254
        (struct spirv_parser_instruction_operand[])
7255
        {
7256
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7257
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7258
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7259
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7260
        }
7261
    },
7262
    {
7263
        0x14e2, "OpHitObjectGetClusterIdNV", 3,
7264
        (struct spirv_parser_instruction_operand[])
7265
        {
7266
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7267
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7268
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7269
        }
7270
    },
7271
    {
7272
        0x14ee, "OpTypeCooperativeMatrixNV", 5,
7273
        (struct spirv_parser_instruction_operand[])
7274
        {
7275
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7276
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7277
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
7278
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7279
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7280
        }
7281
    },
7282
    {
7283
        0x14ef, "OpCooperativeMatrixLoadNV", 6,
7284
        (struct spirv_parser_instruction_operand[])
7285
        {
7286
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7287
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7288
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7289
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7290
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7291
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
7292
        }
7293
    },
7294
    {
7295
        0x14f0, "OpCooperativeMatrixStoreNV", 5,
7296
        (struct spirv_parser_instruction_operand[])
7297
        {
7298
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7299
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7300
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7301
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7302
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
7303
        }
7304
    },
7305
    {
7306
        0x14f1, "OpCooperativeMatrixMulAddNV", 5,
7307
        (struct spirv_parser_instruction_operand[])
7308
        {
7309
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7310
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7311
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7312
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7313
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7314
        }
7315
    },
7316
    {
7317
        0x14f2, "OpCooperativeMatrixLengthNV", 3,
7318
        (struct spirv_parser_instruction_operand[])
7319
        {
7320
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7321
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7322
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7323
        }
7324
    },
7325
    {0x14f4, "OpBeginInvocationInterlockEXT"},
7326
    {0x14f5, "OpEndInvocationInterlockEXT"},
7327
    {
7328
        0x14f6, "OpCooperativeMatrixReduceNV", 5,
7329
        (struct spirv_parser_instruction_operand[])
7330
        {
7331
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7332
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7333
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7334
            {SPIRV_PARSER_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE},
7335
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7336
        }
7337
    },
7338
    {
7339
        0x14f7, "OpCooperativeMatrixLoadTensorNV", 7,
7340
        (struct spirv_parser_instruction_operand[])
7341
        {
7342
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7343
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7344
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7345
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7346
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7347
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS},
7348
            {SPIRV_PARSER_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS},
7349
        }
7350
    },
7351
    {
7352
        0x14f8, "OpCooperativeMatrixStoreTensorNV", 5,
7353
        (struct spirv_parser_instruction_operand[])
7354
        {
7355
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7356
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7357
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7358
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS},
7359
            {SPIRV_PARSER_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS},
7360
        }
7361
    },
7362
    {
7363
        0x14f9, "OpCooperativeMatrixPerElementOpNV", 5,
7364
        (struct spirv_parser_instruction_operand[])
7365
        {
7366
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7367
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7368
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7369
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7370
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7371
        }
7372
    },
7373
    {
7374
        0x14fa, "OpTypeTensorLayoutNV", 3,
7375
        (struct spirv_parser_instruction_operand[])
7376
        {
7377
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7378
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7379
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7380
        }
7381
    },
7382
    {
7383
        0x14fb, "OpTypeTensorViewNV", 4,
7384
        (struct spirv_parser_instruction_operand[])
7385
        {
7386
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7387
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7388
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7389
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7390
        }
7391
    },
7392
    {
7393
        0x14fc, "OpCreateTensorLayoutNV", 2,
7394
        (struct spirv_parser_instruction_operand[])
7395
        {
7396
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7397
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7398
        }
7399
    },
7400
    {
7401
        0x14fd, "OpTensorLayoutSetDimensionNV", 4,
7402
        (struct spirv_parser_instruction_operand[])
7403
        {
7404
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7405
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7406
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7407
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7408
        }
7409
    },
7410
    {
7411
        0x14fe, "OpTensorLayoutSetStrideNV", 4,
7412
        (struct spirv_parser_instruction_operand[])
7413
        {
7414
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7415
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7416
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7417
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7418
        }
7419
    },
7420
    {
7421
        0x14ff, "OpTensorLayoutSliceNV", 4,
7422
        (struct spirv_parser_instruction_operand[])
7423
        {
7424
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7425
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7426
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7427
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7428
        }
7429
    },
7430
    {
7431
        0x1500, "OpTensorLayoutSetClampValueNV", 4,
7432
        (struct spirv_parser_instruction_operand[])
7433
        {
7434
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7435
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7436
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7437
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7438
        }
7439
    },
7440
    {
7441
        0x1501, "OpCreateTensorViewNV", 2,
7442
        (struct spirv_parser_instruction_operand[])
7443
        {
7444
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7445
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7446
        }
7447
    },
7448
    {
7449
        0x1502, "OpTensorViewSetDimensionNV", 4,
7450
        (struct spirv_parser_instruction_operand[])
7451
        {
7452
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7453
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7454
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7455
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7456
        }
7457
    },
7458
    {
7459
        0x1503, "OpTensorViewSetStrideNV", 4,
7460
        (struct spirv_parser_instruction_operand[])
7461
        {
7462
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7463
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7464
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7465
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7466
        }
7467
    },
7468
    {0x1504, "OpDemoteToHelperInvocation"},
7469
    {
7470
        0x1505, "OpIsHelperInvocationEXT", 2,
7471
        (struct spirv_parser_instruction_operand[])
7472
        {
7473
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7474
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7475
        }
7476
    },
7477
    {
7478
        0x1506, "OpTensorViewSetClipNV", 7,
7479
        (struct spirv_parser_instruction_operand[])
7480
        {
7481
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7482
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7483
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7484
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7485
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7486
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7487
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7488
        }
7489
    },
7490
    {
7491
        0x1508, "OpTensorLayoutSetBlockSizeNV", 4,
7492
        (struct spirv_parser_instruction_operand[])
7493
        {
7494
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7495
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7496
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7497
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7498
        }
7499
    },
7500
    {
7501
        0x150e, "OpCooperativeMatrixTransposeNV", 3,
7502
        (struct spirv_parser_instruction_operand[])
7503
        {
7504
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7505
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7506
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7507
        }
7508
    },
7509
    {
7510
        0x150f, "OpConvertUToImageNV", 3,
7511
        (struct spirv_parser_instruction_operand[])
7512
        {
7513
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7514
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7515
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7516
        }
7517
    },
7518
    {
7519
        0x1510, "OpConvertUToSamplerNV", 3,
7520
        (struct spirv_parser_instruction_operand[])
7521
        {
7522
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7523
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7524
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7525
        }
7526
    },
7527
    {
7528
        0x1511, "OpConvertImageToUNV", 3,
7529
        (struct spirv_parser_instruction_operand[])
7530
        {
7531
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7532
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7533
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7534
        }
7535
    },
7536
    {
7537
        0x1512, "OpConvertSamplerToUNV", 3,
7538
        (struct spirv_parser_instruction_operand[])
7539
        {
7540
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7541
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7542
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7543
        }
7544
    },
7545
    {
7546
        0x1513, "OpConvertUToSampledImageNV", 3,
7547
        (struct spirv_parser_instruction_operand[])
7548
        {
7549
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7550
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7551
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7552
        }
7553
    },
7554
    {
7555
        0x1514, "OpConvertSampledImageToUNV", 3,
7556
        (struct spirv_parser_instruction_operand[])
7557
        {
7558
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7559
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7560
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7561
        }
7562
    },
7563
    {
7564
        0x1515, "OpSamplerImageAddressingModeNV", 1,
7565
        (struct spirv_parser_instruction_operand[])
7566
        {
7567
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
7568
        }
7569
    },
7570
    {
7571
        0x1516, "OpRawAccessChainNV", 7,
7572
        (struct spirv_parser_instruction_operand[])
7573
        {
7574
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7575
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7576
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7577
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7578
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7579
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7580
            {SPIRV_PARSER_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS, '?'},
7581
        }
7582
    },
7583
    {
7584
        0x1533, "OpRayQueryGetIntersectionSpherePositionNV", 4,
7585
        (struct spirv_parser_instruction_operand[])
7586
        {
7587
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7588
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7589
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7590
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7591
        }
7592
    },
7593
    {
7594
        0x1534, "OpRayQueryGetIntersectionSphereRadiusNV", 4,
7595
        (struct spirv_parser_instruction_operand[])
7596
        {
7597
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7598
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7599
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7600
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7601
        }
7602
    },
7603
    {
7604
        0x1535, "OpRayQueryGetIntersectionLSSPositionsNV", 4,
7605
        (struct spirv_parser_instruction_operand[])
7606
        {
7607
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7608
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7609
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7610
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7611
        }
7612
    },
7613
    {
7614
        0x1536, "OpRayQueryGetIntersectionLSSRadiiNV", 4,
7615
        (struct spirv_parser_instruction_operand[])
7616
        {
7617
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7618
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7619
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7620
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7621
        }
7622
    },
7623
    {
7624
        0x1537, "OpRayQueryGetIntersectionLSSHitValueNV", 4,
7625
        (struct spirv_parser_instruction_operand[])
7626
        {
7627
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7628
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7629
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7630
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7631
        }
7632
    },
7633
    {
7634
        0x1538, "OpHitObjectGetSpherePositionNV", 3,
7635
        (struct spirv_parser_instruction_operand[])
7636
        {
7637
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7638
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7639
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7640
        }
7641
    },
7642
    {
7643
        0x1539, "OpHitObjectGetSphereRadiusNV", 3,
7644
        (struct spirv_parser_instruction_operand[])
7645
        {
7646
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7647
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7648
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7649
        }
7650
    },
7651
    {
7652
        0x153a, "OpHitObjectGetLSSPositionsNV", 3,
7653
        (struct spirv_parser_instruction_operand[])
7654
        {
7655
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7656
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7657
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7658
        }
7659
    },
7660
    {
7661
        0x153b, "OpHitObjectGetLSSRadiiNV", 3,
7662
        (struct spirv_parser_instruction_operand[])
7663
        {
7664
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7665
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7666
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7667
        }
7668
    },
7669
    {
7670
        0x153c, "OpHitObjectIsSphereHitNV", 3,
7671
        (struct spirv_parser_instruction_operand[])
7672
        {
7673
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7674
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7675
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7676
        }
7677
    },
7678
    {
7679
        0x153d, "OpHitObjectIsLSSHitNV", 3,
7680
        (struct spirv_parser_instruction_operand[])
7681
        {
7682
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7683
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7684
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7685
        }
7686
    },
7687
    {
7688
        0x153e, "OpRayQueryIsSphereHitNV", 4,
7689
        (struct spirv_parser_instruction_operand[])
7690
        {
7691
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7692
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7693
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7694
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7695
        }
7696
    },
7697
    {
7698
        0x153f, "OpRayQueryIsLSSHitNV", 4,
7699
        (struct spirv_parser_instruction_operand[])
7700
        {
7701
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7702
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7703
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7704
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7705
        }
7706
    },
7707
    {
7708
        0x15c3, "OpSubgroupShuffleINTEL", 4,
7709
        (struct spirv_parser_instruction_operand[])
7710
        {
7711
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7712
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7713
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7714
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7715
        }
7716
    },
7717
    {
7718
        0x15c4, "OpSubgroupShuffleDownINTEL", 5,
7719
        (struct spirv_parser_instruction_operand[])
7720
        {
7721
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7722
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7723
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7724
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7725
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7726
        }
7727
    },
7728
    {
7729
        0x15c5, "OpSubgroupShuffleUpINTEL", 5,
7730
        (struct spirv_parser_instruction_operand[])
7731
        {
7732
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7733
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7734
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7735
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7736
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7737
        }
7738
    },
7739
    {
7740
        0x15c6, "OpSubgroupShuffleXorINTEL", 4,
7741
        (struct spirv_parser_instruction_operand[])
7742
        {
7743
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7744
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7745
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7746
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7747
        }
7748
    },
7749
    {
7750
        0x15c7, "OpSubgroupBlockReadINTEL", 3,
7751
        (struct spirv_parser_instruction_operand[])
7752
        {
7753
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7754
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7755
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7756
        }
7757
    },
7758
    {
7759
        0x15c8, "OpSubgroupBlockWriteINTEL", 2,
7760
        (struct spirv_parser_instruction_operand[])
7761
        {
7762
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7763
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7764
        }
7765
    },
7766
    {
7767
        0x15c9, "OpSubgroupImageBlockReadINTEL", 4,
7768
        (struct spirv_parser_instruction_operand[])
7769
        {
7770
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7771
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7772
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7773
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7774
        }
7775
    },
7776
    {
7777
        0x15ca, "OpSubgroupImageBlockWriteINTEL", 3,
7778
        (struct spirv_parser_instruction_operand[])
7779
        {
7780
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7781
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7782
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7783
        }
7784
    },
7785
    {
7786
        0x15cc, "OpSubgroupImageMediaBlockReadINTEL", 6,
7787
        (struct spirv_parser_instruction_operand[])
7788
        {
7789
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7790
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7791
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7792
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7793
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7794
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7795
        }
7796
    },
7797
    {
7798
        0x15cd, "OpSubgroupImageMediaBlockWriteINTEL", 5,
7799
        (struct spirv_parser_instruction_operand[])
7800
        {
7801
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7802
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7803
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7804
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7805
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7806
        }
7807
    },
7808
    {
7809
        0x15d1, "OpUCountLeadingZerosINTEL", 3,
7810
        (struct spirv_parser_instruction_operand[])
7811
        {
7812
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7813
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7814
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7815
        }
7816
    },
7817
    {
7818
        0x15d2, "OpUCountTrailingZerosINTEL", 3,
7819
        (struct spirv_parser_instruction_operand[])
7820
        {
7821
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7822
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7823
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7824
        }
7825
    },
7826
    {
7827
        0x15d3, "OpAbsISubINTEL", 4,
7828
        (struct spirv_parser_instruction_operand[])
7829
        {
7830
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7831
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7832
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7833
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7834
        }
7835
    },
7836
    {
7837
        0x15d4, "OpAbsUSubINTEL", 4,
7838
        (struct spirv_parser_instruction_operand[])
7839
        {
7840
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7841
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7842
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7843
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7844
        }
7845
    },
7846
    {
7847
        0x15d5, "OpIAddSatINTEL", 4,
7848
        (struct spirv_parser_instruction_operand[])
7849
        {
7850
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7851
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7852
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7853
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7854
        }
7855
    },
7856
    {
7857
        0x15d6, "OpUAddSatINTEL", 4,
7858
        (struct spirv_parser_instruction_operand[])
7859
        {
7860
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7861
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7862
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7863
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7864
        }
7865
    },
7866
    {
7867
        0x15d7, "OpIAverageINTEL", 4,
7868
        (struct spirv_parser_instruction_operand[])
7869
        {
7870
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7871
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7872
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7873
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7874
        }
7875
    },
7876
    {
7877
        0x15d8, "OpUAverageINTEL", 4,
7878
        (struct spirv_parser_instruction_operand[])
7879
        {
7880
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7881
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7882
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7883
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7884
        }
7885
    },
7886
    {
7887
        0x15d9, "OpIAverageRoundedINTEL", 4,
7888
        (struct spirv_parser_instruction_operand[])
7889
        {
7890
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7891
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7892
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7893
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7894
        }
7895
    },
7896
    {
7897
        0x15da, "OpUAverageRoundedINTEL", 4,
7898
        (struct spirv_parser_instruction_operand[])
7899
        {
7900
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7901
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7902
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7903
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7904
        }
7905
    },
7906
    {
7907
        0x15db, "OpISubSatINTEL", 4,
7908
        (struct spirv_parser_instruction_operand[])
7909
        {
7910
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7911
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7912
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7913
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7914
        }
7915
    },
7916
    {
7917
        0x15dc, "OpUSubSatINTEL", 4,
7918
        (struct spirv_parser_instruction_operand[])
7919
        {
7920
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7921
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7922
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7923
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7924
        }
7925
    },
7926
    {
7927
        0x15dd, "OpIMul32x16INTEL", 4,
7928
        (struct spirv_parser_instruction_operand[])
7929
        {
7930
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7931
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7932
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7933
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7934
        }
7935
    },
7936
    {
7937
        0x15de, "OpUMul32x16INTEL", 4,
7938
        (struct spirv_parser_instruction_operand[])
7939
        {
7940
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7941
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7942
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7943
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7944
        }
7945
    },
7946
    {
7947
        0x15e0, "OpConstantFunctionPointerINTEL", 3,
7948
        (struct spirv_parser_instruction_operand[])
7949
        {
7950
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7951
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7952
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7953
        }
7954
    },
7955
    {
7956
        0x15e1, "OpFunctionPointerCallINTEL", 3,
7957
        (struct spirv_parser_instruction_operand[])
7958
        {
7959
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7960
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7961
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7962
        }
7963
    },
7964
    {
7965
        0x15e9, "OpAsmTargetINTEL", 2,
7966
        (struct spirv_parser_instruction_operand[])
7967
        {
7968
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7969
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
7970
        }
7971
    },
7972
    {
7973
        0x15ea, "OpAsmINTEL", 6,
7974
        (struct spirv_parser_instruction_operand[])
7975
        {
7976
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7977
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7978
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7979
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7980
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
7981
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_STRING},
7982
        }
7983
    },
7984
    {
7985
        0x15eb, "OpAsmCallINTEL", 4,
7986
        (struct spirv_parser_instruction_operand[])
7987
        {
7988
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7989
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
7990
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
7991
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
7992
        }
7993
    },
7994
    {
7995
        0x15ee, "OpAtomicFMinEXT", 6,
7996
        (struct spirv_parser_instruction_operand[])
7997
        {
7998
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
7999
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8000
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8001
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
8002
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
8003
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8004
        }
8005
    },
8006
    {
8007
        0x15ef, "OpAtomicFMaxEXT", 6,
8008
        (struct spirv_parser_instruction_operand[])
8009
        {
8010
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8011
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8012
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8013
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
8014
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
8015
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8016
        }
8017
    },
8018
    {
8019
        0x15fe, "OpAssumeTrueKHR", 1,
8020
        (struct spirv_parser_instruction_operand[])
8021
        {
8022
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8023
        }
8024
    },
8025
    {
8026
        0x15ff, "OpExpectKHR", 4,
8027
        (struct spirv_parser_instruction_operand[])
8028
        {
8029
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8030
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8031
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8032
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8033
        }
8034
    },
8035
    {
8036
        0x1600, "OpDecorateString", 2,
8037
        (struct spirv_parser_instruction_operand[])
8038
        {
8039
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8040
            {SPIRV_PARSER_OPERAND_TYPE_DECORATION},
8041
        }
8042
    },
8043
    {
8044
        0x1601, "OpMemberDecorateString", 3,
8045
        (struct spirv_parser_instruction_operand[])
8046
        {
8047
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8048
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
8049
            {SPIRV_PARSER_OPERAND_TYPE_DECORATION},
8050
        }
8051
    },
8052
    {
8053
        0x1643, "OpVmeImageINTEL", 4,
8054
        (struct spirv_parser_instruction_operand[])
8055
        {
8056
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8057
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8058
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8059
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8060
        }
8061
    },
8062
    {
8063
        0x1644, "OpTypeVmeImageINTEL", 2,
8064
        (struct spirv_parser_instruction_operand[])
8065
        {
8066
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8067
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8068
        }
8069
    },
8070
    {
8071
        0x1645, "OpTypeAvcImePayloadINTEL", 1,
8072
        (struct spirv_parser_instruction_operand[])
8073
        {
8074
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8075
        }
8076
    },
8077
    {
8078
        0x1646, "OpTypeAvcRefPayloadINTEL", 1,
8079
        (struct spirv_parser_instruction_operand[])
8080
        {
8081
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8082
        }
8083
    },
8084
    {
8085
        0x1647, "OpTypeAvcSicPayloadINTEL", 1,
8086
        (struct spirv_parser_instruction_operand[])
8087
        {
8088
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8089
        }
8090
    },
8091
    {
8092
        0x1648, "OpTypeAvcMcePayloadINTEL", 1,
8093
        (struct spirv_parser_instruction_operand[])
8094
        {
8095
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8096
        }
8097
    },
8098
    {
8099
        0x1649, "OpTypeAvcMceResultINTEL", 1,
8100
        (struct spirv_parser_instruction_operand[])
8101
        {
8102
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8103
        }
8104
    },
8105
    {
8106
        0x164a, "OpTypeAvcImeResultINTEL", 1,
8107
        (struct spirv_parser_instruction_operand[])
8108
        {
8109
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8110
        }
8111
    },
8112
    {
8113
        0x164b, "OpTypeAvcImeResultSingleReferenceStreamoutINTEL", 1,
8114
        (struct spirv_parser_instruction_operand[])
8115
        {
8116
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8117
        }
8118
    },
8119
    {
8120
        0x164c, "OpTypeAvcImeResultDualReferenceStreamoutINTEL", 1,
8121
        (struct spirv_parser_instruction_operand[])
8122
        {
8123
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8124
        }
8125
    },
8126
    {
8127
        0x164d, "OpTypeAvcImeSingleReferenceStreaminINTEL", 1,
8128
        (struct spirv_parser_instruction_operand[])
8129
        {
8130
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8131
        }
8132
    },
8133
    {
8134
        0x164e, "OpTypeAvcImeDualReferenceStreaminINTEL", 1,
8135
        (struct spirv_parser_instruction_operand[])
8136
        {
8137
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8138
        }
8139
    },
8140
    {
8141
        0x164f, "OpTypeAvcRefResultINTEL", 1,
8142
        (struct spirv_parser_instruction_operand[])
8143
        {
8144
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8145
        }
8146
    },
8147
    {
8148
        0x1650, "OpTypeAvcSicResultINTEL", 1,
8149
        (struct spirv_parser_instruction_operand[])
8150
        {
8151
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8152
        }
8153
    },
8154
    {
8155
        0x1651, "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", 4,
8156
        (struct spirv_parser_instruction_operand[])
8157
        {
8158
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8159
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8160
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8161
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8162
        }
8163
    },
8164
    {
8165
        0x1652, "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", 4,
8166
        (struct spirv_parser_instruction_operand[])
8167
        {
8168
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8169
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8170
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8171
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8172
        }
8173
    },
8174
    {
8175
        0x1653, "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", 4,
8176
        (struct spirv_parser_instruction_operand[])
8177
        {
8178
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8179
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8180
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8181
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8182
        }
8183
    },
8184
    {
8185
        0x1654, "OpSubgroupAvcMceSetInterShapePenaltyINTEL", 4,
8186
        (struct spirv_parser_instruction_operand[])
8187
        {
8188
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8189
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8190
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8191
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8192
        }
8193
    },
8194
    {
8195
        0x1655, "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", 4,
8196
        (struct spirv_parser_instruction_operand[])
8197
        {
8198
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8199
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8200
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8201
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8202
        }
8203
    },
8204
    {
8205
        0x1656, "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", 4,
8206
        (struct spirv_parser_instruction_operand[])
8207
        {
8208
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8209
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8210
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8211
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8212
        }
8213
    },
8214
    {
8215
        0x1657, "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", 4,
8216
        (struct spirv_parser_instruction_operand[])
8217
        {
8218
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8219
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8220
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8221
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8222
        }
8223
    },
8224
    {
8225
        0x1658, "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", 4,
8226
        (struct spirv_parser_instruction_operand[])
8227
        {
8228
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8229
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8230
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8231
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8232
        }
8233
    },
8234
    {
8235
        0x1659, "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", 2,
8236
        (struct spirv_parser_instruction_operand[])
8237
        {
8238
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8239
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8240
        }
8241
    },
8242
    {
8243
        0x165a, "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", 2,
8244
        (struct spirv_parser_instruction_operand[])
8245
        {
8246
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8247
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8248
        }
8249
    },
8250
    {
8251
        0x165b, "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", 2,
8252
        (struct spirv_parser_instruction_operand[])
8253
        {
8254
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8255
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8256
        }
8257
    },
8258
    {
8259
        0x165c, "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", 6,
8260
        (struct spirv_parser_instruction_operand[])
8261
        {
8262
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8263
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8264
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8265
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8266
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8267
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8268
        }
8269
    },
8270
    {
8271
        0x165d, "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", 4,
8272
        (struct spirv_parser_instruction_operand[])
8273
        {
8274
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8275
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8276
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8277
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8278
        }
8279
    },
8280
    {
8281
        0x165e, "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", 2,
8282
        (struct spirv_parser_instruction_operand[])
8283
        {
8284
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8285
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8286
        }
8287
    },
8288
    {
8289
        0x165f, "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", 2,
8290
        (struct spirv_parser_instruction_operand[])
8291
        {
8292
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8293
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8294
        }
8295
    },
8296
    {
8297
        0x1660, "OpSubgroupAvcMceSetAcOnlyHaarINTEL", 3,
8298
        (struct spirv_parser_instruction_operand[])
8299
        {
8300
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8301
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8302
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8303
        }
8304
    },
8305
    {
8306
        0x1661, "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", 4,
8307
        (struct spirv_parser_instruction_operand[])
8308
        {
8309
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8310
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8311
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8312
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8313
        }
8314
    },
8315
    {
8316
        0x1662, "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", 4,
8317
        (struct spirv_parser_instruction_operand[])
8318
        {
8319
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8320
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8321
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8322
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8323
        }
8324
    },
8325
    {
8326
        0x1663, "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", 5,
8327
        (struct spirv_parser_instruction_operand[])
8328
        {
8329
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8330
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8331
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8332
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8333
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8334
        }
8335
    },
8336
    {
8337
        0x1664, "OpSubgroupAvcMceConvertToImePayloadINTEL", 3,
8338
        (struct spirv_parser_instruction_operand[])
8339
        {
8340
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8341
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8342
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8343
        }
8344
    },
8345
    {
8346
        0x1665, "OpSubgroupAvcMceConvertToImeResultINTEL", 3,
8347
        (struct spirv_parser_instruction_operand[])
8348
        {
8349
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8350
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8351
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8352
        }
8353
    },
8354
    {
8355
        0x1666, "OpSubgroupAvcMceConvertToRefPayloadINTEL", 3,
8356
        (struct spirv_parser_instruction_operand[])
8357
        {
8358
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8359
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8360
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8361
        }
8362
    },
8363
    {
8364
        0x1667, "OpSubgroupAvcMceConvertToRefResultINTEL", 3,
8365
        (struct spirv_parser_instruction_operand[])
8366
        {
8367
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8368
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8369
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8370
        }
8371
    },
8372
    {
8373
        0x1668, "OpSubgroupAvcMceConvertToSicPayloadINTEL", 3,
8374
        (struct spirv_parser_instruction_operand[])
8375
        {
8376
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8377
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8378
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8379
        }
8380
    },
8381
    {
8382
        0x1669, "OpSubgroupAvcMceConvertToSicResultINTEL", 3,
8383
        (struct spirv_parser_instruction_operand[])
8384
        {
8385
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8386
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8387
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8388
        }
8389
    },
8390
    {
8391
        0x166a, "OpSubgroupAvcMceGetMotionVectorsINTEL", 3,
8392
        (struct spirv_parser_instruction_operand[])
8393
        {
8394
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8395
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8396
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8397
        }
8398
    },
8399
    {
8400
        0x166b, "OpSubgroupAvcMceGetInterDistortionsINTEL", 3,
8401
        (struct spirv_parser_instruction_operand[])
8402
        {
8403
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8404
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8405
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8406
        }
8407
    },
8408
    {
8409
        0x166c, "OpSubgroupAvcMceGetBestInterDistortionsINTEL", 3,
8410
        (struct spirv_parser_instruction_operand[])
8411
        {
8412
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8413
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8414
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8415
        }
8416
    },
8417
    {
8418
        0x166d, "OpSubgroupAvcMceGetInterMajorShapeINTEL", 3,
8419
        (struct spirv_parser_instruction_operand[])
8420
        {
8421
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8422
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8423
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8424
        }
8425
    },
8426
    {
8427
        0x166e, "OpSubgroupAvcMceGetInterMinorShapeINTEL", 3,
8428
        (struct spirv_parser_instruction_operand[])
8429
        {
8430
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8431
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8432
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8433
        }
8434
    },
8435
    {
8436
        0x166f, "OpSubgroupAvcMceGetInterDirectionsINTEL", 3,
8437
        (struct spirv_parser_instruction_operand[])
8438
        {
8439
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8440
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8441
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8442
        }
8443
    },
8444
    {
8445
        0x1670, "OpSubgroupAvcMceGetInterMotionVectorCountINTEL", 3,
8446
        (struct spirv_parser_instruction_operand[])
8447
        {
8448
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8449
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8450
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8451
        }
8452
    },
8453
    {
8454
        0x1671, "OpSubgroupAvcMceGetInterReferenceIdsINTEL", 3,
8455
        (struct spirv_parser_instruction_operand[])
8456
        {
8457
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8458
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8459
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8460
        }
8461
    },
8462
    {
8463
        0x1672, "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", 5,
8464
        (struct spirv_parser_instruction_operand[])
8465
        {
8466
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8467
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8468
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8469
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8470
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8471
        }
8472
    },
8473
    {
8474
        0x1673, "OpSubgroupAvcImeInitializeINTEL", 5,
8475
        (struct spirv_parser_instruction_operand[])
8476
        {
8477
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8478
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8479
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8480
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8481
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8482
        }
8483
    },
8484
    {
8485
        0x1674, "OpSubgroupAvcImeSetSingleReferenceINTEL", 5,
8486
        (struct spirv_parser_instruction_operand[])
8487
        {
8488
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8489
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8490
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8491
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8492
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8493
        }
8494
    },
8495
    {
8496
        0x1675, "OpSubgroupAvcImeSetDualReferenceINTEL", 6,
8497
        (struct spirv_parser_instruction_operand[])
8498
        {
8499
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8500
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8501
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8502
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8503
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8504
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8505
        }
8506
    },
8507
    {
8508
        0x1676, "OpSubgroupAvcImeRefWindowSizeINTEL", 4,
8509
        (struct spirv_parser_instruction_operand[])
8510
        {
8511
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8512
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8513
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8514
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8515
        }
8516
    },
8517
    {
8518
        0x1677, "OpSubgroupAvcImeAdjustRefOffsetINTEL", 6,
8519
        (struct spirv_parser_instruction_operand[])
8520
        {
8521
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8522
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8523
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8524
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8525
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8526
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8527
        }
8528
    },
8529
    {
8530
        0x1678, "OpSubgroupAvcImeConvertToMcePayloadINTEL", 3,
8531
        (struct spirv_parser_instruction_operand[])
8532
        {
8533
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8534
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8535
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8536
        }
8537
    },
8538
    {
8539
        0x1679, "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", 4,
8540
        (struct spirv_parser_instruction_operand[])
8541
        {
8542
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8543
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8544
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8545
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8546
        }
8547
    },
8548
    {
8549
        0x167a, "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", 3,
8550
        (struct spirv_parser_instruction_operand[])
8551
        {
8552
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8553
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8554
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8555
        }
8556
    },
8557
    {
8558
        0x167b, "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", 4,
8559
        (struct spirv_parser_instruction_operand[])
8560
        {
8561
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8562
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8563
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8564
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8565
        }
8566
    },
8567
    {
8568
        0x167c, "OpSubgroupAvcImeSetWeightedSadINTEL", 4,
8569
        (struct spirv_parser_instruction_operand[])
8570
        {
8571
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8572
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8573
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8574
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8575
        }
8576
    },
8577
    {
8578
        0x167d, "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", 5,
8579
        (struct spirv_parser_instruction_operand[])
8580
        {
8581
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8582
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8583
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8584
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8585
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8586
        }
8587
    },
8588
    {
8589
        0x167e, "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", 6,
8590
        (struct spirv_parser_instruction_operand[])
8591
        {
8592
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8593
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8594
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8595
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8596
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8597
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8598
        }
8599
    },
8600
    {
8601
        0x167f, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", 6,
8602
        (struct spirv_parser_instruction_operand[])
8603
        {
8604
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8605
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8606
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8607
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8608
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8609
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8610
        }
8611
    },
8612
    {
8613
        0x1680, "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", 7,
8614
        (struct spirv_parser_instruction_operand[])
8615
        {
8616
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8617
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8618
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8619
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8620
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8621
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8622
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8623
        }
8624
    },
8625
    {
8626
        0x1681, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", 5,
8627
        (struct spirv_parser_instruction_operand[])
8628
        {
8629
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8630
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8631
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8632
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8633
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8634
        }
8635
    },
8636
    {
8637
        0x1682, "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", 6,
8638
        (struct spirv_parser_instruction_operand[])
8639
        {
8640
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8641
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8642
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8643
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8644
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8645
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8646
        }
8647
    },
8648
    {
8649
        0x1683, "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", 6,
8650
        (struct spirv_parser_instruction_operand[])
8651
        {
8652
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8653
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8654
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8655
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8656
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8657
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8658
        }
8659
    },
8660
    {
8661
        0x1684, "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", 7,
8662
        (struct spirv_parser_instruction_operand[])
8663
        {
8664
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8665
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8666
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8667
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8668
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8669
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8670
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8671
        }
8672
    },
8673
    {
8674
        0x1685, "OpSubgroupAvcImeConvertToMceResultINTEL", 3,
8675
        (struct spirv_parser_instruction_operand[])
8676
        {
8677
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8678
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8679
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8680
        }
8681
    },
8682
    {
8683
        0x1686, "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", 3,
8684
        (struct spirv_parser_instruction_operand[])
8685
        {
8686
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8687
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8688
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8689
        }
8690
    },
8691
    {
8692
        0x1687, "OpSubgroupAvcImeGetDualReferenceStreaminINTEL", 3,
8693
        (struct spirv_parser_instruction_operand[])
8694
        {
8695
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8696
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8697
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8698
        }
8699
    },
8700
    {
8701
        0x1688, "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", 3,
8702
        (struct spirv_parser_instruction_operand[])
8703
        {
8704
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8705
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8706
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8707
        }
8708
    },
8709
    {
8710
        0x1689, "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", 3,
8711
        (struct spirv_parser_instruction_operand[])
8712
        {
8713
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8714
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8715
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8716
        }
8717
    },
8718
    {
8719
        0x168a, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", 4,
8720
        (struct spirv_parser_instruction_operand[])
8721
        {
8722
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8723
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8724
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8725
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8726
        }
8727
    },
8728
    {
8729
        0x168b, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", 4,
8730
        (struct spirv_parser_instruction_operand[])
8731
        {
8732
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8733
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8734
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8735
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8736
        }
8737
    },
8738
    {
8739
        0x168c, "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", 4,
8740
        (struct spirv_parser_instruction_operand[])
8741
        {
8742
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8743
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8744
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8745
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8746
        }
8747
    },
8748
    {
8749
        0x168d, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", 5,
8750
        (struct spirv_parser_instruction_operand[])
8751
        {
8752
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8753
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8754
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8755
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8756
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8757
        }
8758
    },
8759
    {
8760
        0x168e, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", 5,
8761
        (struct spirv_parser_instruction_operand[])
8762
        {
8763
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8764
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8765
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8766
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8767
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8768
        }
8769
    },
8770
    {
8771
        0x168f, "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", 5,
8772
        (struct spirv_parser_instruction_operand[])
8773
        {
8774
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8775
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8776
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8777
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8778
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8779
        }
8780
    },
8781
    {
8782
        0x1690, "OpSubgroupAvcImeGetBorderReachedINTEL", 4,
8783
        (struct spirv_parser_instruction_operand[])
8784
        {
8785
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8786
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8787
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8788
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8789
        }
8790
    },
8791
    {
8792
        0x1691, "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", 3,
8793
        (struct spirv_parser_instruction_operand[])
8794
        {
8795
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8796
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8797
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8798
        }
8799
    },
8800
    {
8801
        0x1692, "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", 3,
8802
        (struct spirv_parser_instruction_operand[])
8803
        {
8804
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8805
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8806
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8807
        }
8808
    },
8809
    {
8810
        0x1693, "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", 3,
8811
        (struct spirv_parser_instruction_operand[])
8812
        {
8813
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8814
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8815
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8816
        }
8817
    },
8818
    {
8819
        0x1694, "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", 3,
8820
        (struct spirv_parser_instruction_operand[])
8821
        {
8822
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8823
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8824
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8825
        }
8826
    },
8827
    {
8828
        0x1695, "OpSubgroupAvcFmeInitializeINTEL", 9,
8829
        (struct spirv_parser_instruction_operand[])
8830
        {
8831
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8832
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8833
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8834
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8835
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8836
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8837
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8838
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8839
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8840
        }
8841
    },
8842
    {
8843
        0x1696, "OpSubgroupAvcBmeInitializeINTEL", 10,
8844
        (struct spirv_parser_instruction_operand[])
8845
        {
8846
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8847
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8848
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8849
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8850
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8851
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8852
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8853
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8854
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8855
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8856
        }
8857
    },
8858
    {
8859
        0x1697, "OpSubgroupAvcRefConvertToMcePayloadINTEL", 3,
8860
        (struct spirv_parser_instruction_operand[])
8861
        {
8862
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8863
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8864
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8865
        }
8866
    },
8867
    {
8868
        0x1698, "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", 3,
8869
        (struct spirv_parser_instruction_operand[])
8870
        {
8871
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8872
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8873
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8874
        }
8875
    },
8876
    {
8877
        0x1699, "OpSubgroupAvcRefSetBilinearFilterEnableINTEL", 3,
8878
        (struct spirv_parser_instruction_operand[])
8879
        {
8880
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8881
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8882
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8883
        }
8884
    },
8885
    {
8886
        0x169a, "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", 5,
8887
        (struct spirv_parser_instruction_operand[])
8888
        {
8889
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8890
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8891
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8892
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8893
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8894
        }
8895
    },
8896
    {
8897
        0x169b, "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", 6,
8898
        (struct spirv_parser_instruction_operand[])
8899
        {
8900
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8901
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8902
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8903
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8904
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8905
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8906
        }
8907
    },
8908
    {
8909
        0x169c, "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", 5,
8910
        (struct spirv_parser_instruction_operand[])
8911
        {
8912
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8913
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8914
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8915
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8916
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8917
        }
8918
    },
8919
    {
8920
        0x169d, "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", 6,
8921
        (struct spirv_parser_instruction_operand[])
8922
        {
8923
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8924
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8925
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8926
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8927
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8928
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8929
        }
8930
    },
8931
    {
8932
        0x169e, "OpSubgroupAvcRefConvertToMceResultINTEL", 3,
8933
        (struct spirv_parser_instruction_operand[])
8934
        {
8935
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8936
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8937
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8938
        }
8939
    },
8940
    {
8941
        0x169f, "OpSubgroupAvcSicInitializeINTEL", 3,
8942
        (struct spirv_parser_instruction_operand[])
8943
        {
8944
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8945
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8946
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8947
        }
8948
    },
8949
    {
8950
        0x16a0, "OpSubgroupAvcSicConfigureSkcINTEL", 8,
8951
        (struct spirv_parser_instruction_operand[])
8952
        {
8953
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8954
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8955
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8956
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8957
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8958
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8959
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8960
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8961
        }
8962
    },
8963
    {
8964
        0x16a1, "OpSubgroupAvcSicConfigureIpeLumaINTEL", 10,
8965
        (struct spirv_parser_instruction_operand[])
8966
        {
8967
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8968
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8969
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8970
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8971
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8972
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8973
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8974
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8975
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8976
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8977
        }
8978
    },
8979
    {
8980
        0x16a2, "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", 13,
8981
        (struct spirv_parser_instruction_operand[])
8982
        {
8983
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
8984
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
8985
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8986
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8987
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8988
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8989
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8990
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8991
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8992
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8993
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8994
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8995
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
8996
        }
8997
    },
8998
    {
8999
        0x16a3, "OpSubgroupAvcSicGetMotionVectorMaskINTEL", 4,
9000
        (struct spirv_parser_instruction_operand[])
9001
        {
9002
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9003
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9004
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9005
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9006
        }
9007
    },
9008
    {
9009
        0x16a4, "OpSubgroupAvcSicConvertToMcePayloadINTEL", 3,
9010
        (struct spirv_parser_instruction_operand[])
9011
        {
9012
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9013
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9014
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9015
        }
9016
    },
9017
    {
9018
        0x16a5, "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", 4,
9019
        (struct spirv_parser_instruction_operand[])
9020
        {
9021
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9022
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9023
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9024
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9025
        }
9026
    },
9027
    {
9028
        0x16a6, "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", 6,
9029
        (struct spirv_parser_instruction_operand[])
9030
        {
9031
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9032
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9033
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9034
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9035
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9036
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9037
        }
9038
    },
9039
    {
9040
        0x16a7, "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", 4,
9041
        (struct spirv_parser_instruction_operand[])
9042
        {
9043
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9044
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9045
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9046
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9047
        }
9048
    },
9049
    {
9050
        0x16a8, "OpSubgroupAvcSicSetBilinearFilterEnableINTEL", 3,
9051
        (struct spirv_parser_instruction_operand[])
9052
        {
9053
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9054
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9055
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9056
        }
9057
    },
9058
    {
9059
        0x16a9, "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", 4,
9060
        (struct spirv_parser_instruction_operand[])
9061
        {
9062
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9063
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9064
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9065
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9066
        }
9067
    },
9068
    {
9069
        0x16aa, "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", 4,
9070
        (struct spirv_parser_instruction_operand[])
9071
        {
9072
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9073
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9074
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9075
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9076
        }
9077
    },
9078
    {
9079
        0x16ab, "OpSubgroupAvcSicEvaluateIpeINTEL", 4,
9080
        (struct spirv_parser_instruction_operand[])
9081
        {
9082
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9083
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9084
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9085
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9086
        }
9087
    },
9088
    {
9089
        0x16ac, "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", 5,
9090
        (struct spirv_parser_instruction_operand[])
9091
        {
9092
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9093
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9094
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9095
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9096
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9097
        }
9098
    },
9099
    {
9100
        0x16ad, "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", 6,
9101
        (struct spirv_parser_instruction_operand[])
9102
        {
9103
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9104
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9105
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9106
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9107
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9108
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9109
        }
9110
    },
9111
    {
9112
        0x16ae, "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", 5,
9113
        (struct spirv_parser_instruction_operand[])
9114
        {
9115
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9116
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9117
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9118
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9119
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9120
        }
9121
    },
9122
    {
9123
        0x16af, "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", 6,
9124
        (struct spirv_parser_instruction_operand[])
9125
        {
9126
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9127
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9128
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9129
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9130
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9131
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9132
        }
9133
    },
9134
    {
9135
        0x16b0, "OpSubgroupAvcSicConvertToMceResultINTEL", 3,
9136
        (struct spirv_parser_instruction_operand[])
9137
        {
9138
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9139
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9140
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9141
        }
9142
    },
9143
    {
9144
        0x16b1, "OpSubgroupAvcSicGetIpeLumaShapeINTEL", 3,
9145
        (struct spirv_parser_instruction_operand[])
9146
        {
9147
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9148
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9149
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9150
        }
9151
    },
9152
    {
9153
        0x16b2, "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", 3,
9154
        (struct spirv_parser_instruction_operand[])
9155
        {
9156
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9157
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9158
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9159
        }
9160
    },
9161
    {
9162
        0x16b3, "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", 3,
9163
        (struct spirv_parser_instruction_operand[])
9164
        {
9165
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9166
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9167
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9168
        }
9169
    },
9170
    {
9171
        0x16b4, "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", 3,
9172
        (struct spirv_parser_instruction_operand[])
9173
        {
9174
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9175
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9176
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9177
        }
9178
    },
9179
    {
9180
        0x16b5, "OpSubgroupAvcSicGetIpeChromaModeINTEL", 3,
9181
        (struct spirv_parser_instruction_operand[])
9182
        {
9183
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9184
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9185
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9186
        }
9187
    },
9188
    {
9189
        0x16b6, "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", 3,
9190
        (struct spirv_parser_instruction_operand[])
9191
        {
9192
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9193
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9194
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9195
        }
9196
    },
9197
    {
9198
        0x16b7, "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", 3,
9199
        (struct spirv_parser_instruction_operand[])
9200
        {
9201
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9202
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9203
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9204
        }
9205
    },
9206
    {
9207
        0x16b8, "OpSubgroupAvcSicGetInterRawSadsINTEL", 3,
9208
        (struct spirv_parser_instruction_operand[])
9209
        {
9210
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9211
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9212
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9213
        }
9214
    },
9215
    {
9216
        0x16ba, "OpVariableLengthArrayINTEL", 3,
9217
        (struct spirv_parser_instruction_operand[])
9218
        {
9219
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9220
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9221
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9222
        }
9223
    },
9224
    {
9225
        0x16bb, "OpSaveMemoryINTEL", 2,
9226
        (struct spirv_parser_instruction_operand[])
9227
        {
9228
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9229
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9230
        }
9231
    },
9232
    {
9233
        0x16bc, "OpRestoreMemoryINTEL", 1,
9234
        (struct spirv_parser_instruction_operand[])
9235
        {
9236
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9237
        }
9238
    },
9239
    {
9240
        0x16d0, "OpArbitraryFloatSinCosPiINTEL", 8,
9241
        (struct spirv_parser_instruction_operand[])
9242
        {
9243
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9244
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9245
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9246
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9247
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9248
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9249
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9250
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9251
        }
9252
    },
9253
    {
9254
        0x16d1, "OpArbitraryFloatCastINTEL", 8,
9255
        (struct spirv_parser_instruction_operand[])
9256
        {
9257
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9258
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9259
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9260
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9261
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9262
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9263
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9264
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9265
        }
9266
    },
9267
    {
9268
        0x16d2, "OpArbitraryFloatCastFromIntINTEL", 8,
9269
        (struct spirv_parser_instruction_operand[])
9270
        {
9271
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9272
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9273
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9274
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9275
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9276
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9277
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9278
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9279
        }
9280
    },
9281
    {
9282
        0x16d3, "OpArbitraryFloatCastToIntINTEL", 8,
9283
        (struct spirv_parser_instruction_operand[])
9284
        {
9285
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9286
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9287
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9288
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9289
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9290
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9291
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9292
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9293
        }
9294
    },
9295
    {
9296
        0x16d6, "OpArbitraryFloatAddINTEL", 10,
9297
        (struct spirv_parser_instruction_operand[])
9298
        {
9299
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9300
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9301
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9302
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9303
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9304
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9305
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9306
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9307
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9308
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9309
        }
9310
    },
9311
    {
9312
        0x16d7, "OpArbitraryFloatSubINTEL", 10,
9313
        (struct spirv_parser_instruction_operand[])
9314
        {
9315
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9316
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9317
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9318
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9319
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9320
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9321
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9322
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9323
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9324
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9325
        }
9326
    },
9327
    {
9328
        0x16d8, "OpArbitraryFloatMulINTEL", 10,
9329
        (struct spirv_parser_instruction_operand[])
9330
        {
9331
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9332
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9333
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9334
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9335
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9336
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9337
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9338
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9339
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9340
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9341
        }
9342
    },
9343
    {
9344
        0x16d9, "OpArbitraryFloatDivINTEL", 10,
9345
        (struct spirv_parser_instruction_operand[])
9346
        {
9347
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9348
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9349
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9350
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9351
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9352
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9353
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9354
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9355
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9356
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9357
        }
9358
    },
9359
    {
9360
        0x16da, "OpArbitraryFloatGTINTEL", 6,
9361
        (struct spirv_parser_instruction_operand[])
9362
        {
9363
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9364
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9365
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9366
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9367
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9368
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9369
        }
9370
    },
9371
    {
9372
        0x16db, "OpArbitraryFloatGEINTEL", 6,
9373
        (struct spirv_parser_instruction_operand[])
9374
        {
9375
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9376
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9377
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9378
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9379
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9380
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9381
        }
9382
    },
9383
    {
9384
        0x16dc, "OpArbitraryFloatLTINTEL", 6,
9385
        (struct spirv_parser_instruction_operand[])
9386
        {
9387
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9388
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9389
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9390
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9391
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9392
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9393
        }
9394
    },
9395
    {
9396
        0x16dd, "OpArbitraryFloatLEINTEL", 6,
9397
        (struct spirv_parser_instruction_operand[])
9398
        {
9399
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9400
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9401
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9402
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9403
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9404
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9405
        }
9406
    },
9407
    {
9408
        0x16de, "OpArbitraryFloatEQINTEL", 6,
9409
        (struct spirv_parser_instruction_operand[])
9410
        {
9411
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9412
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9413
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9414
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9415
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9416
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9417
        }
9418
    },
9419
    {
9420
        0x16df, "OpArbitraryFloatRecipINTEL", 8,
9421
        (struct spirv_parser_instruction_operand[])
9422
        {
9423
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9424
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9425
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9426
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9427
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9428
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9429
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9430
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9431
        }
9432
    },
9433
    {
9434
        0x16e0, "OpArbitraryFloatRSqrtINTEL", 8,
9435
        (struct spirv_parser_instruction_operand[])
9436
        {
9437
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9438
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9439
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9440
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9441
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9442
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9443
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9444
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9445
        }
9446
    },
9447
    {
9448
        0x16e1, "OpArbitraryFloatCbrtINTEL", 8,
9449
        (struct spirv_parser_instruction_operand[])
9450
        {
9451
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9452
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9453
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9454
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9455
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9456
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9457
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9458
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9459
        }
9460
    },
9461
    {
9462
        0x16e2, "OpArbitraryFloatHypotINTEL", 10,
9463
        (struct spirv_parser_instruction_operand[])
9464
        {
9465
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9466
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9467
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9468
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9469
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9470
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9471
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9472
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9473
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9474
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9475
        }
9476
    },
9477
    {
9478
        0x16e3, "OpArbitraryFloatSqrtINTEL", 8,
9479
        (struct spirv_parser_instruction_operand[])
9480
        {
9481
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9482
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9483
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9484
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9485
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9486
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9487
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9488
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9489
        }
9490
    },
9491
    {
9492
        0x16e4, "OpArbitraryFloatLogINTEL", 8,
9493
        (struct spirv_parser_instruction_operand[])
9494
        {
9495
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9496
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9497
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9498
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9499
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9500
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9501
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9502
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9503
        }
9504
    },
9505
    {
9506
        0x16e5, "OpArbitraryFloatLog2INTEL", 8,
9507
        (struct spirv_parser_instruction_operand[])
9508
        {
9509
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9510
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9511
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9512
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9513
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9514
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9515
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9516
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9517
        }
9518
    },
9519
    {
9520
        0x16e6, "OpArbitraryFloatLog10INTEL", 8,
9521
        (struct spirv_parser_instruction_operand[])
9522
        {
9523
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9524
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9525
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9526
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9527
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9528
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9529
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9530
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9531
        }
9532
    },
9533
    {
9534
        0x16e7, "OpArbitraryFloatLog1pINTEL", 8,
9535
        (struct spirv_parser_instruction_operand[])
9536
        {
9537
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9538
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9539
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9540
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9541
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9542
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9543
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9544
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9545
        }
9546
    },
9547
    {
9548
        0x16e8, "OpArbitraryFloatExpINTEL", 8,
9549
        (struct spirv_parser_instruction_operand[])
9550
        {
9551
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9552
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9553
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9554
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9555
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9556
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9557
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9558
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9559
        }
9560
    },
9561
    {
9562
        0x16e9, "OpArbitraryFloatExp2INTEL", 8,
9563
        (struct spirv_parser_instruction_operand[])
9564
        {
9565
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9566
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9567
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9568
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9569
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9570
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9571
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9572
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9573
        }
9574
    },
9575
    {
9576
        0x16ea, "OpArbitraryFloatExp10INTEL", 8,
9577
        (struct spirv_parser_instruction_operand[])
9578
        {
9579
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9580
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9581
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9582
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9583
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9584
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9585
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9586
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9587
        }
9588
    },
9589
    {
9590
        0x16eb, "OpArbitraryFloatExpm1INTEL", 8,
9591
        (struct spirv_parser_instruction_operand[])
9592
        {
9593
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9594
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9595
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9596
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9597
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9598
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9599
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9600
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9601
        }
9602
    },
9603
    {
9604
        0x16ec, "OpArbitraryFloatSinINTEL", 8,
9605
        (struct spirv_parser_instruction_operand[])
9606
        {
9607
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9608
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9609
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9610
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9611
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9612
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9613
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9614
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9615
        }
9616
    },
9617
    {
9618
        0x16ed, "OpArbitraryFloatCosINTEL", 8,
9619
        (struct spirv_parser_instruction_operand[])
9620
        {
9621
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9622
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9623
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9624
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9625
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9626
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9627
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9628
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9629
        }
9630
    },
9631
    {
9632
        0x16ee, "OpArbitraryFloatSinCosINTEL", 8,
9633
        (struct spirv_parser_instruction_operand[])
9634
        {
9635
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9636
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9637
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9638
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9639
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9640
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9641
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9642
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9643
        }
9644
    },
9645
    {
9646
        0x16ef, "OpArbitraryFloatSinPiINTEL", 8,
9647
        (struct spirv_parser_instruction_operand[])
9648
        {
9649
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9650
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9651
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9652
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9653
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9654
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9655
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9656
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9657
        }
9658
    },
9659
    {
9660
        0x16f0, "OpArbitraryFloatCosPiINTEL", 8,
9661
        (struct spirv_parser_instruction_operand[])
9662
        {
9663
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9664
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9665
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9666
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9667
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9668
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9669
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9670
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9671
        }
9672
    },
9673
    {
9674
        0x16f1, "OpArbitraryFloatASinINTEL", 8,
9675
        (struct spirv_parser_instruction_operand[])
9676
        {
9677
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9678
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9679
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9680
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9681
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9682
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9683
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9684
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9685
        }
9686
    },
9687
    {
9688
        0x16f2, "OpArbitraryFloatASinPiINTEL", 8,
9689
        (struct spirv_parser_instruction_operand[])
9690
        {
9691
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9692
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9693
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9694
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9695
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9696
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9697
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9698
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9699
        }
9700
    },
9701
    {
9702
        0x16f3, "OpArbitraryFloatACosINTEL", 8,
9703
        (struct spirv_parser_instruction_operand[])
9704
        {
9705
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9706
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9707
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9708
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9709
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9710
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9711
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9712
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9713
        }
9714
    },
9715
    {
9716
        0x16f4, "OpArbitraryFloatACosPiINTEL", 8,
9717
        (struct spirv_parser_instruction_operand[])
9718
        {
9719
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9720
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9721
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9722
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9723
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9724
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9725
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9726
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9727
        }
9728
    },
9729
    {
9730
        0x16f5, "OpArbitraryFloatATanINTEL", 8,
9731
        (struct spirv_parser_instruction_operand[])
9732
        {
9733
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9734
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9735
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9736
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9737
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9738
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9739
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9740
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9741
        }
9742
    },
9743
    {
9744
        0x16f6, "OpArbitraryFloatATanPiINTEL", 8,
9745
        (struct spirv_parser_instruction_operand[])
9746
        {
9747
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9748
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9749
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9750
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9751
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9752
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9753
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9754
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9755
        }
9756
    },
9757
    {
9758
        0x16f7, "OpArbitraryFloatATan2INTEL", 10,
9759
        (struct spirv_parser_instruction_operand[])
9760
        {
9761
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9762
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9763
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9764
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9765
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9766
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9767
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9768
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9769
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9770
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9771
        }
9772
    },
9773
    {
9774
        0x16f8, "OpArbitraryFloatPowINTEL", 10,
9775
        (struct spirv_parser_instruction_operand[])
9776
        {
9777
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9778
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9779
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9780
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9781
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9782
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9783
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9784
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9785
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9786
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9787
        }
9788
    },
9789
    {
9790
        0x16f9, "OpArbitraryFloatPowRINTEL", 10,
9791
        (struct spirv_parser_instruction_operand[])
9792
        {
9793
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9794
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9795
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9796
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9797
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9798
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9799
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9800
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9801
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9802
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9803
        }
9804
    },
9805
    {
9806
        0x16fa, "OpArbitraryFloatPowNINTEL", 10,
9807
        (struct spirv_parser_instruction_operand[])
9808
        {
9809
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9810
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9811
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9812
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9813
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9814
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9815
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9816
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9817
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9818
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9819
        }
9820
    },
9821
    {
9822
        0x16ff, "OpLoopControlINTEL", 1,
9823
        (struct spirv_parser_instruction_operand[])
9824
        {
9825
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER, '*'},
9826
        }
9827
    },
9828
    {
9829
        0x1717, "OpAliasDomainDeclINTEL", 2,
9830
        (struct spirv_parser_instruction_operand[])
9831
        {
9832
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9833
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
9834
        }
9835
    },
9836
    {
9837
        0x1718, "OpAliasScopeDeclINTEL", 3,
9838
        (struct spirv_parser_instruction_operand[])
9839
        {
9840
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9841
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9842
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '?'},
9843
        }
9844
    },
9845
    {
9846
        0x1719, "OpAliasScopeListDeclINTEL", 2,
9847
        (struct spirv_parser_instruction_operand[])
9848
        {
9849
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9850
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
9851
        }
9852
    },
9853
    {
9854
        0x1723, "OpFixedSqrtINTEL", 8,
9855
        (struct spirv_parser_instruction_operand[])
9856
        {
9857
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9858
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9859
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9860
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9861
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9862
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9863
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9864
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9865
        }
9866
    },
9867
    {
9868
        0x1724, "OpFixedRecipINTEL", 8,
9869
        (struct spirv_parser_instruction_operand[])
9870
        {
9871
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9872
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9873
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9874
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9875
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9876
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9877
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9878
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9879
        }
9880
    },
9881
    {
9882
        0x1725, "OpFixedRsqrtINTEL", 8,
9883
        (struct spirv_parser_instruction_operand[])
9884
        {
9885
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9886
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9887
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9888
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9889
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9890
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9891
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9892
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9893
        }
9894
    },
9895
    {
9896
        0x1726, "OpFixedSinINTEL", 8,
9897
        (struct spirv_parser_instruction_operand[])
9898
        {
9899
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9900
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9901
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9902
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9903
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9904
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9905
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9906
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9907
        }
9908
    },
9909
    {
9910
        0x1727, "OpFixedCosINTEL", 8,
9911
        (struct spirv_parser_instruction_operand[])
9912
        {
9913
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9914
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9915
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9916
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9917
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9918
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9919
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9920
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9921
        }
9922
    },
9923
    {
9924
        0x1728, "OpFixedSinCosINTEL", 8,
9925
        (struct spirv_parser_instruction_operand[])
9926
        {
9927
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9928
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9929
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9930
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9931
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9932
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9933
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9934
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9935
        }
9936
    },
9937
    {
9938
        0x1729, "OpFixedSinPiINTEL", 8,
9939
        (struct spirv_parser_instruction_operand[])
9940
        {
9941
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9942
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9943
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9944
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9945
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9946
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9947
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9948
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9949
        }
9950
    },
9951
    {
9952
        0x172a, "OpFixedCosPiINTEL", 8,
9953
        (struct spirv_parser_instruction_operand[])
9954
        {
9955
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9956
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9957
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9958
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9959
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9960
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9961
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9962
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9963
        }
9964
    },
9965
    {
9966
        0x172b, "OpFixedSinCosPiINTEL", 8,
9967
        (struct spirv_parser_instruction_operand[])
9968
        {
9969
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9970
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9971
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9972
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9973
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9974
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9975
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9976
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9977
        }
9978
    },
9979
    {
9980
        0x172c, "OpFixedLogINTEL", 8,
9981
        (struct spirv_parser_instruction_operand[])
9982
        {
9983
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9984
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9985
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
9986
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9987
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9988
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9989
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9990
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
9991
        }
9992
    },
9993
    {
9994
        0x172d, "OpFixedExpINTEL", 8,
9995
        (struct spirv_parser_instruction_operand[])
9996
        {
9997
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
9998
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
9999
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10000
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10001
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10002
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10003
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10004
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10005
        }
10006
    },
10007
    {
10008
        0x172e, "OpPtrCastToCrossWorkgroupINTEL", 3,
10009
        (struct spirv_parser_instruction_operand[])
10010
        {
10011
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10012
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10013
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10014
        }
10015
    },
10016
    {
10017
        0x1732, "OpCrossWorkgroupCastToPtrINTEL", 3,
10018
        (struct spirv_parser_instruction_operand[])
10019
        {
10020
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10021
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10022
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10023
        }
10024
    },
10025
    {
10026
        0x173a, "OpReadPipeBlockingINTEL", 4,
10027
        (struct spirv_parser_instruction_operand[])
10028
        {
10029
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10030
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10031
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10032
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10033
        }
10034
    },
10035
    {
10036
        0x173b, "OpWritePipeBlockingINTEL", 4,
10037
        (struct spirv_parser_instruction_operand[])
10038
        {
10039
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10040
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10041
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10042
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10043
        }
10044
    },
10045
    {
10046
        0x173d, "OpFPGARegINTEL", 3,
10047
        (struct spirv_parser_instruction_operand[])
10048
        {
10049
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10050
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10051
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10052
        }
10053
    },
10054
    {
10055
        0x1780, "OpRayQueryGetRayTMinKHR", 3,
10056
        (struct spirv_parser_instruction_operand[])
10057
        {
10058
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10059
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10060
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10061
        }
10062
    },
10063
    {
10064
        0x1781, "OpRayQueryGetRayFlagsKHR", 3,
10065
        (struct spirv_parser_instruction_operand[])
10066
        {
10067
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10068
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10069
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10070
        }
10071
    },
10072
    {
10073
        0x1782, "OpRayQueryGetIntersectionTKHR", 4,
10074
        (struct spirv_parser_instruction_operand[])
10075
        {
10076
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10077
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10078
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10079
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10080
        }
10081
    },
10082
    {
10083
        0x1783, "OpRayQueryGetIntersectionInstanceCustomIndexKHR", 4,
10084
        (struct spirv_parser_instruction_operand[])
10085
        {
10086
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10087
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10088
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10089
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10090
        }
10091
    },
10092
    {
10093
        0x1784, "OpRayQueryGetIntersectionInstanceIdKHR", 4,
10094
        (struct spirv_parser_instruction_operand[])
10095
        {
10096
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10097
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10098
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10099
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10100
        }
10101
    },
10102
    {
10103
        0x1785, "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", 4,
10104
        (struct spirv_parser_instruction_operand[])
10105
        {
10106
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10107
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10108
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10109
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10110
        }
10111
    },
10112
    {
10113
        0x1786, "OpRayQueryGetIntersectionGeometryIndexKHR", 4,
10114
        (struct spirv_parser_instruction_operand[])
10115
        {
10116
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10117
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10118
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10119
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10120
        }
10121
    },
10122
    {
10123
        0x1787, "OpRayQueryGetIntersectionPrimitiveIndexKHR", 4,
10124
        (struct spirv_parser_instruction_operand[])
10125
        {
10126
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10127
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10128
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10129
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10130
        }
10131
    },
10132
    {
10133
        0x1788, "OpRayQueryGetIntersectionBarycentricsKHR", 4,
10134
        (struct spirv_parser_instruction_operand[])
10135
        {
10136
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10137
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10138
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10139
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10140
        }
10141
    },
10142
    {
10143
        0x1789, "OpRayQueryGetIntersectionFrontFaceKHR", 4,
10144
        (struct spirv_parser_instruction_operand[])
10145
        {
10146
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10147
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10148
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10149
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10150
        }
10151
    },
10152
    {
10153
        0x178a, "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", 3,
10154
        (struct spirv_parser_instruction_operand[])
10155
        {
10156
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10157
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10158
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10159
        }
10160
    },
10161
    {
10162
        0x178b, "OpRayQueryGetIntersectionObjectRayDirectionKHR", 4,
10163
        (struct spirv_parser_instruction_operand[])
10164
        {
10165
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10166
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10167
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10168
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10169
        }
10170
    },
10171
    {
10172
        0x178c, "OpRayQueryGetIntersectionObjectRayOriginKHR", 4,
10173
        (struct spirv_parser_instruction_operand[])
10174
        {
10175
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10176
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10177
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10178
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10179
        }
10180
    },
10181
    {
10182
        0x178d, "OpRayQueryGetWorldRayDirectionKHR", 3,
10183
        (struct spirv_parser_instruction_operand[])
10184
        {
10185
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10186
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10187
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10188
        }
10189
    },
10190
    {
10191
        0x178e, "OpRayQueryGetWorldRayOriginKHR", 3,
10192
        (struct spirv_parser_instruction_operand[])
10193
        {
10194
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10195
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10196
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10197
        }
10198
    },
10199
    {
10200
        0x178f, "OpRayQueryGetIntersectionObjectToWorldKHR", 4,
10201
        (struct spirv_parser_instruction_operand[])
10202
        {
10203
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10204
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10205
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10206
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10207
        }
10208
    },
10209
    {
10210
        0x1790, "OpRayQueryGetIntersectionWorldToObjectKHR", 4,
10211
        (struct spirv_parser_instruction_operand[])
10212
        {
10213
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10214
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10215
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10216
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10217
        }
10218
    },
10219
    {
10220
        0x1793, "OpAtomicFAddEXT", 6,
10221
        (struct spirv_parser_instruction_operand[])
10222
        {
10223
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10224
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10225
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10226
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10227
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
10228
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10229
        }
10230
    },
10231
    {
10232
        0x17c6, "OpTypeBufferSurfaceINTEL", 2,
10233
        (struct spirv_parser_instruction_operand[])
10234
        {
10235
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10236
            {SPIRV_PARSER_OPERAND_TYPE_ACCESS_QUALIFIER},
10237
        }
10238
    },
10239
    {
10240
        0x17ca, "OpTypeStructContinuedINTEL", 1,
10241
        (struct spirv_parser_instruction_operand[])
10242
        {
10243
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
10244
        }
10245
    },
10246
    {
10247
        0x17cb, "OpConstantCompositeContinuedINTEL", 1,
10248
        (struct spirv_parser_instruction_operand[])
10249
        {
10250
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
10251
        }
10252
    },
10253
    {
10254
        0x17cc, "OpSpecConstantCompositeContinuedINTEL", 1,
10255
        (struct spirv_parser_instruction_operand[])
10256
        {
10257
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
10258
        }
10259
    },
10260
    {
10261
        0x17d0, "OpCompositeConstructContinuedINTEL", 3,
10262
        (struct spirv_parser_instruction_operand[])
10263
        {
10264
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10265
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10266
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
10267
        }
10268
    },
10269
    {
10270
        0x17e4, "OpConvertFToBF16INTEL", 3,
10271
        (struct spirv_parser_instruction_operand[])
10272
        {
10273
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10274
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10275
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10276
        }
10277
    },
10278
    {
10279
        0x17e5, "OpConvertBF16ToFINTEL", 3,
10280
        (struct spirv_parser_instruction_operand[])
10281
        {
10282
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10283
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10284
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10285
        }
10286
    },
10287
    {
10288
        0x17fe, "OpControlBarrierArriveINTEL", 3,
10289
        (struct spirv_parser_instruction_operand[])
10290
        {
10291
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10292
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10293
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
10294
        }
10295
    },
10296
    {
10297
        0x17ff, "OpControlBarrierWaitINTEL", 3,
10298
        (struct spirv_parser_instruction_operand[])
10299
        {
10300
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10301
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10302
            {SPIRV_PARSER_OPERAND_TYPE_ID_MEMORY_SEMANTICS},
10303
        }
10304
    },
10305
    {
10306
        0x1801, "OpArithmeticFenceEXT", 3,
10307
        (struct spirv_parser_instruction_operand[])
10308
        {
10309
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10310
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10311
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10312
        }
10313
    },
10314
    {
10315
        0x1813, "OpTaskSequenceCreateINTEL", 7,
10316
        (struct spirv_parser_instruction_operand[])
10317
        {
10318
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10319
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10320
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10321
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10322
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10323
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10324
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10325
        }
10326
    },
10327
    {
10328
        0x1814, "OpTaskSequenceAsyncINTEL", 2,
10329
        (struct spirv_parser_instruction_operand[])
10330
        {
10331
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10332
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF, '*'},
10333
        }
10334
    },
10335
    {
10336
        0x1815, "OpTaskSequenceGetINTEL", 3,
10337
        (struct spirv_parser_instruction_operand[])
10338
        {
10339
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10340
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10341
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10342
        }
10343
    },
10344
    {
10345
        0x1816, "OpTaskSequenceReleaseINTEL", 1,
10346
        (struct spirv_parser_instruction_operand[])
10347
        {
10348
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10349
        }
10350
    },
10351
    {
10352
        0x1837, "OpTypeTaskSequenceINTEL", 1,
10353
        (struct spirv_parser_instruction_operand[])
10354
        {
10355
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10356
        }
10357
    },
10358
    {
10359
        0x184d, "OpSubgroupBlockPrefetchINTEL", 3,
10360
        (struct spirv_parser_instruction_operand[])
10361
        {
10362
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10363
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10364
            {SPIRV_PARSER_OPERAND_TYPE_MEMORY_ACCESS, '?'},
10365
        }
10366
    },
10367
    {
10368
        0x1857, "OpSubgroup2DBlockLoadINTEL", 10,
10369
        (struct spirv_parser_instruction_operand[])
10370
        {
10371
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10372
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10373
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10374
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10375
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10376
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10377
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10378
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10379
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10380
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10381
        }
10382
    },
10383
    {
10384
        0x1858, "OpSubgroup2DBlockLoadTransformINTEL", 10,
10385
        (struct spirv_parser_instruction_operand[])
10386
        {
10387
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10388
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10389
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10390
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10391
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10392
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10393
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10394
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10395
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10396
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10397
        }
10398
    },
10399
    {
10400
        0x1859, "OpSubgroup2DBlockLoadTransposeINTEL", 10,
10401
        (struct spirv_parser_instruction_operand[])
10402
        {
10403
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10404
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10405
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10406
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10407
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10408
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10409
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10410
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10411
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10412
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10413
        }
10414
    },
10415
    {
10416
        0x185a, "OpSubgroup2DBlockPrefetchINTEL", 9,
10417
        (struct spirv_parser_instruction_operand[])
10418
        {
10419
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10420
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10421
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10422
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10423
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10424
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10425
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10426
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10427
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10428
        }
10429
    },
10430
    {
10431
        0x185b, "OpSubgroup2DBlockStoreINTEL", 10,
10432
        (struct spirv_parser_instruction_operand[])
10433
        {
10434
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10435
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10436
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10437
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10438
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10439
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10440
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10441
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10442
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10443
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10444
        }
10445
    },
10446
    {
10447
        0x185d, "OpSubgroupMatrixMultiplyAccumulateINTEL", 7,
10448
        (struct spirv_parser_instruction_operand[])
10449
        {
10450
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10451
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10452
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10453
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10454
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10455
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10456
            {SPIRV_PARSER_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS, '?'},
10457
        }
10458
    },
10459
    {
10460
        0x1862, "OpBitwiseFunctionINTEL", 6,
10461
        (struct spirv_parser_instruction_operand[])
10462
        {
10463
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10464
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10465
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10466
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10467
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10468
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10469
        }
10470
    },
10471
    {
10472
        0x1901, "OpGroupIMulKHR", 5,
10473
        (struct spirv_parser_instruction_operand[])
10474
        {
10475
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10476
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10477
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10478
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10479
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10480
        }
10481
    },
10482
    {
10483
        0x1902, "OpGroupFMulKHR", 5,
10484
        (struct spirv_parser_instruction_operand[])
10485
        {
10486
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10487
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10488
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10489
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10490
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10491
        }
10492
    },
10493
    {
10494
        0x1903, "OpGroupBitwiseAndKHR", 5,
10495
        (struct spirv_parser_instruction_operand[])
10496
        {
10497
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10498
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10499
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10500
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10501
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10502
        }
10503
    },
10504
    {
10505
        0x1904, "OpGroupBitwiseOrKHR", 5,
10506
        (struct spirv_parser_instruction_operand[])
10507
        {
10508
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10509
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10510
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10511
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10512
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10513
        }
10514
    },
10515
    {
10516
        0x1905, "OpGroupBitwiseXorKHR", 5,
10517
        (struct spirv_parser_instruction_operand[])
10518
        {
10519
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10520
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10521
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10522
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10523
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10524
        }
10525
    },
10526
    {
10527
        0x1906, "OpGroupLogicalAndKHR", 5,
10528
        (struct spirv_parser_instruction_operand[])
10529
        {
10530
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10531
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10532
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10533
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10534
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10535
        }
10536
    },
10537
    {
10538
        0x1907, "OpGroupLogicalOrKHR", 5,
10539
        (struct spirv_parser_instruction_operand[])
10540
        {
10541
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10542
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10543
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10544
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10545
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10546
        }
10547
    },
10548
    {
10549
        0x1908, "OpGroupLogicalXorKHR", 5,
10550
        (struct spirv_parser_instruction_operand[])
10551
        {
10552
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10553
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10554
            {SPIRV_PARSER_OPERAND_TYPE_ID_SCOPE},
10555
            {SPIRV_PARSER_OPERAND_TYPE_GROUP_OPERATION},
10556
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10557
        }
10558
    },
10559
    {
10560
        0x191a, "OpRoundFToTF32INTEL", 3,
10561
        (struct spirv_parser_instruction_operand[])
10562
        {
10563
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10564
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10565
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10566
        }
10567
    },
10568
    {
10569
        0x191c, "OpMaskedGatherINTEL", 6,
10570
        (struct spirv_parser_instruction_operand[])
10571
        {
10572
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT_TYPE},
10573
            {SPIRV_PARSER_OPERAND_TYPE_ID_RESULT},
10574
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10575
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10576
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10577
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10578
        }
10579
    },
10580
    {
10581
        0x191d, "OpMaskedScatterINTEL", 4,
10582
        (struct spirv_parser_instruction_operand[])
10583
        {
10584
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10585
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10586
            {SPIRV_PARSER_OPERAND_TYPE_LITERAL_INTEGER},
10587
            {SPIRV_PARSER_OPERAND_TYPE_ID_REF},
10588
        }
10589
    },
10590
};
10591

10592
Product

Resources

Company
