From 593d80c80ec3b81aa055fa76ea8c97e11488cf00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Leclercq?= Date: Sat, 13 Mar 2021 15:59:41 +0100 Subject: [PATCH] SpirV grammar parser: Add result id operand and version info --- build/scripts/actions/spirv.lua | 29 +- include/Nazara/Shader/SpirvData.hpp | 11 + src/Nazara/Shader/SpirvData.cpp | 916 +++++++++++++++++++++++----- 3 files changed, 800 insertions(+), 156 deletions(-) diff --git a/build/scripts/actions/spirv.lua b/build/scripts/actions/spirv.lua index 6843e548a..432acc0d0 100644 --- a/build/scripts/actions/spirv.lua +++ b/build/scripts/actions/spirv.lua @@ -15,6 +15,8 @@ ACTION.Function = function() print("Done") + io.write("Parsing... ") + local result, err = json.decode(content) assert(result, err) @@ -34,16 +36,26 @@ ACTION.Function = function() local operandByInstruction = {} for _, instruction in pairs(instructions) do if (instruction.operands) then + local resultId local firstId = #operands local operandCount = #instruction.operands - for _, operand in pairs(instruction.operands) do + for i, operand in pairs(instruction.operands) do table.insert(operands, operand) + + if (operand.kind == "IdResult") then + assert(not resultId, "unexpected operand with two IdResult") + resultId = i - 1 + end end - operandByInstruction[instruction.opcode] = { firstId = firstId, count = operandCount } + operandByInstruction[instruction.opcode] = { firstId = firstId, count = operandCount, resultId = resultId } end end + print("Done") + + io.write("Generating... ") + local headerFile = io.open("../include/Nazara/Shader/SpirvData.hpp", "w+") assert(headerFile, "failed to open Spir-V header") @@ -65,6 +77,15 @@ ACTION.Function = function() namespace Nz { +]]) + + headerFile:write([[ + constexpr UInt32 SpirvMagicNumber = ]] .. result.magic_number .. [[; + constexpr UInt32 SpirvMajorVersion = ]] .. result.major_version .. [[; + constexpr UInt32 SpirvMinorVersion = ]] .. result.minor_version .. [[; + constexpr UInt32 SpirvRevision = ]] .. result.revision .. [[; + constexpr UInt32 SpirvVersion = (SpirvMajorVersion << 16) | (SpirvMinorVersion << 8); + ]]) -- SpirV operations @@ -155,6 +176,7 @@ headerFile:write([[ SpirvOp op; const char* name; const Operand* operands; + const Operand* resultOperand; std::size_t minOperandCount; }; @@ -210,12 +232,14 @@ namespace Nz for _, instruction in pairs(instructions) do local opByInstruction = operandByInstruction[instruction.opcode] + local resultId = opByInstruction and opByInstruction.resultId or nil sourceFile:write([[ { SpirvOp::]] .. instruction.opname .. [[, R"(]] .. instruction.opname .. [[)", ]] .. (opByInstruction and "&s_operands[" .. opByInstruction.firstId .. "]" or "nullptr") .. [[, + ]] .. (resultId and "&s_operands[" .. opByInstruction.firstId + resultId .. "]" or "nullptr") .. [[, ]] .. (opByInstruction and opByInstruction.count or "0") .. [[, }, ]]) @@ -243,4 +267,5 @@ namespace Nz } ]]) + print("Done") end diff --git a/include/Nazara/Shader/SpirvData.hpp b/include/Nazara/Shader/SpirvData.hpp index 3295d2edb..aaacc4631 100644 --- a/include/Nazara/Shader/SpirvData.hpp +++ b/include/Nazara/Shader/SpirvData.hpp @@ -15,6 +15,12 @@ namespace Nz { + constexpr UInt32 SpirvMagicNumber = 0x07230203; + constexpr UInt32 SpirvMajorVersion = 1; + constexpr UInt32 SpirvMinorVersion = 5; + constexpr UInt32 SpirvRevision = 4; + constexpr UInt32 SpirvVersion = (SpirvMajorVersion << 16) | (SpirvMinorVersion << 8); + enum class SpirvOp { OpNop = 0, @@ -442,6 +448,8 @@ namespace Nz OpAsmCallINTEL = 5611, OpAtomicFMinEXT = 5614, OpAtomicFMaxEXT = 5615, + OpAssumeTrueKHR = 5630, + OpExpectKHR = 5631, OpDecorateString = 5632, OpDecorateStringGOOGLE = 5632, OpMemberDecorateString = 5633, @@ -1178,6 +1186,7 @@ namespace Nz { Export = 0, Import = 1, + LinkOnceODR = 2, }; enum class SpirvAccessQualifier @@ -1636,6 +1645,7 @@ namespace Nz AtomicFloat16MinMaxEXT = 5616, VectorComputeINTEL = 5617, VectorAnyINTEL = 5619, + ExpectAssumeKHR = 5629, SubgroupAvcMotionEstimationINTEL = 5696, SubgroupAvcMotionEstimationIntraINTEL = 5697, SubgroupAvcMotionEstimationChromaINTEL = 5698, @@ -1691,6 +1701,7 @@ namespace Nz SpirvOp op; const char* name; const Operand* operands; + const Operand* resultOperand; std::size_t minOperandCount; }; diff --git a/src/Nazara/Shader/SpirvData.cpp b/src/Nazara/Shader/SpirvData.cpp index 5bb2f2794..c0c333eeb 100644 --- a/src/Nazara/Shader/SpirvData.cpp +++ b/src/Nazara/Shader/SpirvData.cpp @@ -11,7 +11,7 @@ namespace Nz { - static constexpr std::array s_operands = { + static constexpr std::array s_operands = { { { SpirvOperandKind::IdResultType, @@ -5779,7 +5779,7 @@ namespace Nz }, { SpirvOperandKind::IdScope, - R"('Execution')" + R"('Scope')" }, { SpirvOperandKind::IdResultType, @@ -6509,6 +6509,26 @@ namespace Nz SpirvOperandKind::IdRef, R"('Value')" }, + { + SpirvOperandKind::IdRef, + R"('Condition')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Value')" + }, + { + SpirvOperandKind::IdRef, + R"('ExpectedValue')" + }, { SpirvOperandKind::IdRef, R"('Target')" @@ -8746,3450 +8766,4038 @@ namespace Nz } }; - static std::array s_instructions = { + static std::array s_instructions = { { { SpirvOp::OpNop, R"(OpNop)", nullptr, + nullptr, 0, }, { SpirvOp::OpUndef, R"(OpUndef)", &s_operands[0], + &s_operands[1], 2, }, { SpirvOp::OpSourceContinued, R"(OpSourceContinued)", &s_operands[2], + nullptr, 1, }, { SpirvOp::OpSource, R"(OpSource)", &s_operands[3], + nullptr, 4, }, { SpirvOp::OpSourceExtension, R"(OpSourceExtension)", &s_operands[7], + nullptr, 1, }, { SpirvOp::OpName, R"(OpName)", &s_operands[8], + nullptr, 2, }, { SpirvOp::OpMemberName, R"(OpMemberName)", &s_operands[10], + nullptr, 3, }, { SpirvOp::OpString, R"(OpString)", &s_operands[13], + &s_operands[13], 2, }, { SpirvOp::OpLine, R"(OpLine)", &s_operands[15], + nullptr, 3, }, { SpirvOp::OpExtension, R"(OpExtension)", &s_operands[18], + nullptr, 1, }, { SpirvOp::OpExtInstImport, R"(OpExtInstImport)", &s_operands[19], + &s_operands[19], 2, }, { SpirvOp::OpExtInst, R"(OpExtInst)", &s_operands[21], + &s_operands[22], 5, }, { SpirvOp::OpMemoryModel, R"(OpMemoryModel)", &s_operands[26], + nullptr, 2, }, { SpirvOp::OpEntryPoint, R"(OpEntryPoint)", &s_operands[28], + nullptr, 4, }, { SpirvOp::OpExecutionMode, R"(OpExecutionMode)", &s_operands[32], + nullptr, 2, }, { SpirvOp::OpCapability, R"(OpCapability)", &s_operands[34], + nullptr, 1, }, { SpirvOp::OpTypeVoid, R"(OpTypeVoid)", &s_operands[35], + &s_operands[35], 1, }, { SpirvOp::OpTypeBool, R"(OpTypeBool)", &s_operands[36], + &s_operands[36], 1, }, { SpirvOp::OpTypeInt, R"(OpTypeInt)", &s_operands[37], + &s_operands[37], 3, }, { SpirvOp::OpTypeFloat, R"(OpTypeFloat)", &s_operands[40], + &s_operands[40], 2, }, { SpirvOp::OpTypeVector, R"(OpTypeVector)", &s_operands[42], + &s_operands[42], 3, }, { SpirvOp::OpTypeMatrix, R"(OpTypeMatrix)", &s_operands[45], + &s_operands[45], 3, }, { SpirvOp::OpTypeImage, R"(OpTypeImage)", &s_operands[48], + &s_operands[48], 9, }, { SpirvOp::OpTypeSampler, R"(OpTypeSampler)", &s_operands[57], + &s_operands[57], 1, }, { SpirvOp::OpTypeSampledImage, R"(OpTypeSampledImage)", &s_operands[58], + &s_operands[58], 2, }, { SpirvOp::OpTypeArray, R"(OpTypeArray)", &s_operands[60], + &s_operands[60], 3, }, { SpirvOp::OpTypeRuntimeArray, R"(OpTypeRuntimeArray)", &s_operands[63], + &s_operands[63], 2, }, { SpirvOp::OpTypeStruct, R"(OpTypeStruct)", &s_operands[65], + &s_operands[65], 2, }, { SpirvOp::OpTypeOpaque, R"(OpTypeOpaque)", &s_operands[67], + &s_operands[67], 2, }, { SpirvOp::OpTypePointer, R"(OpTypePointer)", &s_operands[69], + &s_operands[69], 3, }, { SpirvOp::OpTypeFunction, R"(OpTypeFunction)", &s_operands[72], + &s_operands[72], 3, }, { SpirvOp::OpTypeEvent, R"(OpTypeEvent)", &s_operands[75], + &s_operands[75], 1, }, { SpirvOp::OpTypeDeviceEvent, R"(OpTypeDeviceEvent)", &s_operands[76], + &s_operands[76], 1, }, { SpirvOp::OpTypeReserveId, R"(OpTypeReserveId)", &s_operands[77], + &s_operands[77], 1, }, { SpirvOp::OpTypeQueue, R"(OpTypeQueue)", &s_operands[78], + &s_operands[78], 1, }, { SpirvOp::OpTypePipe, R"(OpTypePipe)", &s_operands[79], + &s_operands[79], 2, }, { SpirvOp::OpTypeForwardPointer, R"(OpTypeForwardPointer)", &s_operands[81], + nullptr, 2, }, { SpirvOp::OpConstantTrue, R"(OpConstantTrue)", &s_operands[83], + &s_operands[84], 2, }, { SpirvOp::OpConstantFalse, R"(OpConstantFalse)", &s_operands[85], + &s_operands[86], 2, }, { SpirvOp::OpConstant, R"(OpConstant)", &s_operands[87], + &s_operands[88], 3, }, { SpirvOp::OpConstantComposite, R"(OpConstantComposite)", &s_operands[90], + &s_operands[91], 3, }, { SpirvOp::OpConstantSampler, R"(OpConstantSampler)", &s_operands[93], + &s_operands[94], 5, }, { SpirvOp::OpConstantNull, R"(OpConstantNull)", &s_operands[98], + &s_operands[99], 2, }, { SpirvOp::OpSpecConstantTrue, R"(OpSpecConstantTrue)", &s_operands[100], + &s_operands[101], 2, }, { SpirvOp::OpSpecConstantFalse, R"(OpSpecConstantFalse)", &s_operands[102], + &s_operands[103], 2, }, { SpirvOp::OpSpecConstant, R"(OpSpecConstant)", &s_operands[104], + &s_operands[105], 3, }, { SpirvOp::OpSpecConstantComposite, R"(OpSpecConstantComposite)", &s_operands[107], + &s_operands[108], 3, }, { SpirvOp::OpSpecConstantOp, R"(OpSpecConstantOp)", &s_operands[110], + &s_operands[111], 3, }, { SpirvOp::OpFunction, R"(OpFunction)", &s_operands[113], + &s_operands[114], 4, }, { SpirvOp::OpFunctionParameter, R"(OpFunctionParameter)", &s_operands[117], + &s_operands[118], 2, }, { SpirvOp::OpFunctionEnd, R"(OpFunctionEnd)", nullptr, + nullptr, 0, }, { SpirvOp::OpFunctionCall, R"(OpFunctionCall)", &s_operands[119], + &s_operands[120], 4, }, { SpirvOp::OpVariable, R"(OpVariable)", &s_operands[123], + &s_operands[124], 4, }, { SpirvOp::OpImageTexelPointer, R"(OpImageTexelPointer)", &s_operands[127], + &s_operands[128], 5, }, { SpirvOp::OpLoad, R"(OpLoad)", &s_operands[132], + &s_operands[133], 4, }, { SpirvOp::OpStore, R"(OpStore)", &s_operands[136], + nullptr, 3, }, { SpirvOp::OpCopyMemory, R"(OpCopyMemory)", &s_operands[139], + nullptr, 4, }, { SpirvOp::OpCopyMemorySized, R"(OpCopyMemorySized)", &s_operands[143], + nullptr, 5, }, { SpirvOp::OpAccessChain, R"(OpAccessChain)", &s_operands[148], + &s_operands[149], 4, }, { SpirvOp::OpInBoundsAccessChain, R"(OpInBoundsAccessChain)", &s_operands[152], + &s_operands[153], 4, }, { SpirvOp::OpPtrAccessChain, R"(OpPtrAccessChain)", &s_operands[156], + &s_operands[157], 5, }, { SpirvOp::OpArrayLength, R"(OpArrayLength)", &s_operands[161], + &s_operands[162], 4, }, { SpirvOp::OpGenericPtrMemSemantics, R"(OpGenericPtrMemSemantics)", &s_operands[165], + &s_operands[166], 3, }, { SpirvOp::OpInBoundsPtrAccessChain, R"(OpInBoundsPtrAccessChain)", &s_operands[168], + &s_operands[169], 5, }, { SpirvOp::OpDecorate, R"(OpDecorate)", &s_operands[173], + nullptr, 2, }, { SpirvOp::OpMemberDecorate, R"(OpMemberDecorate)", &s_operands[175], + nullptr, 3, }, { SpirvOp::OpDecorationGroup, R"(OpDecorationGroup)", &s_operands[178], + &s_operands[178], 1, }, { SpirvOp::OpGroupDecorate, R"(OpGroupDecorate)", &s_operands[179], + nullptr, 2, }, { SpirvOp::OpGroupMemberDecorate, R"(OpGroupMemberDecorate)", &s_operands[181], + nullptr, 2, }, { SpirvOp::OpVectorExtractDynamic, R"(OpVectorExtractDynamic)", &s_operands[183], + &s_operands[184], 4, }, { SpirvOp::OpVectorInsertDynamic, R"(OpVectorInsertDynamic)", &s_operands[187], + &s_operands[188], 5, }, { SpirvOp::OpVectorShuffle, R"(OpVectorShuffle)", &s_operands[192], + &s_operands[193], 5, }, { SpirvOp::OpCompositeConstruct, R"(OpCompositeConstruct)", &s_operands[197], + &s_operands[198], 3, }, { SpirvOp::OpCompositeExtract, R"(OpCompositeExtract)", &s_operands[200], + &s_operands[201], 4, }, { SpirvOp::OpCompositeInsert, R"(OpCompositeInsert)", &s_operands[204], + &s_operands[205], 5, }, { SpirvOp::OpCopyObject, R"(OpCopyObject)", &s_operands[209], + &s_operands[210], 3, }, { SpirvOp::OpTranspose, R"(OpTranspose)", &s_operands[212], + &s_operands[213], 3, }, { SpirvOp::OpSampledImage, R"(OpSampledImage)", &s_operands[215], + &s_operands[216], 4, }, { SpirvOp::OpImageSampleImplicitLod, R"(OpImageSampleImplicitLod)", &s_operands[219], + &s_operands[220], 5, }, { SpirvOp::OpImageSampleExplicitLod, R"(OpImageSampleExplicitLod)", &s_operands[224], + &s_operands[225], 5, }, { SpirvOp::OpImageSampleDrefImplicitLod, R"(OpImageSampleDrefImplicitLod)", &s_operands[229], + &s_operands[230], 6, }, { SpirvOp::OpImageSampleDrefExplicitLod, R"(OpImageSampleDrefExplicitLod)", &s_operands[235], + &s_operands[236], 6, }, { SpirvOp::OpImageSampleProjImplicitLod, R"(OpImageSampleProjImplicitLod)", &s_operands[241], + &s_operands[242], 5, }, { SpirvOp::OpImageSampleProjExplicitLod, R"(OpImageSampleProjExplicitLod)", &s_operands[246], + &s_operands[247], 5, }, { SpirvOp::OpImageSampleProjDrefImplicitLod, R"(OpImageSampleProjDrefImplicitLod)", &s_operands[251], + &s_operands[252], 6, }, { SpirvOp::OpImageSampleProjDrefExplicitLod, R"(OpImageSampleProjDrefExplicitLod)", &s_operands[257], + &s_operands[258], 6, }, { SpirvOp::OpImageFetch, R"(OpImageFetch)", &s_operands[263], + &s_operands[264], 5, }, { SpirvOp::OpImageGather, R"(OpImageGather)", &s_operands[268], + &s_operands[269], 6, }, { SpirvOp::OpImageDrefGather, R"(OpImageDrefGather)", &s_operands[274], + &s_operands[275], 6, }, { SpirvOp::OpImageRead, R"(OpImageRead)", &s_operands[280], + &s_operands[281], 5, }, { SpirvOp::OpImageWrite, R"(OpImageWrite)", &s_operands[285], + nullptr, 4, }, { SpirvOp::OpImage, R"(OpImage)", &s_operands[289], + &s_operands[290], 3, }, { SpirvOp::OpImageQueryFormat, R"(OpImageQueryFormat)", &s_operands[292], + &s_operands[293], 3, }, { SpirvOp::OpImageQueryOrder, R"(OpImageQueryOrder)", &s_operands[295], + &s_operands[296], 3, }, { SpirvOp::OpImageQuerySizeLod, R"(OpImageQuerySizeLod)", &s_operands[298], + &s_operands[299], 4, }, { SpirvOp::OpImageQuerySize, R"(OpImageQuerySize)", &s_operands[302], + &s_operands[303], 3, }, { SpirvOp::OpImageQueryLod, R"(OpImageQueryLod)", &s_operands[305], + &s_operands[306], 4, }, { SpirvOp::OpImageQueryLevels, R"(OpImageQueryLevels)", &s_operands[309], + &s_operands[310], 3, }, { SpirvOp::OpImageQuerySamples, R"(OpImageQuerySamples)", &s_operands[312], + &s_operands[313], 3, }, { SpirvOp::OpConvertFToU, R"(OpConvertFToU)", &s_operands[315], + &s_operands[316], 3, }, { SpirvOp::OpConvertFToS, R"(OpConvertFToS)", &s_operands[318], + &s_operands[319], 3, }, { SpirvOp::OpConvertSToF, R"(OpConvertSToF)", &s_operands[321], + &s_operands[322], 3, }, { SpirvOp::OpConvertUToF, R"(OpConvertUToF)", &s_operands[324], + &s_operands[325], 3, }, { SpirvOp::OpUConvert, R"(OpUConvert)", &s_operands[327], + &s_operands[328], 3, }, { SpirvOp::OpSConvert, R"(OpSConvert)", &s_operands[330], + &s_operands[331], 3, }, { SpirvOp::OpFConvert, R"(OpFConvert)", &s_operands[333], + &s_operands[334], 3, }, { SpirvOp::OpQuantizeToF16, R"(OpQuantizeToF16)", &s_operands[336], + &s_operands[337], 3, }, { SpirvOp::OpConvertPtrToU, R"(OpConvertPtrToU)", &s_operands[339], + &s_operands[340], 3, }, { SpirvOp::OpSatConvertSToU, R"(OpSatConvertSToU)", &s_operands[342], + &s_operands[343], 3, }, { SpirvOp::OpSatConvertUToS, R"(OpSatConvertUToS)", &s_operands[345], + &s_operands[346], 3, }, { SpirvOp::OpConvertUToPtr, R"(OpConvertUToPtr)", &s_operands[348], + &s_operands[349], 3, }, { SpirvOp::OpPtrCastToGeneric, R"(OpPtrCastToGeneric)", &s_operands[351], + &s_operands[352], 3, }, { SpirvOp::OpGenericCastToPtr, R"(OpGenericCastToPtr)", &s_operands[354], + &s_operands[355], 3, }, { SpirvOp::OpGenericCastToPtrExplicit, R"(OpGenericCastToPtrExplicit)", &s_operands[357], + &s_operands[358], 4, }, { SpirvOp::OpBitcast, R"(OpBitcast)", &s_operands[361], + &s_operands[362], 3, }, { SpirvOp::OpSNegate, R"(OpSNegate)", &s_operands[364], + &s_operands[365], 3, }, { SpirvOp::OpFNegate, R"(OpFNegate)", &s_operands[367], + &s_operands[368], 3, }, { SpirvOp::OpIAdd, R"(OpIAdd)", &s_operands[370], + &s_operands[371], 4, }, { SpirvOp::OpFAdd, R"(OpFAdd)", &s_operands[374], + &s_operands[375], 4, }, { SpirvOp::OpISub, R"(OpISub)", &s_operands[378], + &s_operands[379], 4, }, { SpirvOp::OpFSub, R"(OpFSub)", &s_operands[382], + &s_operands[383], 4, }, { SpirvOp::OpIMul, R"(OpIMul)", &s_operands[386], + &s_operands[387], 4, }, { SpirvOp::OpFMul, R"(OpFMul)", &s_operands[390], + &s_operands[391], 4, }, { SpirvOp::OpUDiv, R"(OpUDiv)", &s_operands[394], + &s_operands[395], 4, }, { SpirvOp::OpSDiv, R"(OpSDiv)", &s_operands[398], + &s_operands[399], 4, }, { SpirvOp::OpFDiv, R"(OpFDiv)", &s_operands[402], + &s_operands[403], 4, }, { SpirvOp::OpUMod, R"(OpUMod)", &s_operands[406], + &s_operands[407], 4, }, { SpirvOp::OpSRem, R"(OpSRem)", &s_operands[410], + &s_operands[411], 4, }, { SpirvOp::OpSMod, R"(OpSMod)", &s_operands[414], + &s_operands[415], 4, }, { SpirvOp::OpFRem, R"(OpFRem)", &s_operands[418], + &s_operands[419], 4, }, { SpirvOp::OpFMod, R"(OpFMod)", &s_operands[422], + &s_operands[423], 4, }, { SpirvOp::OpVectorTimesScalar, R"(OpVectorTimesScalar)", &s_operands[426], + &s_operands[427], 4, }, { SpirvOp::OpMatrixTimesScalar, R"(OpMatrixTimesScalar)", &s_operands[430], + &s_operands[431], 4, }, { SpirvOp::OpVectorTimesMatrix, R"(OpVectorTimesMatrix)", &s_operands[434], + &s_operands[435], 4, }, { SpirvOp::OpMatrixTimesVector, R"(OpMatrixTimesVector)", &s_operands[438], + &s_operands[439], 4, }, { SpirvOp::OpMatrixTimesMatrix, R"(OpMatrixTimesMatrix)", &s_operands[442], + &s_operands[443], 4, }, { SpirvOp::OpOuterProduct, R"(OpOuterProduct)", &s_operands[446], + &s_operands[447], 4, }, { SpirvOp::OpDot, R"(OpDot)", &s_operands[450], + &s_operands[451], 4, }, { SpirvOp::OpIAddCarry, R"(OpIAddCarry)", &s_operands[454], + &s_operands[455], 4, }, { SpirvOp::OpISubBorrow, R"(OpISubBorrow)", &s_operands[458], + &s_operands[459], 4, }, { SpirvOp::OpUMulExtended, R"(OpUMulExtended)", &s_operands[462], + &s_operands[463], 4, }, { SpirvOp::OpSMulExtended, R"(OpSMulExtended)", &s_operands[466], + &s_operands[467], 4, }, { SpirvOp::OpAny, R"(OpAny)", &s_operands[470], + &s_operands[471], 3, }, { SpirvOp::OpAll, R"(OpAll)", &s_operands[473], + &s_operands[474], 3, }, { SpirvOp::OpIsNan, R"(OpIsNan)", &s_operands[476], + &s_operands[477], 3, }, { SpirvOp::OpIsInf, R"(OpIsInf)", &s_operands[479], + &s_operands[480], 3, }, { SpirvOp::OpIsFinite, R"(OpIsFinite)", &s_operands[482], + &s_operands[483], 3, }, { SpirvOp::OpIsNormal, R"(OpIsNormal)", &s_operands[485], + &s_operands[486], 3, }, { SpirvOp::OpSignBitSet, R"(OpSignBitSet)", &s_operands[488], + &s_operands[489], 3, }, { SpirvOp::OpLessOrGreater, R"(OpLessOrGreater)", &s_operands[491], + &s_operands[492], 4, }, { SpirvOp::OpOrdered, R"(OpOrdered)", &s_operands[495], + &s_operands[496], 4, }, { SpirvOp::OpUnordered, R"(OpUnordered)", &s_operands[499], + &s_operands[500], 4, }, { SpirvOp::OpLogicalEqual, R"(OpLogicalEqual)", &s_operands[503], + &s_operands[504], 4, }, { SpirvOp::OpLogicalNotEqual, R"(OpLogicalNotEqual)", &s_operands[507], + &s_operands[508], 4, }, { SpirvOp::OpLogicalOr, R"(OpLogicalOr)", &s_operands[511], + &s_operands[512], 4, }, { SpirvOp::OpLogicalAnd, R"(OpLogicalAnd)", &s_operands[515], + &s_operands[516], 4, }, { SpirvOp::OpLogicalNot, R"(OpLogicalNot)", &s_operands[519], + &s_operands[520], 3, }, { SpirvOp::OpSelect, R"(OpSelect)", &s_operands[522], + &s_operands[523], 5, }, { SpirvOp::OpIEqual, R"(OpIEqual)", &s_operands[527], + &s_operands[528], 4, }, { SpirvOp::OpINotEqual, R"(OpINotEqual)", &s_operands[531], + &s_operands[532], 4, }, { SpirvOp::OpUGreaterThan, R"(OpUGreaterThan)", &s_operands[535], + &s_operands[536], 4, }, { SpirvOp::OpSGreaterThan, R"(OpSGreaterThan)", &s_operands[539], + &s_operands[540], 4, }, { SpirvOp::OpUGreaterThanEqual, R"(OpUGreaterThanEqual)", &s_operands[543], + &s_operands[544], 4, }, { SpirvOp::OpSGreaterThanEqual, R"(OpSGreaterThanEqual)", &s_operands[547], + &s_operands[548], 4, }, { SpirvOp::OpULessThan, R"(OpULessThan)", &s_operands[551], + &s_operands[552], 4, }, { SpirvOp::OpSLessThan, R"(OpSLessThan)", &s_operands[555], + &s_operands[556], 4, }, { SpirvOp::OpULessThanEqual, R"(OpULessThanEqual)", &s_operands[559], + &s_operands[560], 4, }, { SpirvOp::OpSLessThanEqual, R"(OpSLessThanEqual)", &s_operands[563], + &s_operands[564], 4, }, { SpirvOp::OpFOrdEqual, R"(OpFOrdEqual)", &s_operands[567], + &s_operands[568], 4, }, { SpirvOp::OpFUnordEqual, R"(OpFUnordEqual)", &s_operands[571], + &s_operands[572], 4, }, { SpirvOp::OpFOrdNotEqual, R"(OpFOrdNotEqual)", &s_operands[575], + &s_operands[576], 4, }, { SpirvOp::OpFUnordNotEqual, R"(OpFUnordNotEqual)", &s_operands[579], + &s_operands[580], 4, }, { SpirvOp::OpFOrdLessThan, R"(OpFOrdLessThan)", &s_operands[583], + &s_operands[584], 4, }, { SpirvOp::OpFUnordLessThan, R"(OpFUnordLessThan)", &s_operands[587], + &s_operands[588], 4, }, { SpirvOp::OpFOrdGreaterThan, R"(OpFOrdGreaterThan)", &s_operands[591], + &s_operands[592], 4, }, { SpirvOp::OpFUnordGreaterThan, R"(OpFUnordGreaterThan)", &s_operands[595], + &s_operands[596], 4, }, { SpirvOp::OpFOrdLessThanEqual, R"(OpFOrdLessThanEqual)", &s_operands[599], + &s_operands[600], 4, }, { SpirvOp::OpFUnordLessThanEqual, R"(OpFUnordLessThanEqual)", &s_operands[603], + &s_operands[604], 4, }, { SpirvOp::OpFOrdGreaterThanEqual, R"(OpFOrdGreaterThanEqual)", &s_operands[607], + &s_operands[608], 4, }, { SpirvOp::OpFUnordGreaterThanEqual, R"(OpFUnordGreaterThanEqual)", &s_operands[611], + &s_operands[612], 4, }, { SpirvOp::OpShiftRightLogical, R"(OpShiftRightLogical)", &s_operands[615], + &s_operands[616], 4, }, { SpirvOp::OpShiftRightArithmetic, R"(OpShiftRightArithmetic)", &s_operands[619], + &s_operands[620], 4, }, { SpirvOp::OpShiftLeftLogical, R"(OpShiftLeftLogical)", &s_operands[623], + &s_operands[624], 4, }, { SpirvOp::OpBitwiseOr, R"(OpBitwiseOr)", &s_operands[627], + &s_operands[628], 4, }, { SpirvOp::OpBitwiseXor, R"(OpBitwiseXor)", &s_operands[631], + &s_operands[632], 4, }, { SpirvOp::OpBitwiseAnd, R"(OpBitwiseAnd)", &s_operands[635], + &s_operands[636], 4, }, { SpirvOp::OpNot, R"(OpNot)", &s_operands[639], + &s_operands[640], 3, }, { SpirvOp::OpBitFieldInsert, R"(OpBitFieldInsert)", &s_operands[642], + &s_operands[643], 6, }, { SpirvOp::OpBitFieldSExtract, R"(OpBitFieldSExtract)", &s_operands[648], + &s_operands[649], 5, }, { SpirvOp::OpBitFieldUExtract, R"(OpBitFieldUExtract)", &s_operands[653], + &s_operands[654], 5, }, { SpirvOp::OpBitReverse, R"(OpBitReverse)", &s_operands[658], + &s_operands[659], 3, }, { SpirvOp::OpBitCount, R"(OpBitCount)", &s_operands[661], + &s_operands[662], 3, }, { SpirvOp::OpDPdx, R"(OpDPdx)", &s_operands[664], + &s_operands[665], 3, }, { SpirvOp::OpDPdy, R"(OpDPdy)", &s_operands[667], + &s_operands[668], 3, }, { SpirvOp::OpFwidth, R"(OpFwidth)", &s_operands[670], + &s_operands[671], 3, }, { SpirvOp::OpDPdxFine, R"(OpDPdxFine)", &s_operands[673], + &s_operands[674], 3, }, { SpirvOp::OpDPdyFine, R"(OpDPdyFine)", &s_operands[676], + &s_operands[677], 3, }, { SpirvOp::OpFwidthFine, R"(OpFwidthFine)", &s_operands[679], + &s_operands[680], 3, }, { SpirvOp::OpDPdxCoarse, R"(OpDPdxCoarse)", &s_operands[682], + &s_operands[683], 3, }, { SpirvOp::OpDPdyCoarse, R"(OpDPdyCoarse)", &s_operands[685], + &s_operands[686], 3, }, { SpirvOp::OpFwidthCoarse, R"(OpFwidthCoarse)", &s_operands[688], + &s_operands[689], 3, }, { SpirvOp::OpEmitVertex, R"(OpEmitVertex)", nullptr, + nullptr, 0, }, { SpirvOp::OpEndPrimitive, R"(OpEndPrimitive)", nullptr, + nullptr, 0, }, { SpirvOp::OpEmitStreamVertex, R"(OpEmitStreamVertex)", &s_operands[691], + nullptr, 1, }, { SpirvOp::OpEndStreamPrimitive, R"(OpEndStreamPrimitive)", &s_operands[692], + nullptr, 1, }, { SpirvOp::OpControlBarrier, R"(OpControlBarrier)", &s_operands[693], + nullptr, 3, }, { SpirvOp::OpMemoryBarrier, R"(OpMemoryBarrier)", &s_operands[696], + nullptr, 2, }, { SpirvOp::OpAtomicLoad, R"(OpAtomicLoad)", &s_operands[698], + &s_operands[699], 5, }, { SpirvOp::OpAtomicStore, R"(OpAtomicStore)", &s_operands[703], + nullptr, 4, }, { SpirvOp::OpAtomicExchange, R"(OpAtomicExchange)", &s_operands[707], + &s_operands[708], 6, }, { SpirvOp::OpAtomicCompareExchange, R"(OpAtomicCompareExchange)", &s_operands[713], + &s_operands[714], 8, }, { SpirvOp::OpAtomicCompareExchangeWeak, R"(OpAtomicCompareExchangeWeak)", &s_operands[721], + &s_operands[722], 8, }, { SpirvOp::OpAtomicIIncrement, R"(OpAtomicIIncrement)", &s_operands[729], + &s_operands[730], 5, }, { SpirvOp::OpAtomicIDecrement, R"(OpAtomicIDecrement)", &s_operands[734], + &s_operands[735], 5, }, { SpirvOp::OpAtomicIAdd, R"(OpAtomicIAdd)", &s_operands[739], + &s_operands[740], 6, }, { SpirvOp::OpAtomicISub, R"(OpAtomicISub)", &s_operands[745], + &s_operands[746], 6, }, { SpirvOp::OpAtomicSMin, R"(OpAtomicSMin)", &s_operands[751], + &s_operands[752], 6, }, { SpirvOp::OpAtomicUMin, R"(OpAtomicUMin)", &s_operands[757], + &s_operands[758], 6, }, { SpirvOp::OpAtomicSMax, R"(OpAtomicSMax)", &s_operands[763], + &s_operands[764], 6, }, { SpirvOp::OpAtomicUMax, R"(OpAtomicUMax)", &s_operands[769], + &s_operands[770], 6, }, { SpirvOp::OpAtomicAnd, R"(OpAtomicAnd)", &s_operands[775], + &s_operands[776], 6, }, { SpirvOp::OpAtomicOr, R"(OpAtomicOr)", &s_operands[781], + &s_operands[782], 6, }, { SpirvOp::OpAtomicXor, R"(OpAtomicXor)", &s_operands[787], + &s_operands[788], 6, }, { SpirvOp::OpPhi, R"(OpPhi)", &s_operands[793], + &s_operands[794], 3, }, { SpirvOp::OpLoopMerge, R"(OpLoopMerge)", &s_operands[796], + nullptr, 3, }, { SpirvOp::OpSelectionMerge, R"(OpSelectionMerge)", &s_operands[799], + nullptr, 2, }, { SpirvOp::OpLabel, R"(OpLabel)", &s_operands[801], + &s_operands[801], 1, }, { SpirvOp::OpBranch, R"(OpBranch)", &s_operands[802], + nullptr, 1, }, { SpirvOp::OpBranchConditional, R"(OpBranchConditional)", &s_operands[803], + nullptr, 4, }, { SpirvOp::OpSwitch, R"(OpSwitch)", &s_operands[807], + nullptr, 3, }, { SpirvOp::OpKill, R"(OpKill)", nullptr, + nullptr, 0, }, { SpirvOp::OpReturn, R"(OpReturn)", nullptr, + nullptr, 0, }, { SpirvOp::OpReturnValue, R"(OpReturnValue)", &s_operands[810], + nullptr, 1, }, { SpirvOp::OpUnreachable, R"(OpUnreachable)", nullptr, + nullptr, 0, }, { SpirvOp::OpLifetimeStart, R"(OpLifetimeStart)", &s_operands[811], + nullptr, 2, }, { SpirvOp::OpLifetimeStop, R"(OpLifetimeStop)", &s_operands[813], + nullptr, 2, }, { SpirvOp::OpGroupAsyncCopy, R"(OpGroupAsyncCopy)", &s_operands[815], + &s_operands[816], 8, }, { SpirvOp::OpGroupWaitEvents, R"(OpGroupWaitEvents)", &s_operands[823], + nullptr, 3, }, { SpirvOp::OpGroupAll, R"(OpGroupAll)", &s_operands[826], + &s_operands[827], 4, }, { SpirvOp::OpGroupAny, R"(OpGroupAny)", &s_operands[830], + &s_operands[831], 4, }, { SpirvOp::OpGroupBroadcast, R"(OpGroupBroadcast)", &s_operands[834], + &s_operands[835], 5, }, { SpirvOp::OpGroupIAdd, R"(OpGroupIAdd)", &s_operands[839], + &s_operands[840], 5, }, { SpirvOp::OpGroupFAdd, R"(OpGroupFAdd)", &s_operands[844], + &s_operands[845], 5, }, { SpirvOp::OpGroupFMin, R"(OpGroupFMin)", &s_operands[849], + &s_operands[850], 5, }, { SpirvOp::OpGroupUMin, R"(OpGroupUMin)", &s_operands[854], + &s_operands[855], 5, }, { SpirvOp::OpGroupSMin, R"(OpGroupSMin)", &s_operands[859], + &s_operands[860], 5, }, { SpirvOp::OpGroupFMax, R"(OpGroupFMax)", &s_operands[864], + &s_operands[865], 5, }, { SpirvOp::OpGroupUMax, R"(OpGroupUMax)", &s_operands[869], + &s_operands[870], 5, }, { SpirvOp::OpGroupSMax, R"(OpGroupSMax)", &s_operands[874], + &s_operands[875], 5, }, { SpirvOp::OpReadPipe, R"(OpReadPipe)", &s_operands[879], + &s_operands[880], 6, }, { SpirvOp::OpWritePipe, R"(OpWritePipe)", &s_operands[885], + &s_operands[886], 6, }, { SpirvOp::OpReservedReadPipe, R"(OpReservedReadPipe)", &s_operands[891], + &s_operands[892], 8, }, { SpirvOp::OpReservedWritePipe, R"(OpReservedWritePipe)", &s_operands[899], + &s_operands[900], 8, }, { SpirvOp::OpReserveReadPipePackets, R"(OpReserveReadPipePackets)", &s_operands[907], + &s_operands[908], 6, }, { SpirvOp::OpReserveWritePipePackets, R"(OpReserveWritePipePackets)", &s_operands[913], + &s_operands[914], 6, }, { SpirvOp::OpCommitReadPipe, R"(OpCommitReadPipe)", &s_operands[919], + nullptr, 4, }, { SpirvOp::OpCommitWritePipe, R"(OpCommitWritePipe)", &s_operands[923], + nullptr, 4, }, { SpirvOp::OpIsValidReserveId, R"(OpIsValidReserveId)", &s_operands[927], + &s_operands[928], 3, }, { SpirvOp::OpGetNumPipePackets, R"(OpGetNumPipePackets)", &s_operands[930], + &s_operands[931], 5, }, { SpirvOp::OpGetMaxPipePackets, R"(OpGetMaxPipePackets)", &s_operands[935], + &s_operands[936], 5, }, { SpirvOp::OpGroupReserveReadPipePackets, R"(OpGroupReserveReadPipePackets)", &s_operands[940], + &s_operands[941], 7, }, { SpirvOp::OpGroupReserveWritePipePackets, R"(OpGroupReserveWritePipePackets)", &s_operands[947], + &s_operands[948], 7, }, { SpirvOp::OpGroupCommitReadPipe, R"(OpGroupCommitReadPipe)", &s_operands[954], + nullptr, 5, }, { SpirvOp::OpGroupCommitWritePipe, R"(OpGroupCommitWritePipe)", &s_operands[959], + nullptr, 5, }, { SpirvOp::OpEnqueueMarker, R"(OpEnqueueMarker)", &s_operands[964], + &s_operands[965], 6, }, { SpirvOp::OpEnqueueKernel, R"(OpEnqueueKernel)", &s_operands[970], + &s_operands[971], 13, }, { SpirvOp::OpGetKernelNDrangeSubGroupCount, R"(OpGetKernelNDrangeSubGroupCount)", &s_operands[983], + &s_operands[984], 7, }, { SpirvOp::OpGetKernelNDrangeMaxSubGroupSize, R"(OpGetKernelNDrangeMaxSubGroupSize)", &s_operands[990], + &s_operands[991], 7, }, { SpirvOp::OpGetKernelWorkGroupSize, R"(OpGetKernelWorkGroupSize)", &s_operands[997], + &s_operands[998], 6, }, { SpirvOp::OpGetKernelPreferredWorkGroupSizeMultiple, R"(OpGetKernelPreferredWorkGroupSizeMultiple)", &s_operands[1003], + &s_operands[1004], 6, }, { SpirvOp::OpRetainEvent, R"(OpRetainEvent)", &s_operands[1009], + nullptr, 1, }, { SpirvOp::OpReleaseEvent, R"(OpReleaseEvent)", &s_operands[1010], + nullptr, 1, }, { SpirvOp::OpCreateUserEvent, R"(OpCreateUserEvent)", &s_operands[1011], + &s_operands[1012], 2, }, { SpirvOp::OpIsValidEvent, R"(OpIsValidEvent)", &s_operands[1013], + &s_operands[1014], 3, }, { SpirvOp::OpSetUserEventStatus, R"(OpSetUserEventStatus)", &s_operands[1016], + nullptr, 2, }, { SpirvOp::OpCaptureEventProfilingInfo, R"(OpCaptureEventProfilingInfo)", &s_operands[1018], + nullptr, 3, }, { SpirvOp::OpGetDefaultQueue, R"(OpGetDefaultQueue)", &s_operands[1021], + &s_operands[1022], 2, }, { SpirvOp::OpBuildNDRange, R"(OpBuildNDRange)", &s_operands[1023], + &s_operands[1024], 5, }, { SpirvOp::OpImageSparseSampleImplicitLod, R"(OpImageSparseSampleImplicitLod)", &s_operands[1028], + &s_operands[1029], 5, }, { SpirvOp::OpImageSparseSampleExplicitLod, R"(OpImageSparseSampleExplicitLod)", &s_operands[1033], + &s_operands[1034], 5, }, { SpirvOp::OpImageSparseSampleDrefImplicitLod, R"(OpImageSparseSampleDrefImplicitLod)", &s_operands[1038], + &s_operands[1039], 6, }, { SpirvOp::OpImageSparseSampleDrefExplicitLod, R"(OpImageSparseSampleDrefExplicitLod)", &s_operands[1044], + &s_operands[1045], 6, }, { SpirvOp::OpImageSparseSampleProjImplicitLod, R"(OpImageSparseSampleProjImplicitLod)", &s_operands[1050], + &s_operands[1051], 5, }, { SpirvOp::OpImageSparseSampleProjExplicitLod, R"(OpImageSparseSampleProjExplicitLod)", &s_operands[1055], + &s_operands[1056], 5, }, { SpirvOp::OpImageSparseSampleProjDrefImplicitLod, R"(OpImageSparseSampleProjDrefImplicitLod)", &s_operands[1060], + &s_operands[1061], 6, }, { SpirvOp::OpImageSparseSampleProjDrefExplicitLod, R"(OpImageSparseSampleProjDrefExplicitLod)", &s_operands[1066], + &s_operands[1067], 6, }, { SpirvOp::OpImageSparseFetch, R"(OpImageSparseFetch)", &s_operands[1072], + &s_operands[1073], 5, }, { SpirvOp::OpImageSparseGather, R"(OpImageSparseGather)", &s_operands[1077], + &s_operands[1078], 6, }, { SpirvOp::OpImageSparseDrefGather, R"(OpImageSparseDrefGather)", &s_operands[1083], + &s_operands[1084], 6, }, { SpirvOp::OpImageSparseTexelsResident, R"(OpImageSparseTexelsResident)", &s_operands[1089], + &s_operands[1090], 3, }, { SpirvOp::OpNoLine, R"(OpNoLine)", nullptr, + nullptr, 0, }, { SpirvOp::OpAtomicFlagTestAndSet, R"(OpAtomicFlagTestAndSet)", &s_operands[1092], + &s_operands[1093], 5, }, { SpirvOp::OpAtomicFlagClear, R"(OpAtomicFlagClear)", &s_operands[1097], + nullptr, 3, }, { SpirvOp::OpImageSparseRead, R"(OpImageSparseRead)", &s_operands[1100], + &s_operands[1101], 5, }, { SpirvOp::OpSizeOf, R"(OpSizeOf)", &s_operands[1105], + &s_operands[1106], 3, }, { SpirvOp::OpTypePipeStorage, R"(OpTypePipeStorage)", &s_operands[1108], + &s_operands[1108], 1, }, { SpirvOp::OpConstantPipeStorage, R"(OpConstantPipeStorage)", &s_operands[1109], + &s_operands[1110], 5, }, { SpirvOp::OpCreatePipeFromPipeStorage, R"(OpCreatePipeFromPipeStorage)", &s_operands[1114], + &s_operands[1115], 3, }, { SpirvOp::OpGetKernelLocalSizeForSubgroupCount, R"(OpGetKernelLocalSizeForSubgroupCount)", &s_operands[1117], + &s_operands[1118], 7, }, { SpirvOp::OpGetKernelMaxNumSubgroups, R"(OpGetKernelMaxNumSubgroups)", &s_operands[1124], + &s_operands[1125], 6, }, { SpirvOp::OpTypeNamedBarrier, R"(OpTypeNamedBarrier)", &s_operands[1130], + &s_operands[1130], 1, }, { SpirvOp::OpNamedBarrierInitialize, R"(OpNamedBarrierInitialize)", &s_operands[1131], + &s_operands[1132], 3, }, { SpirvOp::OpMemoryNamedBarrier, R"(OpMemoryNamedBarrier)", &s_operands[1134], + nullptr, 3, }, { SpirvOp::OpModuleProcessed, R"(OpModuleProcessed)", &s_operands[1137], + nullptr, 1, }, { SpirvOp::OpExecutionModeId, R"(OpExecutionModeId)", &s_operands[1138], + nullptr, 2, }, { SpirvOp::OpDecorateId, R"(OpDecorateId)", &s_operands[1140], + nullptr, 2, }, { SpirvOp::OpGroupNonUniformElect, R"(OpGroupNonUniformElect)", &s_operands[1142], + &s_operands[1143], 3, }, { SpirvOp::OpGroupNonUniformAll, R"(OpGroupNonUniformAll)", &s_operands[1145], + &s_operands[1146], 4, }, { SpirvOp::OpGroupNonUniformAny, R"(OpGroupNonUniformAny)", &s_operands[1149], + &s_operands[1150], 4, }, { SpirvOp::OpGroupNonUniformAllEqual, R"(OpGroupNonUniformAllEqual)", &s_operands[1153], + &s_operands[1154], 4, }, { SpirvOp::OpGroupNonUniformBroadcast, R"(OpGroupNonUniformBroadcast)", &s_operands[1157], + &s_operands[1158], 5, }, { SpirvOp::OpGroupNonUniformBroadcastFirst, R"(OpGroupNonUniformBroadcastFirst)", &s_operands[1162], + &s_operands[1163], 4, }, { SpirvOp::OpGroupNonUniformBallot, R"(OpGroupNonUniformBallot)", &s_operands[1166], + &s_operands[1167], 4, }, { SpirvOp::OpGroupNonUniformInverseBallot, R"(OpGroupNonUniformInverseBallot)", &s_operands[1170], + &s_operands[1171], 4, }, { SpirvOp::OpGroupNonUniformBallotBitExtract, R"(OpGroupNonUniformBallotBitExtract)", &s_operands[1174], + &s_operands[1175], 5, }, { SpirvOp::OpGroupNonUniformBallotBitCount, R"(OpGroupNonUniformBallotBitCount)", &s_operands[1179], + &s_operands[1180], 5, }, { SpirvOp::OpGroupNonUniformBallotFindLSB, R"(OpGroupNonUniformBallotFindLSB)", &s_operands[1184], + &s_operands[1185], 4, }, { SpirvOp::OpGroupNonUniformBallotFindMSB, R"(OpGroupNonUniformBallotFindMSB)", &s_operands[1188], + &s_operands[1189], 4, }, { SpirvOp::OpGroupNonUniformShuffle, R"(OpGroupNonUniformShuffle)", &s_operands[1192], + &s_operands[1193], 5, }, { SpirvOp::OpGroupNonUniformShuffleXor, R"(OpGroupNonUniformShuffleXor)", &s_operands[1197], + &s_operands[1198], 5, }, { SpirvOp::OpGroupNonUniformShuffleUp, R"(OpGroupNonUniformShuffleUp)", &s_operands[1202], + &s_operands[1203], 5, }, { SpirvOp::OpGroupNonUniformShuffleDown, R"(OpGroupNonUniformShuffleDown)", &s_operands[1207], + &s_operands[1208], 5, }, { SpirvOp::OpGroupNonUniformIAdd, R"(OpGroupNonUniformIAdd)", &s_operands[1212], + &s_operands[1213], 6, }, { SpirvOp::OpGroupNonUniformFAdd, R"(OpGroupNonUniformFAdd)", &s_operands[1218], + &s_operands[1219], 6, }, { SpirvOp::OpGroupNonUniformIMul, R"(OpGroupNonUniformIMul)", &s_operands[1224], + &s_operands[1225], 6, }, { SpirvOp::OpGroupNonUniformFMul, R"(OpGroupNonUniformFMul)", &s_operands[1230], + &s_operands[1231], 6, }, { SpirvOp::OpGroupNonUniformSMin, R"(OpGroupNonUniformSMin)", &s_operands[1236], + &s_operands[1237], 6, }, { SpirvOp::OpGroupNonUniformUMin, R"(OpGroupNonUniformUMin)", &s_operands[1242], + &s_operands[1243], 6, }, { SpirvOp::OpGroupNonUniformFMin, R"(OpGroupNonUniformFMin)", &s_operands[1248], + &s_operands[1249], 6, }, { SpirvOp::OpGroupNonUniformSMax, R"(OpGroupNonUniformSMax)", &s_operands[1254], + &s_operands[1255], 6, }, { SpirvOp::OpGroupNonUniformUMax, R"(OpGroupNonUniformUMax)", &s_operands[1260], + &s_operands[1261], 6, }, { SpirvOp::OpGroupNonUniformFMax, R"(OpGroupNonUniformFMax)", &s_operands[1266], + &s_operands[1267], 6, }, { SpirvOp::OpGroupNonUniformBitwiseAnd, R"(OpGroupNonUniformBitwiseAnd)", &s_operands[1272], + &s_operands[1273], 6, }, { SpirvOp::OpGroupNonUniformBitwiseOr, R"(OpGroupNonUniformBitwiseOr)", &s_operands[1278], + &s_operands[1279], 6, }, { SpirvOp::OpGroupNonUniformBitwiseXor, R"(OpGroupNonUniformBitwiseXor)", &s_operands[1284], + &s_operands[1285], 6, }, { SpirvOp::OpGroupNonUniformLogicalAnd, R"(OpGroupNonUniformLogicalAnd)", &s_operands[1290], + &s_operands[1291], 6, }, { SpirvOp::OpGroupNonUniformLogicalOr, R"(OpGroupNonUniformLogicalOr)", &s_operands[1296], + &s_operands[1297], 6, }, { SpirvOp::OpGroupNonUniformLogicalXor, R"(OpGroupNonUniformLogicalXor)", &s_operands[1302], + &s_operands[1303], 6, }, { SpirvOp::OpGroupNonUniformQuadBroadcast, R"(OpGroupNonUniformQuadBroadcast)", &s_operands[1308], + &s_operands[1309], 5, }, { SpirvOp::OpGroupNonUniformQuadSwap, R"(OpGroupNonUniformQuadSwap)", &s_operands[1313], + &s_operands[1314], 5, }, { SpirvOp::OpCopyLogical, R"(OpCopyLogical)", &s_operands[1318], + &s_operands[1319], 3, }, { SpirvOp::OpPtrEqual, R"(OpPtrEqual)", &s_operands[1321], + &s_operands[1322], 4, }, { SpirvOp::OpPtrNotEqual, R"(OpPtrNotEqual)", &s_operands[1325], + &s_operands[1326], 4, }, { SpirvOp::OpPtrDiff, R"(OpPtrDiff)", &s_operands[1329], + &s_operands[1330], 4, }, { SpirvOp::OpTerminateInvocation, R"(OpTerminateInvocation)", nullptr, + nullptr, 0, }, { SpirvOp::OpSubgroupBallotKHR, R"(OpSubgroupBallotKHR)", &s_operands[1333], + &s_operands[1334], 3, }, { SpirvOp::OpSubgroupFirstInvocationKHR, R"(OpSubgroupFirstInvocationKHR)", &s_operands[1336], + &s_operands[1337], 3, }, { SpirvOp::OpSubgroupAllKHR, R"(OpSubgroupAllKHR)", &s_operands[1339], + &s_operands[1340], 3, }, { SpirvOp::OpSubgroupAnyKHR, R"(OpSubgroupAnyKHR)", &s_operands[1342], + &s_operands[1343], 3, }, { SpirvOp::OpSubgroupAllEqualKHR, R"(OpSubgroupAllEqualKHR)", &s_operands[1345], + &s_operands[1346], 3, }, { SpirvOp::OpSubgroupReadInvocationKHR, R"(OpSubgroupReadInvocationKHR)", &s_operands[1348], + &s_operands[1349], 4, }, { SpirvOp::OpTraceRayKHR, R"(OpTraceRayKHR)", &s_operands[1352], + nullptr, 11, }, { SpirvOp::OpExecuteCallableKHR, R"(OpExecuteCallableKHR)", &s_operands[1363], + nullptr, 2, }, { SpirvOp::OpConvertUToAccelerationStructureKHR, R"(OpConvertUToAccelerationStructureKHR)", &s_operands[1365], + &s_operands[1366], 3, }, { SpirvOp::OpIgnoreIntersectionKHR, R"(OpIgnoreIntersectionKHR)", nullptr, + nullptr, 0, }, { SpirvOp::OpTerminateRayKHR, R"(OpTerminateRayKHR)", nullptr, + nullptr, 0, }, { SpirvOp::OpTypeRayQueryKHR, R"(OpTypeRayQueryKHR)", &s_operands[1368], + &s_operands[1368], 1, }, { SpirvOp::OpRayQueryInitializeKHR, R"(OpRayQueryInitializeKHR)", &s_operands[1369], + nullptr, 8, }, { SpirvOp::OpRayQueryTerminateKHR, R"(OpRayQueryTerminateKHR)", &s_operands[1377], + nullptr, 1, }, { SpirvOp::OpRayQueryGenerateIntersectionKHR, R"(OpRayQueryGenerateIntersectionKHR)", &s_operands[1378], + nullptr, 2, }, { SpirvOp::OpRayQueryConfirmIntersectionKHR, R"(OpRayQueryConfirmIntersectionKHR)", &s_operands[1380], + nullptr, 1, }, { SpirvOp::OpRayQueryProceedKHR, R"(OpRayQueryProceedKHR)", &s_operands[1381], + &s_operands[1382], 3, }, { SpirvOp::OpRayQueryGetIntersectionTypeKHR, R"(OpRayQueryGetIntersectionTypeKHR)", &s_operands[1384], + &s_operands[1385], 4, }, { SpirvOp::OpGroupIAddNonUniformAMD, R"(OpGroupIAddNonUniformAMD)", &s_operands[1388], + &s_operands[1389], 5, }, { SpirvOp::OpGroupFAddNonUniformAMD, R"(OpGroupFAddNonUniformAMD)", &s_operands[1393], + &s_operands[1394], 5, }, { SpirvOp::OpGroupFMinNonUniformAMD, R"(OpGroupFMinNonUniformAMD)", &s_operands[1398], + &s_operands[1399], 5, }, { SpirvOp::OpGroupUMinNonUniformAMD, R"(OpGroupUMinNonUniformAMD)", &s_operands[1403], + &s_operands[1404], 5, }, { SpirvOp::OpGroupSMinNonUniformAMD, R"(OpGroupSMinNonUniformAMD)", &s_operands[1408], + &s_operands[1409], 5, }, { SpirvOp::OpGroupFMaxNonUniformAMD, R"(OpGroupFMaxNonUniformAMD)", &s_operands[1413], + &s_operands[1414], 5, }, { SpirvOp::OpGroupUMaxNonUniformAMD, R"(OpGroupUMaxNonUniformAMD)", &s_operands[1418], + &s_operands[1419], 5, }, { SpirvOp::OpGroupSMaxNonUniformAMD, R"(OpGroupSMaxNonUniformAMD)", &s_operands[1423], + &s_operands[1424], 5, }, { SpirvOp::OpFragmentMaskFetchAMD, R"(OpFragmentMaskFetchAMD)", &s_operands[1428], + &s_operands[1429], 4, }, { SpirvOp::OpFragmentFetchAMD, R"(OpFragmentFetchAMD)", &s_operands[1432], + &s_operands[1433], 5, }, { SpirvOp::OpReadClockKHR, R"(OpReadClockKHR)", &s_operands[1437], + &s_operands[1438], 3, }, { SpirvOp::OpImageSampleFootprintNV, R"(OpImageSampleFootprintNV)", &s_operands[1440], + &s_operands[1441], 7, }, { SpirvOp::OpGroupNonUniformPartitionNV, R"(OpGroupNonUniformPartitionNV)", &s_operands[1447], + &s_operands[1448], 3, }, { SpirvOp::OpWritePackedPrimitiveIndices4x8NV, R"(OpWritePackedPrimitiveIndices4x8NV)", &s_operands[1450], + nullptr, 2, }, { SpirvOp::OpReportIntersectionKHR, R"(OpReportIntersectionKHR)", &s_operands[1452], + &s_operands[1453], 4, }, { SpirvOp::OpIgnoreIntersectionNV, R"(OpIgnoreIntersectionNV)", nullptr, + nullptr, 0, }, { SpirvOp::OpTerminateRayNV, R"(OpTerminateRayNV)", nullptr, + nullptr, 0, }, { SpirvOp::OpTraceNV, R"(OpTraceNV)", &s_operands[1456], + nullptr, 11, }, { SpirvOp::OpTypeAccelerationStructureKHR, R"(OpTypeAccelerationStructureKHR)", &s_operands[1467], + &s_operands[1467], 1, }, { SpirvOp::OpExecuteCallableNV, R"(OpExecuteCallableNV)", &s_operands[1468], + nullptr, 2, }, { SpirvOp::OpTypeCooperativeMatrixNV, R"(OpTypeCooperativeMatrixNV)", &s_operands[1470], + &s_operands[1470], 5, }, { SpirvOp::OpCooperativeMatrixLoadNV, R"(OpCooperativeMatrixLoadNV)", &s_operands[1475], + &s_operands[1476], 6, }, { SpirvOp::OpCooperativeMatrixStoreNV, R"(OpCooperativeMatrixStoreNV)", &s_operands[1481], + nullptr, 5, }, { SpirvOp::OpCooperativeMatrixMulAddNV, R"(OpCooperativeMatrixMulAddNV)", &s_operands[1486], + &s_operands[1487], 5, }, { SpirvOp::OpCooperativeMatrixLengthNV, R"(OpCooperativeMatrixLengthNV)", &s_operands[1491], + &s_operands[1492], 3, }, { SpirvOp::OpBeginInvocationInterlockEXT, R"(OpBeginInvocationInterlockEXT)", nullptr, + nullptr, 0, }, { SpirvOp::OpEndInvocationInterlockEXT, R"(OpEndInvocationInterlockEXT)", nullptr, + nullptr, 0, }, { SpirvOp::OpDemoteToHelperInvocationEXT, R"(OpDemoteToHelperInvocationEXT)", nullptr, + nullptr, 0, }, { SpirvOp::OpIsHelperInvocationEXT, R"(OpIsHelperInvocationEXT)", &s_operands[1494], + &s_operands[1495], 2, }, { SpirvOp::OpSubgroupShuffleINTEL, R"(OpSubgroupShuffleINTEL)", &s_operands[1496], + &s_operands[1497], 4, }, { SpirvOp::OpSubgroupShuffleDownINTEL, R"(OpSubgroupShuffleDownINTEL)", &s_operands[1500], + &s_operands[1501], 5, }, { SpirvOp::OpSubgroupShuffleUpINTEL, R"(OpSubgroupShuffleUpINTEL)", &s_operands[1505], + &s_operands[1506], 5, }, { SpirvOp::OpSubgroupShuffleXorINTEL, R"(OpSubgroupShuffleXorINTEL)", &s_operands[1510], + &s_operands[1511], 4, }, { SpirvOp::OpSubgroupBlockReadINTEL, R"(OpSubgroupBlockReadINTEL)", &s_operands[1514], + &s_operands[1515], 3, }, { SpirvOp::OpSubgroupBlockWriteINTEL, R"(OpSubgroupBlockWriteINTEL)", &s_operands[1517], + nullptr, 2, }, { SpirvOp::OpSubgroupImageBlockReadINTEL, R"(OpSubgroupImageBlockReadINTEL)", &s_operands[1519], + &s_operands[1520], 4, }, { SpirvOp::OpSubgroupImageBlockWriteINTEL, R"(OpSubgroupImageBlockWriteINTEL)", &s_operands[1523], + nullptr, 3, }, { SpirvOp::OpSubgroupImageMediaBlockReadINTEL, R"(OpSubgroupImageMediaBlockReadINTEL)", &s_operands[1526], + &s_operands[1527], 6, }, { SpirvOp::OpSubgroupImageMediaBlockWriteINTEL, R"(OpSubgroupImageMediaBlockWriteINTEL)", &s_operands[1532], + nullptr, 5, }, { SpirvOp::OpUCountLeadingZerosINTEL, R"(OpUCountLeadingZerosINTEL)", &s_operands[1537], + &s_operands[1538], 3, }, { SpirvOp::OpUCountTrailingZerosINTEL, R"(OpUCountTrailingZerosINTEL)", &s_operands[1540], + &s_operands[1541], 3, }, { SpirvOp::OpAbsISubINTEL, R"(OpAbsISubINTEL)", &s_operands[1543], + &s_operands[1544], 4, }, { SpirvOp::OpAbsUSubINTEL, R"(OpAbsUSubINTEL)", &s_operands[1547], + &s_operands[1548], 4, }, { SpirvOp::OpIAddSatINTEL, R"(OpIAddSatINTEL)", &s_operands[1551], + &s_operands[1552], 4, }, { SpirvOp::OpUAddSatINTEL, R"(OpUAddSatINTEL)", &s_operands[1555], + &s_operands[1556], 4, }, { SpirvOp::OpIAverageINTEL, R"(OpIAverageINTEL)", &s_operands[1559], + &s_operands[1560], 4, }, { SpirvOp::OpUAverageINTEL, R"(OpUAverageINTEL)", &s_operands[1563], + &s_operands[1564], 4, }, { SpirvOp::OpIAverageRoundedINTEL, R"(OpIAverageRoundedINTEL)", &s_operands[1567], + &s_operands[1568], 4, }, { SpirvOp::OpUAverageRoundedINTEL, R"(OpUAverageRoundedINTEL)", &s_operands[1571], + &s_operands[1572], 4, }, { SpirvOp::OpISubSatINTEL, R"(OpISubSatINTEL)", &s_operands[1575], + &s_operands[1576], 4, }, { SpirvOp::OpUSubSatINTEL, R"(OpUSubSatINTEL)", &s_operands[1579], + &s_operands[1580], 4, }, { SpirvOp::OpIMul32x16INTEL, R"(OpIMul32x16INTEL)", &s_operands[1583], + &s_operands[1584], 4, }, { SpirvOp::OpUMul32x16INTEL, R"(OpUMul32x16INTEL)", &s_operands[1587], + &s_operands[1588], 4, }, { SpirvOp::OpConstFunctionPointerINTEL, R"(OpConstFunctionPointerINTEL)", &s_operands[1591], + &s_operands[1592], 3, }, { SpirvOp::OpFunctionPointerCallINTEL, R"(OpFunctionPointerCallINTEL)", &s_operands[1594], + &s_operands[1595], 3, }, { SpirvOp::OpAsmTargetINTEL, R"(OpAsmTargetINTEL)", &s_operands[1597], + &s_operands[1598], 3, }, { SpirvOp::OpAsmINTEL, R"(OpAsmINTEL)", &s_operands[1600], + &s_operands[1601], 6, }, { SpirvOp::OpAsmCallINTEL, R"(OpAsmCallINTEL)", &s_operands[1606], + &s_operands[1607], 4, }, { SpirvOp::OpAtomicFMinEXT, R"(OpAtomicFMinEXT)", &s_operands[1610], + &s_operands[1611], 6, }, { SpirvOp::OpAtomicFMaxEXT, R"(OpAtomicFMaxEXT)", &s_operands[1616], + &s_operands[1617], 6, }, + { + SpirvOp::OpAssumeTrueKHR, + R"(OpAssumeTrueKHR)", + &s_operands[1622], + nullptr, + 1, + }, + { + SpirvOp::OpExpectKHR, + R"(OpExpectKHR)", + &s_operands[1623], + &s_operands[1624], + 4, + }, { SpirvOp::OpDecorateStringGOOGLE, R"(OpDecorateStringGOOGLE)", - &s_operands[1622], + &s_operands[1627], + nullptr, 2, }, { SpirvOp::OpMemberDecorateStringGOOGLE, R"(OpMemberDecorateStringGOOGLE)", - &s_operands[1624], + &s_operands[1629], + nullptr, 3, }, { SpirvOp::OpVmeImageINTEL, R"(OpVmeImageINTEL)", - &s_operands[1627], + &s_operands[1632], + &s_operands[1633], 4, }, { SpirvOp::OpTypeVmeImageINTEL, R"(OpTypeVmeImageINTEL)", - &s_operands[1631], + &s_operands[1636], + &s_operands[1636], 2, }, { SpirvOp::OpTypeAvcImePayloadINTEL, R"(OpTypeAvcImePayloadINTEL)", - &s_operands[1633], + &s_operands[1638], + &s_operands[1638], 1, }, { SpirvOp::OpTypeAvcRefPayloadINTEL, R"(OpTypeAvcRefPayloadINTEL)", - &s_operands[1634], + &s_operands[1639], + &s_operands[1639], 1, }, { SpirvOp::OpTypeAvcSicPayloadINTEL, R"(OpTypeAvcSicPayloadINTEL)", - &s_operands[1635], + &s_operands[1640], + &s_operands[1640], 1, }, { SpirvOp::OpTypeAvcMcePayloadINTEL, R"(OpTypeAvcMcePayloadINTEL)", - &s_operands[1636], + &s_operands[1641], + &s_operands[1641], 1, }, { SpirvOp::OpTypeAvcMceResultINTEL, R"(OpTypeAvcMceResultINTEL)", - &s_operands[1637], + &s_operands[1642], + &s_operands[1642], 1, }, { SpirvOp::OpTypeAvcImeResultINTEL, R"(OpTypeAvcImeResultINTEL)", - &s_operands[1638], + &s_operands[1643], + &s_operands[1643], 1, }, { SpirvOp::OpTypeAvcImeResultSingleReferenceStreamoutINTEL, R"(OpTypeAvcImeResultSingleReferenceStreamoutINTEL)", - &s_operands[1639], + &s_operands[1644], + &s_operands[1644], 1, }, { SpirvOp::OpTypeAvcImeResultDualReferenceStreamoutINTEL, R"(OpTypeAvcImeResultDualReferenceStreamoutINTEL)", - &s_operands[1640], + &s_operands[1645], + &s_operands[1645], 1, }, { SpirvOp::OpTypeAvcImeSingleReferenceStreaminINTEL, R"(OpTypeAvcImeSingleReferenceStreaminINTEL)", - &s_operands[1641], + &s_operands[1646], + &s_operands[1646], 1, }, { SpirvOp::OpTypeAvcImeDualReferenceStreaminINTEL, R"(OpTypeAvcImeDualReferenceStreaminINTEL)", - &s_operands[1642], + &s_operands[1647], + &s_operands[1647], 1, }, { SpirvOp::OpTypeAvcRefResultINTEL, R"(OpTypeAvcRefResultINTEL)", - &s_operands[1643], + &s_operands[1648], + &s_operands[1648], 1, }, { SpirvOp::OpTypeAvcSicResultINTEL, R"(OpTypeAvcSicResultINTEL)", - &s_operands[1644], + &s_operands[1649], + &s_operands[1649], 1, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL)", - &s_operands[1645], + &s_operands[1650], + &s_operands[1651], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL, R"(OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL)", - &s_operands[1649], + &s_operands[1654], + &s_operands[1655], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL)", - &s_operands[1653], + &s_operands[1658], + &s_operands[1659], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterShapePenaltyINTEL, R"(OpSubgroupAvcMceSetInterShapePenaltyINTEL)", - &s_operands[1657], + &s_operands[1662], + &s_operands[1663], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL)", - &s_operands[1661], + &s_operands[1666], + &s_operands[1667], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL, R"(OpSubgroupAvcMceSetInterDirectionPenaltyINTEL)", - &s_operands[1665], + &s_operands[1670], + &s_operands[1671], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL)", - &s_operands[1669], + &s_operands[1674], + &s_operands[1675], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL)", - &s_operands[1673], + &s_operands[1678], + &s_operands[1679], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL)", - &s_operands[1677], + &s_operands[1682], + &s_operands[1683], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL)", - &s_operands[1679], + &s_operands[1684], + &s_operands[1685], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL)", - &s_operands[1681], + &s_operands[1686], + &s_operands[1687], 2, }, { SpirvOp::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL, R"(OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL)", - &s_operands[1683], + &s_operands[1688], + &s_operands[1689], 6, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL)", - &s_operands[1689], + &s_operands[1694], + &s_operands[1695], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL)", - &s_operands[1693], + &s_operands[1698], + &s_operands[1699], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL)", - &s_operands[1695], + &s_operands[1700], + &s_operands[1701], 2, }, { SpirvOp::OpSubgroupAvcMceSetAcOnlyHaarINTEL, R"(OpSubgroupAvcMceSetAcOnlyHaarINTEL)", - &s_operands[1697], + &s_operands[1702], + &s_operands[1703], 3, }, { SpirvOp::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL, R"(OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL)", - &s_operands[1700], + &s_operands[1705], + &s_operands[1706], 4, }, { SpirvOp::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL, R"(OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL)", - &s_operands[1704], + &s_operands[1709], + &s_operands[1710], 4, }, { SpirvOp::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL, R"(OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL)", - &s_operands[1708], + &s_operands[1713], + &s_operands[1714], 5, }, { SpirvOp::OpSubgroupAvcMceConvertToImePayloadINTEL, R"(OpSubgroupAvcMceConvertToImePayloadINTEL)", - &s_operands[1713], + &s_operands[1718], + &s_operands[1719], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToImeResultINTEL, R"(OpSubgroupAvcMceConvertToImeResultINTEL)", - &s_operands[1716], + &s_operands[1721], + &s_operands[1722], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToRefPayloadINTEL, R"(OpSubgroupAvcMceConvertToRefPayloadINTEL)", - &s_operands[1719], + &s_operands[1724], + &s_operands[1725], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToRefResultINTEL, R"(OpSubgroupAvcMceConvertToRefResultINTEL)", - &s_operands[1722], + &s_operands[1727], + &s_operands[1728], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToSicPayloadINTEL, R"(OpSubgroupAvcMceConvertToSicPayloadINTEL)", - &s_operands[1725], + &s_operands[1730], + &s_operands[1731], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToSicResultINTEL, R"(OpSubgroupAvcMceConvertToSicResultINTEL)", - &s_operands[1728], + &s_operands[1733], + &s_operands[1734], 3, }, { SpirvOp::OpSubgroupAvcMceGetMotionVectorsINTEL, R"(OpSubgroupAvcMceGetMotionVectorsINTEL)", - &s_operands[1731], + &s_operands[1736], + &s_operands[1737], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterDistortionsINTEL, R"(OpSubgroupAvcMceGetInterDistortionsINTEL)", - &s_operands[1734], + &s_operands[1739], + &s_operands[1740], 3, }, { SpirvOp::OpSubgroupAvcMceGetBestInterDistortionsINTEL, R"(OpSubgroupAvcMceGetBestInterDistortionsINTEL)", - &s_operands[1737], + &s_operands[1742], + &s_operands[1743], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMajorShapeINTEL, R"(OpSubgroupAvcMceGetInterMajorShapeINTEL)", - &s_operands[1740], + &s_operands[1745], + &s_operands[1746], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMinorShapeINTEL, R"(OpSubgroupAvcMceGetInterMinorShapeINTEL)", - &s_operands[1743], + &s_operands[1748], + &s_operands[1749], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterDirectionsINTEL, R"(OpSubgroupAvcMceGetInterDirectionsINTEL)", - &s_operands[1746], + &s_operands[1751], + &s_operands[1752], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMotionVectorCountINTEL, R"(OpSubgroupAvcMceGetInterMotionVectorCountINTEL)", - &s_operands[1749], + &s_operands[1754], + &s_operands[1755], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterReferenceIdsINTEL, R"(OpSubgroupAvcMceGetInterReferenceIdsINTEL)", - &s_operands[1752], + &s_operands[1757], + &s_operands[1758], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL, R"(OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL)", - &s_operands[1755], + &s_operands[1760], + &s_operands[1761], 5, }, { SpirvOp::OpSubgroupAvcImeInitializeINTEL, R"(OpSubgroupAvcImeInitializeINTEL)", - &s_operands[1760], + &s_operands[1765], + &s_operands[1766], 5, }, { SpirvOp::OpSubgroupAvcImeSetSingleReferenceINTEL, R"(OpSubgroupAvcImeSetSingleReferenceINTEL)", - &s_operands[1765], + &s_operands[1770], + &s_operands[1771], 5, }, { SpirvOp::OpSubgroupAvcImeSetDualReferenceINTEL, R"(OpSubgroupAvcImeSetDualReferenceINTEL)", - &s_operands[1770], + &s_operands[1775], + &s_operands[1776], 6, }, { SpirvOp::OpSubgroupAvcImeRefWindowSizeINTEL, R"(OpSubgroupAvcImeRefWindowSizeINTEL)", - &s_operands[1776], + &s_operands[1781], + &s_operands[1782], 4, }, { SpirvOp::OpSubgroupAvcImeAdjustRefOffsetINTEL, R"(OpSubgroupAvcImeAdjustRefOffsetINTEL)", - &s_operands[1780], + &s_operands[1785], + &s_operands[1786], 6, }, { SpirvOp::OpSubgroupAvcImeConvertToMcePayloadINTEL, R"(OpSubgroupAvcImeConvertToMcePayloadINTEL)", - &s_operands[1786], + &s_operands[1791], + &s_operands[1792], 3, }, { SpirvOp::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL, R"(OpSubgroupAvcImeSetMaxMotionVectorCountINTEL)", - &s_operands[1789], + &s_operands[1794], + &s_operands[1795], 4, }, { SpirvOp::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL, R"(OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL)", - &s_operands[1793], + &s_operands[1798], + &s_operands[1799], 3, }, { SpirvOp::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL, R"(OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL)", - &s_operands[1796], + &s_operands[1801], + &s_operands[1802], 4, }, { SpirvOp::OpSubgroupAvcImeSetWeightedSadINTEL, R"(OpSubgroupAvcImeSetWeightedSadINTEL)", - &s_operands[1800], + &s_operands[1805], + &s_operands[1806], 4, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL)", - &s_operands[1804], + &s_operands[1809], + &s_operands[1810], 5, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceINTEL)", - &s_operands[1809], + &s_operands[1814], + &s_operands[1815], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL)", - &s_operands[1815], + &s_operands[1820], + &s_operands[1821], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL)", - &s_operands[1821], + &s_operands[1826], + &s_operands[1827], 7, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL)", - &s_operands[1828], + &s_operands[1833], + &s_operands[1834], 5, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL)", - &s_operands[1833], + &s_operands[1838], + &s_operands[1839], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL)", - &s_operands[1839], + &s_operands[1844], + &s_operands[1845], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL)", - &s_operands[1845], + &s_operands[1850], + &s_operands[1851], 7, }, { SpirvOp::OpSubgroupAvcImeConvertToMceResultINTEL, R"(OpSubgroupAvcImeConvertToMceResultINTEL)", - &s_operands[1852], + &s_operands[1857], + &s_operands[1858], 3, }, { SpirvOp::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL, R"(OpSubgroupAvcImeGetSingleReferenceStreaminINTEL)", - &s_operands[1855], + &s_operands[1860], + &s_operands[1861], 3, }, { SpirvOp::OpSubgroupAvcImeGetDualReferenceStreaminINTEL, R"(OpSubgroupAvcImeGetDualReferenceStreaminINTEL)", - &s_operands[1858], + &s_operands[1863], + &s_operands[1864], 3, }, { SpirvOp::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL, R"(OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL)", - &s_operands[1861], + &s_operands[1866], + &s_operands[1867], 3, }, { SpirvOp::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL, R"(OpSubgroupAvcImeStripDualReferenceStreamoutINTEL)", - &s_operands[1864], + &s_operands[1869], + &s_operands[1870], 3, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL)", - &s_operands[1867], + &s_operands[1872], + &s_operands[1873], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL)", - &s_operands[1871], + &s_operands[1876], + &s_operands[1877], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL)", - &s_operands[1875], + &s_operands[1880], + &s_operands[1881], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL)", - &s_operands[1879], + &s_operands[1884], + &s_operands[1885], 5, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL)", - &s_operands[1884], + &s_operands[1889], + &s_operands[1890], 5, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL)", - &s_operands[1889], + &s_operands[1894], + &s_operands[1895], 5, }, { SpirvOp::OpSubgroupAvcImeGetBorderReachedINTEL, R"(OpSubgroupAvcImeGetBorderReachedINTEL)", - &s_operands[1894], + &s_operands[1899], + &s_operands[1900], 4, }, { SpirvOp::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL, R"(OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL)", - &s_operands[1898], + &s_operands[1903], + &s_operands[1904], 3, }, { SpirvOp::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL, R"(OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL)", - &s_operands[1901], + &s_operands[1906], + &s_operands[1907], 3, }, { SpirvOp::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL, R"(OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL)", - &s_operands[1904], + &s_operands[1909], + &s_operands[1910], 3, }, { SpirvOp::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL, R"(OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL)", - &s_operands[1907], + &s_operands[1912], + &s_operands[1913], 3, }, { SpirvOp::OpSubgroupAvcFmeInitializeINTEL, R"(OpSubgroupAvcFmeInitializeINTEL)", - &s_operands[1910], + &s_operands[1915], + &s_operands[1916], 9, }, { SpirvOp::OpSubgroupAvcBmeInitializeINTEL, R"(OpSubgroupAvcBmeInitializeINTEL)", - &s_operands[1919], + &s_operands[1924], + &s_operands[1925], 10, }, { SpirvOp::OpSubgroupAvcRefConvertToMcePayloadINTEL, R"(OpSubgroupAvcRefConvertToMcePayloadINTEL)", - &s_operands[1929], + &s_operands[1934], + &s_operands[1935], 3, }, { SpirvOp::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL, R"(OpSubgroupAvcRefSetBidirectionalMixDisableINTEL)", - &s_operands[1932], + &s_operands[1937], + &s_operands[1938], 3, }, { SpirvOp::OpSubgroupAvcRefSetBilinearFilterEnableINTEL, R"(OpSubgroupAvcRefSetBilinearFilterEnableINTEL)", - &s_operands[1935], + &s_operands[1940], + &s_operands[1941], 3, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL)", - &s_operands[1938], + &s_operands[1943], + &s_operands[1944], 5, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithDualReferenceINTEL)", - &s_operands[1943], + &s_operands[1948], + &s_operands[1949], 6, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL)", - &s_operands[1949], + &s_operands[1954], + &s_operands[1955], 5, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL, R"(OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL)", - &s_operands[1954], + &s_operands[1959], + &s_operands[1960], 6, }, { SpirvOp::OpSubgroupAvcRefConvertToMceResultINTEL, R"(OpSubgroupAvcRefConvertToMceResultINTEL)", - &s_operands[1960], + &s_operands[1965], + &s_operands[1966], 3, }, { SpirvOp::OpSubgroupAvcSicInitializeINTEL, R"(OpSubgroupAvcSicInitializeINTEL)", - &s_operands[1963], + &s_operands[1968], + &s_operands[1969], 3, }, { SpirvOp::OpSubgroupAvcSicConfigureSkcINTEL, R"(OpSubgroupAvcSicConfigureSkcINTEL)", - &s_operands[1966], + &s_operands[1971], + &s_operands[1972], 8, }, { SpirvOp::OpSubgroupAvcSicConfigureIpeLumaINTEL, R"(OpSubgroupAvcSicConfigureIpeLumaINTEL)", - &s_operands[1974], + &s_operands[1979], + &s_operands[1980], 10, }, { SpirvOp::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL, R"(OpSubgroupAvcSicConfigureIpeLumaChromaINTEL)", - &s_operands[1984], + &s_operands[1989], + &s_operands[1990], 13, }, { SpirvOp::OpSubgroupAvcSicGetMotionVectorMaskINTEL, R"(OpSubgroupAvcSicGetMotionVectorMaskINTEL)", - &s_operands[1997], + &s_operands[2002], + &s_operands[2003], 4, }, { SpirvOp::OpSubgroupAvcSicConvertToMcePayloadINTEL, R"(OpSubgroupAvcSicConvertToMcePayloadINTEL)", - &s_operands[2001], + &s_operands[2006], + &s_operands[2007], 3, }, { SpirvOp::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL, R"(OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL)", - &s_operands[2004], + &s_operands[2009], + &s_operands[2010], 4, }, { SpirvOp::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL, R"(OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL)", - &s_operands[2008], + &s_operands[2013], + &s_operands[2014], 6, }, { SpirvOp::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL, R"(OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL)", - &s_operands[2014], + &s_operands[2019], + &s_operands[2020], 4, }, { SpirvOp::OpSubgroupAvcSicSetBilinearFilterEnableINTEL, R"(OpSubgroupAvcSicSetBilinearFilterEnableINTEL)", - &s_operands[2018], + &s_operands[2023], + &s_operands[2024], 3, }, { SpirvOp::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL, R"(OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL)", - &s_operands[2021], + &s_operands[2026], + &s_operands[2027], 4, }, { SpirvOp::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL, R"(OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL)", - &s_operands[2025], + &s_operands[2030], + &s_operands[2031], 4, }, { SpirvOp::OpSubgroupAvcSicEvaluateIpeINTEL, R"(OpSubgroupAvcSicEvaluateIpeINTEL)", - &s_operands[2029], + &s_operands[2034], + &s_operands[2035], 4, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL)", - &s_operands[2033], + &s_operands[2038], + &s_operands[2039], 5, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithDualReferenceINTEL)", - &s_operands[2038], + &s_operands[2043], + &s_operands[2044], 6, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL)", - &s_operands[2044], + &s_operands[2049], + &s_operands[2050], 5, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL, R"(OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL)", - &s_operands[2049], + &s_operands[2054], + &s_operands[2055], 6, }, { SpirvOp::OpSubgroupAvcSicConvertToMceResultINTEL, R"(OpSubgroupAvcSicConvertToMceResultINTEL)", - &s_operands[2055], + &s_operands[2060], + &s_operands[2061], 3, }, { SpirvOp::OpSubgroupAvcSicGetIpeLumaShapeINTEL, R"(OpSubgroupAvcSicGetIpeLumaShapeINTEL)", - &s_operands[2058], + &s_operands[2063], + &s_operands[2064], 3, }, { SpirvOp::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL, R"(OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL)", - &s_operands[2061], + &s_operands[2066], + &s_operands[2067], 3, }, { SpirvOp::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL, R"(OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL)", - &s_operands[2064], + &s_operands[2069], + &s_operands[2070], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL, R"(OpSubgroupAvcSicGetPackedIpeLumaModesINTEL)", - &s_operands[2067], + &s_operands[2072], + &s_operands[2073], 3, }, { SpirvOp::OpSubgroupAvcSicGetIpeChromaModeINTEL, R"(OpSubgroupAvcSicGetIpeChromaModeINTEL)", - &s_operands[2070], + &s_operands[2075], + &s_operands[2076], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL, R"(OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL)", - &s_operands[2073], + &s_operands[2078], + &s_operands[2079], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL, R"(OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL)", - &s_operands[2076], + &s_operands[2081], + &s_operands[2082], 3, }, { SpirvOp::OpSubgroupAvcSicGetInterRawSadsINTEL, R"(OpSubgroupAvcSicGetInterRawSadsINTEL)", - &s_operands[2079], + &s_operands[2084], + &s_operands[2085], 3, }, { SpirvOp::OpVariableLengthArrayINTEL, R"(OpVariableLengthArrayINTEL)", - &s_operands[2082], + &s_operands[2087], + &s_operands[2088], 3, }, { SpirvOp::OpSaveMemoryINTEL, R"(OpSaveMemoryINTEL)", - &s_operands[2085], + &s_operands[2090], + &s_operands[2091], 2, }, { SpirvOp::OpRestoreMemoryINTEL, R"(OpRestoreMemoryINTEL)", - &s_operands[2087], + &s_operands[2092], + nullptr, 1, }, { SpirvOp::OpLoopControlINTEL, R"(OpLoopControlINTEL)", - &s_operands[2088], + &s_operands[2093], + nullptr, 1, }, { SpirvOp::OpPtrCastToCrossWorkgroupINTEL, R"(OpPtrCastToCrossWorkgroupINTEL)", - &s_operands[2089], + &s_operands[2094], + &s_operands[2095], 3, }, { SpirvOp::OpCrossWorkgroupCastToPtrINTEL, R"(OpCrossWorkgroupCastToPtrINTEL)", - &s_operands[2092], + &s_operands[2097], + &s_operands[2098], 3, }, { SpirvOp::OpReadPipeBlockingINTEL, R"(OpReadPipeBlockingINTEL)", - &s_operands[2095], + &s_operands[2100], + &s_operands[2101], 4, }, { SpirvOp::OpWritePipeBlockingINTEL, R"(OpWritePipeBlockingINTEL)", - &s_operands[2099], + &s_operands[2104], + &s_operands[2105], 4, }, { SpirvOp::OpFPGARegINTEL, R"(OpFPGARegINTEL)", - &s_operands[2103], + &s_operands[2108], + &s_operands[2109], 4, }, { SpirvOp::OpRayQueryGetRayTMinKHR, R"(OpRayQueryGetRayTMinKHR)", - &s_operands[2107], + &s_operands[2112], + &s_operands[2113], 3, }, { SpirvOp::OpRayQueryGetRayFlagsKHR, R"(OpRayQueryGetRayFlagsKHR)", - &s_operands[2110], + &s_operands[2115], + &s_operands[2116], 3, }, { SpirvOp::OpRayQueryGetIntersectionTKHR, R"(OpRayQueryGetIntersectionTKHR)", - &s_operands[2113], + &s_operands[2118], + &s_operands[2119], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceCustomIndexKHR, R"(OpRayQueryGetIntersectionInstanceCustomIndexKHR)", - &s_operands[2117], + &s_operands[2122], + &s_operands[2123], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceIdKHR, R"(OpRayQueryGetIntersectionInstanceIdKHR)", - &s_operands[2121], + &s_operands[2126], + &s_operands[2127], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR, R"(OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)", - &s_operands[2125], + &s_operands[2130], + &s_operands[2131], 4, }, { SpirvOp::OpRayQueryGetIntersectionGeometryIndexKHR, R"(OpRayQueryGetIntersectionGeometryIndexKHR)", - &s_operands[2129], + &s_operands[2134], + &s_operands[2135], 4, }, { SpirvOp::OpRayQueryGetIntersectionPrimitiveIndexKHR, R"(OpRayQueryGetIntersectionPrimitiveIndexKHR)", - &s_operands[2133], + &s_operands[2138], + &s_operands[2139], 4, }, { SpirvOp::OpRayQueryGetIntersectionBarycentricsKHR, R"(OpRayQueryGetIntersectionBarycentricsKHR)", - &s_operands[2137], + &s_operands[2142], + &s_operands[2143], 4, }, { SpirvOp::OpRayQueryGetIntersectionFrontFaceKHR, R"(OpRayQueryGetIntersectionFrontFaceKHR)", - &s_operands[2141], + &s_operands[2146], + &s_operands[2147], 4, }, { SpirvOp::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR, R"(OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)", - &s_operands[2145], + &s_operands[2150], + &s_operands[2151], 3, }, { SpirvOp::OpRayQueryGetIntersectionObjectRayDirectionKHR, R"(OpRayQueryGetIntersectionObjectRayDirectionKHR)", - &s_operands[2148], + &s_operands[2153], + &s_operands[2154], 4, }, { SpirvOp::OpRayQueryGetIntersectionObjectRayOriginKHR, R"(OpRayQueryGetIntersectionObjectRayOriginKHR)", - &s_operands[2152], + &s_operands[2157], + &s_operands[2158], 4, }, { SpirvOp::OpRayQueryGetWorldRayDirectionKHR, R"(OpRayQueryGetWorldRayDirectionKHR)", - &s_operands[2156], + &s_operands[2161], + &s_operands[2162], 3, }, { SpirvOp::OpRayQueryGetWorldRayOriginKHR, R"(OpRayQueryGetWorldRayOriginKHR)", - &s_operands[2159], + &s_operands[2164], + &s_operands[2165], 3, }, { SpirvOp::OpRayQueryGetIntersectionObjectToWorldKHR, R"(OpRayQueryGetIntersectionObjectToWorldKHR)", - &s_operands[2162], + &s_operands[2167], + &s_operands[2168], 4, }, { SpirvOp::OpRayQueryGetIntersectionWorldToObjectKHR, R"(OpRayQueryGetIntersectionWorldToObjectKHR)", - &s_operands[2166], + &s_operands[2171], + &s_operands[2172], 4, }, { SpirvOp::OpAtomicFAddEXT, R"(OpAtomicFAddEXT)", - &s_operands[2170], + &s_operands[2175], + &s_operands[2176], 6, }, { SpirvOp::OpTypeBufferSurfaceINTEL, R"(OpTypeBufferSurfaceINTEL)", - &s_operands[2176], + &s_operands[2181], + &s_operands[2181], 1, }, { SpirvOp::OpTypeStructContinuedINTEL, R"(OpTypeStructContinuedINTEL)", - &s_operands[2177], + &s_operands[2182], + nullptr, 1, }, { SpirvOp::OpConstantCompositeContinuedINTEL, R"(OpConstantCompositeContinuedINTEL)", - &s_operands[2178], + &s_operands[2183], + nullptr, 1, }, { SpirvOp::OpSpecConstantCompositeContinuedINTEL, R"(OpSpecConstantCompositeContinuedINTEL)", - &s_operands[2179], + &s_operands[2184], + nullptr, 1, }, }