Merge remote-tracking branch 'LocalGitHub/master'
diff --git a/README.md b/README.md
index 9d5efb5..504447e 100644
--- a/README.md
+++ b/README.md
@@ -1,50 +1,7 @@
-Also see the Khronos landing page for glslang as a reference front end:
+Private version of glslang for Khronos-internal development.
-https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/
-
-The above page includes where to get binaries, and is kept up to date
-regarding the feature level of glslang.
-
-glslang
-=======
-
-[](https://travis-ci.org/KhronosGroup/glslang)
-[](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
-
-An OpenGL and OpenGL ES shader front end and validator.
-
-There are several components:
-
-1. A GLSL/ESSL front-end for reference validation and translation of GLSL/ESSL into an AST.
-
-2. An HLSL front-end for translation of a broad generic HLL into the AST. See [issue 362](https://github.com/KhronosGroup/glslang/issues/362) and [issue 701](https://github.com/KhronosGroup/glslang/issues/701) for current status.
-
-3. A SPIR-V back end for translating the AST to SPIR-V.
-
-4. A standalone wrapper, `glslangValidator`, that can be used as a command-line tool for the above.
-
-How to add a feature protected by a version/extension/stage/profile: See the
-comment in `glslang/MachineIndependent/Versions.cpp`.
-
-Tasks waiting to be done are documented as GitHub issues.
-
-Execution of Standalone Wrapper
--------------------------------
-
-To use the standalone binary form, execute `glslangValidator`, and it will print
-a usage statement. Basic operation is to give it a file containing a shader,
-and it will print out warnings/errors and optionally an AST.
-
-The applied stage-specific rules are based on the file extension:
-* `.vert` for a vertex shader
-* `.tesc` for a tessellation control shader
-* `.tese` for a tessellation evaluation shader
-* `.geom` for a geometry shader
-* `.frag` for a fragment shader
-* `.comp` for a compute shader
-
-There is also a non-shader extension
-* `.conf` for a configuration file of limits, see usage statement for example
+MRs to add functionality must be accompanied by simple regression tests, which are supplied with the gtests framework.
+See instructions below.
Building
--------
@@ -54,7 +11,7 @@
* [CMake][cmake]: for generating compilation targets.
* [Python 2.7][python]: for executing SPIRV-Tools scripts. (Optional if not using SPIRV-Tools.)
* [bison][bison]: _optional_, but needed when changing the grammar (glslang.y).
-* [googletest][googletest]: _optional_, but should use if making any changes to glslang.
+* [googletest][googletest]: needed if making any changes to glslang.
### Build steps
@@ -63,9 +20,9 @@
```bash
cd <parent of where you want glslang to be>
# If using SSH
-git clone git@github.com:KhronosGroup/glslang.git
+git clone git@gitlab.khronos.org:GLSL/glslang.git
# Or if using HTTPS
-git clone https://github.com/KhronosGroup/glslang.git
+git clone https://gitlab.khronos.org/GLSL/glslang.git
```
#### 2) Check-Out External Projects
diff --git a/SPIRV/GLSL.ext.AMD.h b/SPIRV/GLSL.ext.AMD.h
index 7e97be3..d4f57ef 100644
--- a/SPIRV/GLSL.ext.AMD.h
+++ b/SPIRV/GLSL.ext.AMD.h
@@ -104,14 +104,7 @@
// SPV_AMD_shader_image_load_store_lod
static const char* const E_SPV_AMD_shader_image_load_store_lod = "SPV_AMD_shader_image_load_store_lod";
-static const Capability CapabilityImageReadWriteLodAMD = static_cast<Capability>(5015);
-
// SPV_AMD_shader_fragment_mask
static const char* const E_SPV_AMD_shader_fragment_mask = "SPV_AMD_shader_fragment_mask";
-static const Capability CapabilityFragmentMaskAMD = static_cast<Capability>(5010);
-
-static const Op OpFragmentMaskFetchAMD = static_cast<Op>(5011);
-static const Op OpFragmentFetchAMD = static_cast<Op>(5012);
-
#endif // #ifndef GLSLextAMD_H
diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
old mode 100755
new mode 100644
index b0e51df..aa29267
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -1,6 +1,7 @@
//
// Copyright (C) 2014-2016 LunarG, Inc.
// Copyright (C) 2015-2016 Google, Inc.
+// Copyright (C) 2017 ARM Limited.
//
// All rights reserved.
//
@@ -174,10 +175,12 @@
spv::Id createUnaryOperation(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand,glslang::TBasicType typeProxy);
spv::Id createUnaryMatrixOperation(spv::Op op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand,glslang::TBasicType typeProxy);
spv::Id createConversion(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id destTypeId, spv::Id operand, glslang::TBasicType typeProxy);
+ spv::Id createConversionOperation(glslang::TOperator op, spv::Id operand, int vectorSize);
spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation, spv::Id typeId, std::vector<spv::Id>& operands);
+ spv::Id createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);
spv::Id getSymbolId(const glslang::TIntermSymbol* node);
@@ -581,6 +584,46 @@
builder.addCapability(spv::CapabilitySubgroupBallotKHR);
return spv::BuiltInSubgroupLtMaskKHR;
+ case glslang::EbvNumSubgroups:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ return spv::BuiltInNumSubgroups;
+
+ case glslang::EbvSubgroupID:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ return spv::BuiltInSubgroupId;
+
+ case glslang::EbvSubgroupSize2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ return spv::BuiltInSubgroupSize;
+
+ case glslang::EbvSubgroupInvocation2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ return spv::BuiltInSubgroupLocalInvocationId;
+
+ case glslang::EbvSubgroupEqMask2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ return spv::BuiltInSubgroupEqMask;
+
+ case glslang::EbvSubgroupGeMask2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ return spv::BuiltInSubgroupGeMask;
+
+ case glslang::EbvSubgroupGtMask2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ return spv::BuiltInSubgroupGtMask;
+
+ case glslang::EbvSubgroupLeMask2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ return spv::BuiltInSubgroupLeMask;
+
+ case glslang::EbvSubgroupLtMask2:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ return spv::BuiltInSubgroupLtMask;
#ifdef AMD_EXTENSIONS
case glslang::EbvBaryCoordNoPersp:
builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
@@ -652,7 +695,7 @@
builder.addCapability(spv::CapabilityPerViewAttributesNV);
}
return spv::BuiltInViewportMaskPerViewNV;
-#endif
+#endif
default:
return spv::BuiltInMax;
}
@@ -889,6 +932,7 @@
inEntryPoint(false), entryPointTerminated(false), linkageOnly(false),
glslangIntermediate(glslangIntermediate)
{
+ builder.setTargetVersion(glslangIntermediate->getSpv().spv);
spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage());
builder.clearAccessChain();
@@ -1417,16 +1461,14 @@
one = builder.makeFloatConstant(1.0F);
else if (node->getBasicType() == glslang::EbtDouble)
one = builder.makeDoubleConstant(1.0);
-#ifdef AMD_EXTENSIONS
else if (node->getBasicType() == glslang::EbtFloat16)
one = builder.makeFloat16Constant(1.0F);
-#endif
- else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64)
- one = builder.makeInt64Constant(1);
-#ifdef AMD_EXTENSIONS
+ else if (node->getBasicType() == glslang::EbtInt8 || node->getBasicType() == glslang::EbtUint8)
+ one = builder.makeInt8Constant(1);
else if (node->getBasicType() == glslang::EbtInt16 || node->getBasicType() == glslang::EbtUint16)
one = builder.makeInt16Constant(1);
-#endif
+ else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64)
+ one = builder.makeInt64Constant(1);
else
one = builder.makeIntConstant(1);
glslang::TOperator op;
@@ -1631,7 +1673,6 @@
case glslang::EOpConstructBMat4x2:
case glslang::EOpConstructBMat4x3:
case glslang::EOpConstructBMat4x4:
-#ifdef AMD_EXTENSIONS
case glslang::EOpConstructF16Mat2x2:
case glslang::EOpConstructF16Mat2x3:
case glslang::EOpConstructF16Mat2x4:
@@ -1641,7 +1682,6 @@
case glslang::EOpConstructF16Mat4x2:
case glslang::EOpConstructF16Mat4x3:
case glslang::EOpConstructF16Mat4x4:
-#endif
isMatrix = true;
// fall through
case glslang::EOpConstructFloat:
@@ -1652,16 +1692,30 @@
case glslang::EOpConstructDVec2:
case glslang::EOpConstructDVec3:
case glslang::EOpConstructDVec4:
-#ifdef AMD_EXTENSIONS
case glslang::EOpConstructFloat16:
case glslang::EOpConstructF16Vec2:
case glslang::EOpConstructF16Vec3:
case glslang::EOpConstructF16Vec4:
-#endif
case glslang::EOpConstructBool:
case glslang::EOpConstructBVec2:
case glslang::EOpConstructBVec3:
case glslang::EOpConstructBVec4:
+ case glslang::EOpConstructInt8:
+ case glslang::EOpConstructI8Vec2:
+ case glslang::EOpConstructI8Vec3:
+ case glslang::EOpConstructI8Vec4:
+ case glslang::EOpConstructUint8:
+ case glslang::EOpConstructU8Vec2:
+ case glslang::EOpConstructU8Vec3:
+ case glslang::EOpConstructU8Vec4:
+ case glslang::EOpConstructInt16:
+ case glslang::EOpConstructI16Vec2:
+ case glslang::EOpConstructI16Vec3:
+ case glslang::EOpConstructI16Vec4:
+ case glslang::EOpConstructUint16:
+ case glslang::EOpConstructU16Vec2:
+ case glslang::EOpConstructU16Vec3:
+ case glslang::EOpConstructU16Vec4:
case glslang::EOpConstructInt:
case glslang::EOpConstructIVec2:
case glslang::EOpConstructIVec3:
@@ -1678,16 +1732,6 @@
case glslang::EOpConstructU64Vec2:
case glslang::EOpConstructU64Vec3:
case glslang::EOpConstructU64Vec4:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConstructInt16:
- case glslang::EOpConstructI16Vec2:
- case glslang::EOpConstructI16Vec3:
- case glslang::EOpConstructI16Vec4:
- case glslang::EOpConstructUint16:
- case glslang::EOpConstructU16Vec2:
- case glslang::EOpConstructU16Vec3:
- case glslang::EOpConstructU16Vec4:
-#endif
case glslang::EOpConstructStruct:
case glslang::EOpConstructTextureSampler:
{
@@ -1767,6 +1811,11 @@
case glslang::EOpGroupMemoryBarrierWithGroupSync:
case glslang::EOpWorkgroupMemoryBarrier:
case glslang::EOpWorkgroupMemoryBarrierWithGroupSync:
+ case glslang::EOpSubgroupBarrier:
+ case glslang::EOpSubgroupMemoryBarrier:
+ case glslang::EOpSubgroupMemoryBarrierBuffer:
+ case glslang::EOpSubgroupMemoryBarrierImage:
+ case glslang::EOpSubgroupMemoryBarrierShared:
noReturnValue = true;
// These all have 0 operands and will naturally finish up in the code below for 0 operands
break;
@@ -1990,7 +2039,7 @@
// smear condition to vector, if necessary (AST is always scalar)
if (builder.isVector(trueValue))
- condition = builder.smearScalar(spv::NoPrecision, condition,
+ condition = builder.smearScalar(spv::NoPrecision, condition,
builder.makeVectorType(builder.makeBoolType(),
builder.getNumComponents(trueValue)));
@@ -2248,7 +2297,6 @@
spv::StorageClass storageClass = TranslateStorageClass(node->getType());
spv::Id spvType = convertGlslangToSpvType(node->getType());
-#ifdef AMD_EXTENSIONS
const bool contains16BitType = node->getType().containsBasicType(glslang::EbtFloat16) ||
node->getType().containsBasicType(glslang::EbtInt16) ||
node->getType().containsBasicType(glslang::EbtUint16);
@@ -2266,7 +2314,6 @@
builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
}
}
-#endif
const char* name = node->getName().c_str();
if (glslang::IsAnonymous(name))
@@ -2343,12 +2390,13 @@
case glslang::EbtDouble:
spvType = builder.makeFloatType(64);
break;
-#ifdef AMD_EXTENSIONS
case glslang::EbtFloat16:
+ builder.addCapability(spv::CapabilityFloat16);
+#if AMD_EXTENSIONS
builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
+#endif
spvType = builder.makeFloatType(16);
break;
-#endif
case glslang::EbtBool:
// "transparent" bool doesn't exist in SPIR-V. The GLSL convention is
// a 32-bit int where non-0 means true.
@@ -2357,6 +2405,26 @@
else
spvType = builder.makeBoolType();
break;
+ case glslang::EbtInt8:
+ builder.addCapability(spv::CapabilityInt8);
+ spvType = builder.makeIntType(8);
+ break;
+ case glslang::EbtUint8:
+ builder.addCapability(spv::CapabilityInt8);
+ spvType = builder.makeUintType(8);
+ case glslang::EbtInt16:
+ builder.addCapability(spv::CapabilityInt16);
+#ifdef AMD_EXTENSIONS
+ builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
+#endif
+ spvType = builder.makeIntType(16);
+ break;
+ case glslang::EbtUint16:
+ builder.addCapability(spv::CapabilityInt16);
+#ifdef AMD_EXTENSIONS
+ builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
+#endif
+ spvType = builder.makeUintType(16);
case glslang::EbtInt:
spvType = builder.makeIntType(32);
break;
@@ -2369,16 +2437,6 @@
case glslang::EbtUint64:
spvType = builder.makeUintType(64);
break;
-#ifdef AMD_EXTENSIONS
- case glslang::EbtInt16:
- builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
- spvType = builder.makeIntType(16);
- break;
- case glslang::EbtUint16:
- builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
- spvType = builder.makeUintType(16);
- break;
-#endif
case glslang::EbtAtomicUint:
builder.addCapability(spv::CapabilityAtomicStorage);
spvType = builder.makeUintType(32);
@@ -3687,13 +3745,8 @@
spv::Id typeId, spv::Id left, spv::Id right,
glslang::TBasicType typeProxy, bool reduceComparison)
{
-#ifdef AMD_EXTENSIONS
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16;
-#else
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
-#endif
+ bool isUnsigned = isTypeUnsignedInt(typeProxy);
+ bool isFloat = isTypeFloat(typeProxy);
bool isBool = typeProxy == glslang::EbtBool;
spv::Op binOp = spv::OpNop;
@@ -4018,13 +4071,8 @@
spv::Op unaryOp = spv::OpNop;
int extBuiltins = -1;
int libCall = -1;
-#ifdef AMD_EXTENSIONS
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16;
-#else
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
-#endif
+ bool isUnsigned = isTypeUnsignedInt(typeProxy);
+ bool isFloat = isTypeFloat(typeProxy);
switch (op) {
case glslang::EOpNegative:
@@ -4161,12 +4209,10 @@
case glslang::EOpDoubleBitsToUint64:
case glslang::EOpInt64BitsToDouble:
case glslang::EOpUint64BitsToDouble:
-#ifdef AMD_EXTENSIONS
case glslang::EOpFloat16BitsToInt16:
case glslang::EOpFloat16BitsToUint16:
case glslang::EOpInt16BitsToFloat16:
case glslang::EOpUint16BitsToFloat16:
-#endif
unaryOp = spv::OpBitcast;
break;
@@ -4211,10 +4257,12 @@
case glslang::EOpUnpackInt2x32:
case glslang::EOpPackUint2x32:
case glslang::EOpUnpackUint2x32:
- unaryOp = spv::OpBitcast;
- break;
-
-#ifdef AMD_EXTENSIONS
+ case glslang::EOpPack16:
+ case glslang::EOpPack32:
+ case glslang::EOpPack64:
+ case glslang::EOpUnpack32:
+ case glslang::EOpUnpack16:
+ case glslang::EOpUnpack8:
case glslang::EOpPackInt2x16:
case glslang::EOpUnpackInt2x16:
case glslang::EOpPackUint2x16:
@@ -4227,7 +4275,6 @@
case glslang::EOpUnpackFloat2x16:
unaryOp = spv::OpBitcast;
break;
-#endif
case glslang::EOpDPdx:
unaryOp = spv::OpDPdx;
@@ -4342,7 +4389,45 @@
operands.push_back(operand);
return createInvocationsOperation(op, typeId, operands, typeProxy);
}
-
+ case glslang::EOpSubgroupAll:
+ case glslang::EOpSubgroupAny:
+ case glslang::EOpSubgroupAllEqual:
+ case glslang::EOpSubgroupBroadcastFirst:
+ case glslang::EOpSubgroupBallot:
+ case glslang::EOpSubgroupInverseBallot:
+ case glslang::EOpSubgroupBallotBitCount:
+ case glslang::EOpSubgroupBallotInclusiveBitCount:
+ case glslang::EOpSubgroupBallotExclusiveBitCount:
+ case glslang::EOpSubgroupBallotFindLSB:
+ case glslang::EOpSubgroupBallotFindMSB:
+ case glslang::EOpSubgroupAdd:
+ case glslang::EOpSubgroupMul:
+ case glslang::EOpSubgroupMin:
+ case glslang::EOpSubgroupMax:
+ case glslang::EOpSubgroupAnd:
+ case glslang::EOpSubgroupOr:
+ case glslang::EOpSubgroupXor:
+ case glslang::EOpSubgroupInclusiveAdd:
+ case glslang::EOpSubgroupInclusiveMul:
+ case glslang::EOpSubgroupInclusiveMin:
+ case glslang::EOpSubgroupInclusiveMax:
+ case glslang::EOpSubgroupInclusiveAnd:
+ case glslang::EOpSubgroupInclusiveOr:
+ case glslang::EOpSubgroupInclusiveXor:
+ case glslang::EOpSubgroupExclusiveAdd:
+ case glslang::EOpSubgroupExclusiveMul:
+ case glslang::EOpSubgroupExclusiveMin:
+ case glslang::EOpSubgroupExclusiveMax:
+ case glslang::EOpSubgroupExclusiveAnd:
+ case glslang::EOpSubgroupExclusiveOr:
+ case glslang::EOpSubgroupExclusiveXor:
+ case glslang::EOpSubgroupQuadSwapHorizontal:
+ case glslang::EOpSubgroupQuadSwapVertical:
+ case glslang::EOpSubgroupQuadSwapDiagonal: {
+ std::vector<spv::Id> operands;
+ operands.push_back(operand);
+ return createSubgroupOperation(op, typeId, operands, typeProxy);
+ }
#ifdef AMD_EXTENSIONS
case glslang::EOpMbcnt:
extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
@@ -4408,32 +4493,150 @@
return builder.setPrecision(builder.createCompositeConstruct(typeId, results), precision);
}
+spv::Id TGlslangToSpvTraverser::createConversionOperation(glslang::TOperator op, spv::Id operand, int vectorSize)
+{
+ spv::Op convOp = spv::OpNop;
+ spv::Id type = 0;
+
+ spv::Id result = 0;
+
+ switch(op) {
+ case glslang::EOpConvInt8ToUint16:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvInt8ToUint:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(32);
+ break;
+ case glslang::EOpConvInt8ToUint64:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvInt16ToUint8:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvInt16ToUint:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(32);
+ break;
+ case glslang::EOpConvInt16ToUint64:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvIntToUint8:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvIntToUint16:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvIntToUint64:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvInt64ToUint8:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvInt64ToUint16:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvInt64ToUint:
+ convOp = spv::OpSConvert;
+ type = builder.makeIntType(32);
+ break;
+ case glslang::EOpConvUint8ToInt16:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvUint8ToInt:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(32);
+ break;
+ case glslang::EOpConvUint8ToInt64:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvUint16ToInt8:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvUint16ToInt:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(32);
+ break;
+ case glslang::EOpConvUint16ToInt64:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvUintToInt8:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvUintToInt16:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvUintToInt64:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(64);
+ break;
+ case glslang::EOpConvUint64ToInt8:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(8);
+ break;
+ case glslang::EOpConvUint64ToInt16:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(16);
+ break;
+ case glslang::EOpConvUint64ToInt:
+ convOp = spv::OpUConvert;
+ type = builder.makeIntType(32);
+ break;
+
+ default:
+ assert(false && "Default missing");
+ break;
+ }
+
+ if (vectorSize > 0)
+ type = builder.makeVectorType(type, vectorSize);
+
+ result = builder.createUnaryOp(convOp, type, operand);
+ return result;
+}
+
spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id destType, spv::Id operand, glslang::TBasicType typeProxy)
{
spv::Op convOp = spv::OpNop;
spv::Id zero = 0;
spv::Id one = 0;
- spv::Id type = 0;
int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0;
switch (op) {
- case glslang::EOpConvIntToBool:
- case glslang::EOpConvUintToBool:
- case glslang::EOpConvInt64ToBool:
- case glslang::EOpConvUint64ToBool:
-#ifdef AMD_EXTENSIONS
+ case glslang::EOpConvInt8ToBool:
+ case glslang::EOpConvUint8ToBool:
+ zero = builder.makeUint8Constant(0);
+ zero = makeSmearedConstant(zero, vectorSize);
+ return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
case glslang::EOpConvInt16ToBool:
case glslang::EOpConvUint16ToBool:
-#endif
- if (op == glslang::EOpConvInt64ToBool || op == glslang::EOpConvUint64ToBool)
- zero = builder.makeUint64Constant(0);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvInt16ToBool || op == glslang::EOpConvUint16ToBool)
- zero = builder.makeUint16Constant(0);
-#endif
- else
- zero = builder.makeUintConstant(0);
+ zero = builder.makeUint16Constant(0);
+ zero = makeSmearedConstant(zero, vectorSize);
+ return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
+ case glslang::EOpConvIntToBool:
+ case glslang::EOpConvUintToBool:
+ zero = builder.makeUintConstant(0);
+ zero = makeSmearedConstant(zero, vectorSize);
+ return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
+ case glslang::EOpConvInt64ToBool:
+ case glslang::EOpConvUint64ToBool:
+ zero = builder.makeUint64Constant(0);
zero = makeSmearedConstant(zero, vectorSize);
return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
@@ -4447,12 +4650,10 @@
zero = makeSmearedConstant(zero, vectorSize);
return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero);
-#ifdef AMD_EXTENSIONS
case glslang::EOpConvFloat16ToBool:
zero = builder.makeFloat16Constant(0.0F);
zero = makeSmearedConstant(zero, vectorSize);
return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero);
-#endif
case glslang::EOpConvBoolToFloat:
convOp = spv::OpSelect;
@@ -4466,34 +4667,45 @@
one = builder.makeDoubleConstant(1.0);
break;
-#ifdef AMD_EXTENSIONS
case glslang::EOpConvBoolToFloat16:
convOp = spv::OpSelect;
zero = builder.makeFloat16Constant(0.0F);
one = builder.makeFloat16Constant(1.0F);
break;
-#endif
+
+ case glslang::EOpConvBoolToInt8:
+ zero = builder.makeInt8Constant(0);
+ one = builder.makeInt8Constant(1);
+ convOp = spv::OpSelect;
+ break;
+
+ case glslang::EOpConvBoolToUint8:
+ zero = builder.makeUint8Constant(0);
+ one = builder.makeUint8Constant(1);
+ convOp = spv::OpSelect;
+ break;
+
+ case glslang::EOpConvBoolToInt16:
+ zero = builder.makeInt16Constant(0);
+ one = builder.makeInt16Constant(1);
+ convOp = spv::OpSelect;
+ break;
+
+ case glslang::EOpConvBoolToUint16:
+ zero = builder.makeUint16Constant(0);
+ one = builder.makeUint16Constant(1);
+ convOp = spv::OpSelect;
+ break;
case glslang::EOpConvBoolToInt:
case glslang::EOpConvBoolToInt64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvBoolToInt16:
-#endif
if (op == glslang::EOpConvBoolToInt64)
zero = builder.makeInt64Constant(0);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvBoolToInt16)
- zero = builder.makeInt16Constant(0);
-#endif
else
zero = builder.makeIntConstant(0);
if (op == glslang::EOpConvBoolToInt64)
one = builder.makeInt64Constant(1);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvBoolToInt16)
- one = builder.makeInt16Constant(1);
-#endif
else
one = builder.makeIntConstant(1);
@@ -4502,104 +4714,94 @@
case glslang::EOpConvBoolToUint:
case glslang::EOpConvBoolToUint64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvBoolToUint16:
-#endif
if (op == glslang::EOpConvBoolToUint64)
zero = builder.makeUint64Constant(0);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvBoolToUint16)
- zero = builder.makeUint16Constant(0);
-#endif
else
zero = builder.makeUintConstant(0);
if (op == glslang::EOpConvBoolToUint64)
one = builder.makeUint64Constant(1);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvBoolToUint16)
- one = builder.makeUint16Constant(1);
-#endif
else
one = builder.makeUintConstant(1);
convOp = spv::OpSelect;
break;
+ case glslang::EOpConvInt8ToFloat16:
+ case glslang::EOpConvInt8ToFloat:
+ case glslang::EOpConvInt8ToDouble:
+ case glslang::EOpConvInt16ToFloat16:
+ case glslang::EOpConvInt16ToFloat:
+ case glslang::EOpConvInt16ToDouble:
+ case glslang::EOpConvIntToFloat16:
case glslang::EOpConvIntToFloat:
case glslang::EOpConvIntToDouble:
case glslang::EOpConvInt64ToFloat:
case glslang::EOpConvInt64ToDouble:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvInt16ToFloat:
- case glslang::EOpConvInt16ToDouble:
- case glslang::EOpConvInt16ToFloat16:
- case glslang::EOpConvIntToFloat16:
case glslang::EOpConvInt64ToFloat16:
-#endif
convOp = spv::OpConvertSToF;
break;
+ case glslang::EOpConvUint8ToFloat16:
+ case glslang::EOpConvUint8ToFloat:
+ case glslang::EOpConvUint8ToDouble:
+ case glslang::EOpConvUint16ToFloat16:
+ case glslang::EOpConvUint16ToFloat:
+ case glslang::EOpConvUint16ToDouble:
+ case glslang::EOpConvUintToFloat16:
case glslang::EOpConvUintToFloat:
case glslang::EOpConvUintToDouble:
case glslang::EOpConvUint64ToFloat:
case glslang::EOpConvUint64ToDouble:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUint16ToFloat:
- case glslang::EOpConvUint16ToDouble:
- case glslang::EOpConvUint16ToFloat16:
- case glslang::EOpConvUintToFloat16:
case glslang::EOpConvUint64ToFloat16:
-#endif
convOp = spv::OpConvertUToF;
break;
case glslang::EOpConvDoubleToFloat:
case glslang::EOpConvFloatToDouble:
-#ifdef AMD_EXTENSIONS
case glslang::EOpConvDoubleToFloat16:
case glslang::EOpConvFloat16ToDouble:
case glslang::EOpConvFloatToFloat16:
case glslang::EOpConvFloat16ToFloat:
-#endif
convOp = spv::OpFConvert;
if (builder.isMatrixType(destType))
return createUnaryMatrixOperation(convOp, precision, noContraction, destType, operand, typeProxy);
break;
- case glslang::EOpConvFloatToInt:
- case glslang::EOpConvDoubleToInt:
- case glslang::EOpConvFloatToInt64:
- case glslang::EOpConvDoubleToInt64:
-#ifdef AMD_EXTENSIONS
+ case glslang::EOpConvFloat16ToInt8:
+ case glslang::EOpConvFloatToInt8:
+ case glslang::EOpConvDoubleToInt8:
+ case glslang::EOpConvFloat16ToInt16:
case glslang::EOpConvFloatToInt16:
case glslang::EOpConvDoubleToInt16:
- case glslang::EOpConvFloat16ToInt16:
case glslang::EOpConvFloat16ToInt:
+ case glslang::EOpConvFloatToInt:
+ case glslang::EOpConvDoubleToInt:
case glslang::EOpConvFloat16ToInt64:
-#endif
+ case glslang::EOpConvFloatToInt64:
+ case glslang::EOpConvDoubleToInt64:
convOp = spv::OpConvertFToS;
break;
+ case glslang::EOpConvUint8ToInt8:
+ case glslang::EOpConvInt8ToUint8:
+ case glslang::EOpConvUint16ToInt16:
+ case glslang::EOpConvInt16ToUint16:
case glslang::EOpConvUintToInt:
case glslang::EOpConvIntToUint:
case glslang::EOpConvUint64ToInt64:
case glslang::EOpConvInt64ToUint64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUint16ToInt16:
- case glslang::EOpConvInt16ToUint16:
-#endif
if (builder.isInSpecConstCodeGenMode()) {
// Build zero scalar or vector for OpIAdd.
- if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64)
- zero = builder.makeUint64Constant(0);
-#ifdef AMD_EXTENSIONS
- else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16)
+ if(op == glslang::EOpConvUint8ToInt8 || op == glslang::EOpConvInt8ToUint8) {
+ zero = builder.makeUint8Constant(0);
+ } else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) {
zero = builder.makeUint16Constant(0);
-#endif
- else
+ } else if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) {
+ zero = builder.makeUint64Constant(0);
+ } else {
zero = builder.makeUintConstant(0);
-
+ }
zero = makeSmearedConstant(zero, vectorSize);
// Use OpIAdd, instead of OpBitcast to do the conversion when
// generating for OpSpecConstantOp instruction.
@@ -4609,126 +4811,117 @@
convOp = spv::OpBitcast;
break;
+ case glslang::EOpConvFloat16ToUint8:
+ case glslang::EOpConvFloatToUint8:
+ case glslang::EOpConvDoubleToUint8:
+ case glslang::EOpConvFloat16ToUint16:
+ case glslang::EOpConvFloatToUint16:
+ case glslang::EOpConvDoubleToUint16:
+ case glslang::EOpConvFloat16ToUint:
case glslang::EOpConvFloatToUint:
case glslang::EOpConvDoubleToUint:
case glslang::EOpConvFloatToUint64:
case glslang::EOpConvDoubleToUint64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvFloatToUint16:
- case glslang::EOpConvDoubleToUint16:
- case glslang::EOpConvFloat16ToUint16:
- case glslang::EOpConvFloat16ToUint:
case glslang::EOpConvFloat16ToUint64:
-#endif
convOp = spv::OpConvertFToU;
break;
- case glslang::EOpConvIntToInt64:
- case glslang::EOpConvInt64ToInt:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvIntToInt16:
+ case glslang::EOpConvInt8ToInt16:
+ case glslang::EOpConvInt8ToInt:
+ case glslang::EOpConvInt8ToInt64:
+ case glslang::EOpConvInt16ToInt8:
case glslang::EOpConvInt16ToInt:
- case glslang::EOpConvInt64ToInt16:
case glslang::EOpConvInt16ToInt64:
-#endif
+ case glslang::EOpConvIntToInt8:
+ case glslang::EOpConvIntToInt16:
+ case glslang::EOpConvIntToInt64:
+ case glslang::EOpConvInt64ToInt8:
+ case glslang::EOpConvInt64ToInt16:
+ case glslang::EOpConvInt64ToInt:
convOp = spv::OpSConvert;
break;
- case glslang::EOpConvUintToUint64:
- case glslang::EOpConvUint64ToUint:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUintToUint16:
+ case glslang::EOpConvUint8ToUint16:
+ case glslang::EOpConvUint8ToUint:
+ case glslang::EOpConvUint8ToUint64:
+ case glslang::EOpConvUint16ToUint8:
case glslang::EOpConvUint16ToUint:
- case glslang::EOpConvUint64ToUint16:
case glslang::EOpConvUint16ToUint64:
-#endif
+ case glslang::EOpConvUintToUint8:
+ case glslang::EOpConvUintToUint16:
+ case glslang::EOpConvUintToUint64:
+ case glslang::EOpConvUint64ToUint8:
+ case glslang::EOpConvUint64ToUint16:
+ case glslang::EOpConvUint64ToUint:
convOp = spv::OpUConvert;
break;
- case glslang::EOpConvIntToUint64:
- case glslang::EOpConvInt64ToUint:
- case glslang::EOpConvUint64ToInt:
- case glslang::EOpConvUintToInt64:
-#ifdef AMD_EXTENSIONS
+ case glslang::EOpConvInt8ToUint16:
+ case glslang::EOpConvInt8ToUint:
+ case glslang::EOpConvInt8ToUint64:
+ case glslang::EOpConvInt16ToUint8:
case glslang::EOpConvInt16ToUint:
- case glslang::EOpConvUintToInt16:
case glslang::EOpConvInt16ToUint64:
- case glslang::EOpConvUint64ToInt16:
- case glslang::EOpConvUint16ToInt:
+ case glslang::EOpConvIntToUint8:
case glslang::EOpConvIntToUint16:
- case glslang::EOpConvUint16ToInt64:
+ case glslang::EOpConvIntToUint64:
+ case glslang::EOpConvInt64ToUint8:
case glslang::EOpConvInt64ToUint16:
-#endif
+ case glslang::EOpConvInt64ToUint:
+ case glslang::EOpConvUint8ToInt16:
+ case glslang::EOpConvUint8ToInt:
+ case glslang::EOpConvUint8ToInt64:
+ case glslang::EOpConvUint16ToInt8:
+ case glslang::EOpConvUint16ToInt:
+ case glslang::EOpConvUint16ToInt64:
+ case glslang::EOpConvUintToInt8:
+ case glslang::EOpConvUintToInt16:
+ case glslang::EOpConvUintToInt64:
+ case glslang::EOpConvUint64ToInt8:
+ case glslang::EOpConvUint64ToInt16:
+ case glslang::EOpConvUint64ToInt:
// OpSConvert/OpUConvert + OpBitCast
- switch (op) {
- case glslang::EOpConvIntToUint64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvInt16ToUint64:
-#endif
- convOp = spv::OpSConvert;
- type = builder.makeIntType(64);
- break;
- case glslang::EOpConvInt64ToUint:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvInt16ToUint:
-#endif
- convOp = spv::OpSConvert;
- type = builder.makeIntType(32);
- break;
- case glslang::EOpConvUint64ToInt:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUint16ToInt:
-#endif
- convOp = spv::OpUConvert;
- type = builder.makeUintType(32);
- break;
- case glslang::EOpConvUintToInt64:
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUint16ToInt64:
-#endif
- convOp = spv::OpUConvert;
- type = builder.makeUintType(64);
- break;
-#ifdef AMD_EXTENSIONS
- case glslang::EOpConvUintToInt16:
- case glslang::EOpConvUint64ToInt16:
- convOp = spv::OpUConvert;
- type = builder.makeUintType(16);
- break;
- case glslang::EOpConvIntToUint16:
- case glslang::EOpConvInt64ToUint16:
- convOp = spv::OpSConvert;
- type = builder.makeIntType(16);
- break;
-#endif
- default:
- assert(0);
- break;
- }
-
- if (vectorSize > 0)
- type = builder.makeVectorType(type, vectorSize);
-
- operand = builder.createUnaryOp(convOp, type, operand);
+ operand = createConversionOperation(op, operand, vectorSize);
if (builder.isInSpecConstCodeGenMode()) {
// Build zero scalar or vector for OpIAdd.
-#ifdef AMD_EXTENSIONS
- if (op == glslang::EOpConvIntToUint64 || op == glslang::EOpConvUintToInt64 ||
- op == glslang::EOpConvInt16ToUint64 || op == glslang::EOpConvUint16ToInt64)
- zero = builder.makeUint64Constant(0);
- else if (op == glslang::EOpConvIntToUint16 || op == glslang::EOpConvUintToInt16 ||
- op == glslang::EOpConvInt64ToUint16 || op == glslang::EOpConvUint64ToInt16)
+ switch(op) {
+ case glslang::EOpConvInt16ToUint8:
+ case glslang::EOpConvIntToUint8:
+ case glslang::EOpConvInt64ToUint8:
+ case glslang::EOpConvUint16ToInt8:
+ case glslang::EOpConvUintToInt8:
+ case glslang::EOpConvUint64ToInt8:
+ zero = builder.makeUint8Constant(0);
+ break;
+ case glslang::EOpConvInt8ToUint16:
+ case glslang::EOpConvIntToUint16:
+ case glslang::EOpConvInt64ToUint16:
+ case glslang::EOpConvUint8ToInt16:
+ case glslang::EOpConvUintToInt16:
+ case glslang::EOpConvUint64ToInt16:
zero = builder.makeUint16Constant(0);
- else
+ break;
+ case glslang::EOpConvInt8ToUint:
+ case glslang::EOpConvInt16ToUint:
+ case glslang::EOpConvInt64ToUint:
+ case glslang::EOpConvUint8ToInt:
+ case glslang::EOpConvUint16ToInt:
+ case glslang::EOpConvUint64ToInt:
zero = builder.makeUintConstant(0);
-#else
- if (op == glslang::EOpConvIntToUint64 || op == glslang::EOpConvUintToInt64)
+ break;
+ case glslang::EOpConvInt8ToUint64:
+ case glslang::EOpConvInt16ToUint64:
+ case glslang::EOpConvIntToUint64:
+ case glslang::EOpConvUint8ToInt64:
+ case glslang::EOpConvUint16ToInt64:
+ case glslang::EOpConvUintToInt64:
zero = builder.makeUint64Constant(0);
- else
- zero = builder.makeUintConstant(0);
-#endif
-
+ break;
+ default:
+ assert(false && "Default missing");
+ break;
+ }
zero = makeSmearedConstant(zero, vectorSize);
// Use OpIAdd, instead of OpBitcast to do the conversion when
// generating for OpSpecConstantOp instruction.
@@ -4870,10 +5063,8 @@
// Create group invocation operations.
spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
{
-#ifdef AMD_EXTENSIONS
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16;
-#endif
+ bool isUnsigned = isTypeUnsignedInt(typeProxy);
+ bool isFloat = isTypeFloat(typeProxy);
spv::Op opCode = spv::OpNop;
std::vector<spv::Id> spvGroupOperands;
@@ -5134,15 +5325,263 @@
return builder.createCompositeConstruct(typeId, results);
}
+// Create subgroup invocation operations.
+spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
+{
+ // Add the required capabilities.
+ switch (op) {
+ case glslang::EOpSubgroupElect:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ break;
+ case glslang::EOpSubgroupAll:
+ case glslang::EOpSubgroupAny:
+ case glslang::EOpSubgroupAllEqual:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformVote);
+ break;
+ case glslang::EOpSubgroupBroadcast:
+ case glslang::EOpSubgroupBroadcastFirst:
+ case glslang::EOpSubgroupBallot:
+ case glslang::EOpSubgroupInverseBallot:
+ case glslang::EOpSubgroupBallotBitExtract:
+ case glslang::EOpSubgroupBallotBitCount:
+ case glslang::EOpSubgroupBallotInclusiveBitCount:
+ case glslang::EOpSubgroupBallotExclusiveBitCount:
+ case glslang::EOpSubgroupBallotFindLSB:
+ case glslang::EOpSubgroupBallotFindMSB:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformBallot);
+ break;
+ case glslang::EOpSubgroupShuffle:
+ case glslang::EOpSubgroupShuffleXor:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformShuffle);
+ break;
+ case glslang::EOpSubgroupShuffleUp:
+ case glslang::EOpSubgroupShuffleDown:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformShuffleRelative);
+ break;
+ case glslang::EOpSubgroupAdd:
+ case glslang::EOpSubgroupMul:
+ case glslang::EOpSubgroupMin:
+ case glslang::EOpSubgroupMax:
+ case glslang::EOpSubgroupAnd:
+ case glslang::EOpSubgroupOr:
+ case glslang::EOpSubgroupXor:
+ case glslang::EOpSubgroupInclusiveAdd:
+ case glslang::EOpSubgroupInclusiveMul:
+ case glslang::EOpSubgroupInclusiveMin:
+ case glslang::EOpSubgroupInclusiveMax:
+ case glslang::EOpSubgroupInclusiveAnd:
+ case glslang::EOpSubgroupInclusiveOr:
+ case glslang::EOpSubgroupInclusiveXor:
+ case glslang::EOpSubgroupExclusiveAdd:
+ case glslang::EOpSubgroupExclusiveMul:
+ case glslang::EOpSubgroupExclusiveMin:
+ case glslang::EOpSubgroupExclusiveMax:
+ case glslang::EOpSubgroupExclusiveAnd:
+ case glslang::EOpSubgroupExclusiveOr:
+ case glslang::EOpSubgroupExclusiveXor:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformArithmetic);
+ break;
+ case glslang::EOpSubgroupClusteredAdd:
+ case glslang::EOpSubgroupClusteredMul:
+ case glslang::EOpSubgroupClusteredMin:
+ case glslang::EOpSubgroupClusteredMax:
+ case glslang::EOpSubgroupClusteredAnd:
+ case glslang::EOpSubgroupClusteredOr:
+ case glslang::EOpSubgroupClusteredXor:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformClustered);
+ break;
+ case glslang::EOpSubgroupQuadBroadcast:
+ case glslang::EOpSubgroupQuadSwapHorizontal:
+ case glslang::EOpSubgroupQuadSwapVertical:
+ case glslang::EOpSubgroupQuadSwapDiagonal:
+ builder.addCapability(spv::CapabilityGroupNonUniform);
+ builder.addCapability(spv::CapabilityGroupNonUniformQuad);
+ break;
+ default: assert(0 && "Unhandled subgroup operation!");
+ }
+
+ const bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
+ const bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
+ const bool isBool = typeProxy == glslang::EbtBool;
+
+ spv::Op opCode = spv::OpNop;
+
+ // Figure out which opcode to use.
+ switch (op) {
+ case glslang::EOpSubgroupElect: opCode = spv::OpGroupNonUniformElect; break;
+ case glslang::EOpSubgroupAll: opCode = spv::OpGroupNonUniformAll; break;
+ case glslang::EOpSubgroupAny: opCode = spv::OpGroupNonUniformAny; break;
+ case glslang::EOpSubgroupAllEqual: opCode = spv::OpGroupNonUniformAllEqual; break;
+ case glslang::EOpSubgroupBroadcast: opCode = spv::OpGroupNonUniformBroadcast; break;
+ case glslang::EOpSubgroupBroadcastFirst: opCode = spv::OpGroupNonUniformBroadcastFirst; break;
+ case glslang::EOpSubgroupBallot: opCode = spv::OpGroupNonUniformBallot; break;
+ case glslang::EOpSubgroupInverseBallot: opCode = spv::OpGroupNonUniformInverseBallot; break;
+ case glslang::EOpSubgroupBallotBitExtract: opCode = spv::OpGroupNonUniformBallotBitExtract; break;
+ case glslang::EOpSubgroupBallotBitCount:
+ case glslang::EOpSubgroupBallotInclusiveBitCount:
+ case glslang::EOpSubgroupBallotExclusiveBitCount: opCode = spv::OpGroupNonUniformBallotBitCount; break;
+ case glslang::EOpSubgroupBallotFindLSB: opCode = spv::OpGroupNonUniformBallotFindLSB; break;
+ case glslang::EOpSubgroupBallotFindMSB: opCode = spv::OpGroupNonUniformBallotFindMSB; break;
+ case glslang::EOpSubgroupShuffle: opCode = spv::OpGroupNonUniformShuffle; break;
+ case glslang::EOpSubgroupShuffleXor: opCode = spv::OpGroupNonUniformShuffleXor; break;
+ case glslang::EOpSubgroupShuffleUp: opCode = spv::OpGroupNonUniformShuffleUp; break;
+ case glslang::EOpSubgroupShuffleDown: opCode = spv::OpGroupNonUniformShuffleDown; break;
+ case glslang::EOpSubgroupAdd:
+ case glslang::EOpSubgroupInclusiveAdd:
+ case glslang::EOpSubgroupExclusiveAdd:
+ case glslang::EOpSubgroupClusteredAdd:
+ if (isFloat) {
+ opCode = spv::OpGroupNonUniformFAdd;
+ } else {
+ opCode = spv::OpGroupNonUniformIAdd;
+ }
+ break;
+ case glslang::EOpSubgroupMul:
+ case glslang::EOpSubgroupInclusiveMul:
+ case glslang::EOpSubgroupExclusiveMul:
+ case glslang::EOpSubgroupClusteredMul:
+ if (isFloat) {
+ opCode = spv::OpGroupNonUniformFMul;
+ } else {
+ opCode = spv::OpGroupNonUniformIMul;
+ }
+ break;
+ case glslang::EOpSubgroupMin:
+ case glslang::EOpSubgroupInclusiveMin:
+ case glslang::EOpSubgroupExclusiveMin:
+ case glslang::EOpSubgroupClusteredMin:
+ if (isFloat) {
+ opCode = spv::OpGroupNonUniformFMin;
+ } else if (isUnsigned) {
+ opCode = spv::OpGroupNonUniformUMin;
+ } else {
+ opCode = spv::OpGroupNonUniformSMin;
+ }
+ break;
+ case glslang::EOpSubgroupMax:
+ case glslang::EOpSubgroupInclusiveMax:
+ case glslang::EOpSubgroupExclusiveMax:
+ case glslang::EOpSubgroupClusteredMax:
+ if (isFloat) {
+ opCode = spv::OpGroupNonUniformFMax;
+ } else if (isUnsigned) {
+ opCode = spv::OpGroupNonUniformUMax;
+ } else {
+ opCode = spv::OpGroupNonUniformSMax;
+ }
+ break;
+ case glslang::EOpSubgroupAnd:
+ case glslang::EOpSubgroupInclusiveAnd:
+ case glslang::EOpSubgroupExclusiveAnd:
+ case glslang::EOpSubgroupClusteredAnd:
+ if (isBool) {
+ opCode = spv::OpGroupNonUniformLogicalAnd;
+ } else {
+ opCode = spv::OpGroupNonUniformBitwiseAnd;
+ }
+ break;
+ case glslang::EOpSubgroupOr:
+ case glslang::EOpSubgroupInclusiveOr:
+ case glslang::EOpSubgroupExclusiveOr:
+ case glslang::EOpSubgroupClusteredOr:
+ if (isBool) {
+ opCode = spv::OpGroupNonUniformLogicalOr;
+ } else {
+ opCode = spv::OpGroupNonUniformBitwiseOr;
+ }
+ break;
+ case glslang::EOpSubgroupXor:
+ case glslang::EOpSubgroupInclusiveXor:
+ case glslang::EOpSubgroupExclusiveXor:
+ case glslang::EOpSubgroupClusteredXor:
+ if (isBool) {
+ opCode = spv::OpGroupNonUniformLogicalXor;
+ } else {
+ opCode = spv::OpGroupNonUniformBitwiseXor;
+ }
+ break;
+ case glslang::EOpSubgroupQuadBroadcast: opCode = spv::OpGroupNonUniformQuadBroadcast; break;
+ case glslang::EOpSubgroupQuadSwapHorizontal:
+ case glslang::EOpSubgroupQuadSwapVertical:
+ case glslang::EOpSubgroupQuadSwapDiagonal: opCode = spv::OpGroupNonUniformQuadSwap; break;
+ default: assert(0 && "Unhandled subgroup operation!");
+ }
+
+ std::vector<spv::Id> spvGroupOperands;
+
+ // Every operation begins with the Execution Scope operand.
+ spvGroupOperands.push_back(builder.makeUintConstant(spv::ScopeSubgroup));
+
+ // Next, for all operations that use a Group Operation, push that as an operand.
+ switch (op) {
+ default: break;
+ case glslang::EOpSubgroupBallotBitCount:
+ case glslang::EOpSubgroupAdd:
+ case glslang::EOpSubgroupMul:
+ case glslang::EOpSubgroupMin:
+ case glslang::EOpSubgroupMax:
+ case glslang::EOpSubgroupAnd:
+ case glslang::EOpSubgroupOr:
+ case glslang::EOpSubgroupXor:
+ spvGroupOperands.push_back(spv::GroupOperationReduce);
+ break;
+ case glslang::EOpSubgroupBallotInclusiveBitCount:
+ case glslang::EOpSubgroupInclusiveAdd:
+ case glslang::EOpSubgroupInclusiveMul:
+ case glslang::EOpSubgroupInclusiveMin:
+ case glslang::EOpSubgroupInclusiveMax:
+ case glslang::EOpSubgroupInclusiveAnd:
+ case glslang::EOpSubgroupInclusiveOr:
+ case glslang::EOpSubgroupInclusiveXor:
+ spvGroupOperands.push_back(spv::GroupOperationInclusiveScan);
+ break;
+ case glslang::EOpSubgroupBallotExclusiveBitCount:
+ case glslang::EOpSubgroupExclusiveAdd:
+ case glslang::EOpSubgroupExclusiveMul:
+ case glslang::EOpSubgroupExclusiveMin:
+ case glslang::EOpSubgroupExclusiveMax:
+ case glslang::EOpSubgroupExclusiveAnd:
+ case glslang::EOpSubgroupExclusiveOr:
+ case glslang::EOpSubgroupExclusiveXor:
+ spvGroupOperands.push_back(spv::GroupOperationExclusiveScan);
+ break;
+ case glslang::EOpSubgroupClusteredAdd:
+ case glslang::EOpSubgroupClusteredMul:
+ case glslang::EOpSubgroupClusteredMin:
+ case glslang::EOpSubgroupClusteredMax:
+ case glslang::EOpSubgroupClusteredAnd:
+ case glslang::EOpSubgroupClusteredOr:
+ case glslang::EOpSubgroupClusteredXor:
+ spvGroupOperands.push_back(spv::GroupOperationClusteredReduce);
+ break;
+ }
+
+ // Push back the operands next.
+ for (auto opIt : operands) {
+ spvGroupOperands.push_back(opIt);
+ }
+
+ // Some opcodes have additional operands.
+ switch (op) {
+ default: break;
+ case glslang::EOpSubgroupQuadSwapHorizontal: spvGroupOperands.push_back(builder.makeUintConstant(0)); break;
+ case glslang::EOpSubgroupQuadSwapVertical: spvGroupOperands.push_back(builder.makeUintConstant(1)); break;
+ case glslang::EOpSubgroupQuadSwapDiagonal: spvGroupOperands.push_back(builder.makeUintConstant(2)); break;
+ }
+
+ return builder.createOp(opCode, typeId, spvGroupOperands);
+}
+
spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
{
-#ifdef AMD_EXTENSIONS
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64 || typeProxy == glslang::EbtUint16;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble || typeProxy == glslang::EbtFloat16;
-#else
- bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
- bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
-#endif
+ bool isUnsigned = isTypeUnsignedInt(typeProxy);
+ bool isFloat = isTypeFloat(typeProxy);
spv::Op opCode = spv::OpNop;
int extBuiltins = -1;
@@ -5279,11 +5718,7 @@
libCall = spv::GLSLstd450FrexpStruct;
assert(builder.isPointerType(typeId1));
typeId1 = builder.getContainedTypeId(typeId1);
-#ifdef AMD_EXTENSIONS
int width = builder.getScalarTypeWidth(typeId1);
-#else
- int width = 32;
-#endif
if (builder.getNumComponents(operands[0]) == 1)
frexpIntType = builder.makeIntegerType(width, true);
else
@@ -5299,6 +5734,22 @@
case glslang::EOpReadInvocation:
return createInvocationsOperation(op, typeId, operands, typeProxy);
+ case glslang::EOpSubgroupBroadcast:
+ case glslang::EOpSubgroupBallotBitExtract:
+ case glslang::EOpSubgroupShuffle:
+ case glslang::EOpSubgroupShuffleXor:
+ case glslang::EOpSubgroupShuffleUp:
+ case glslang::EOpSubgroupShuffleDown:
+ case glslang::EOpSubgroupClusteredAdd:
+ case glslang::EOpSubgroupClusteredMul:
+ case glslang::EOpSubgroupClusteredMin:
+ case glslang::EOpSubgroupClusteredMax:
+ case glslang::EOpSubgroupClusteredAnd:
+ case glslang::EOpSubgroupClusteredOr:
+ case glslang::EOpSubgroupClusteredXor:
+ case glslang::EOpSubgroupQuadBroadcast:
+ return createSubgroupOperation(op, typeId, operands, typeProxy);
+
#ifdef AMD_EXTENSIONS
case glslang::EOpSwizzleInvocations:
extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
@@ -5466,6 +5917,25 @@
// Control barrier with non-"None" semantic is also a memory barrier.
builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask);
return 0;
+ case glslang::EOpSubgroupBarrier:
+ builder.createControlBarrier(spv::ScopeSubgroup, spv::ScopeDevice, spv::MemorySemanticsMaskNone);
+ return spv::NoResult;
+ case glslang::EOpSubgroupMemoryBarrier:
+ builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAllMemory);
+ return spv::NoResult;
+ case glslang::EOpSubgroupMemoryBarrierBuffer:
+ builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsUniformMemoryMask);
+ return spv::NoResult;
+ case glslang::EOpSubgroupMemoryBarrierImage:
+ builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask);
+ return spv::NoResult;
+ case glslang::EOpSubgroupMemoryBarrierShared:
+ builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsWorkgroupMemoryMask);
+ return spv::NoResult;
+ case glslang::EOpSubgroupElect: {
+ std::vector<spv::Id> operands;
+ return createSubgroupOperation(op, typeId, operands, glslang::EbtVoid);
+ }
#ifdef AMD_EXTENSIONS
case glslang::EOpTime:
{
@@ -5711,6 +6181,18 @@
for (unsigned int i = 0; i < (unsigned int)glslangType.getVectorSize(); ++i) {
bool zero = nextConst >= consts.size();
switch (glslangType.getBasicType()) {
+ case glslang::EbtInt8:
+ spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
+ break;
+ case glslang::EbtUint8:
+ spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const()));
+ break;
+ case glslang::EbtInt16:
+ spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const()));
+ break;
+ case glslang::EbtUint16:
+ spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const()));
+ break;
case glslang::EbtInt:
spvConsts.push_back(builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst()));
break;
@@ -5723,25 +6205,15 @@
case glslang::EbtUint64:
spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const()));
break;
-#ifdef AMD_EXTENSIONS
- case glslang::EbtInt16:
- spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : (short)consts[nextConst].getIConst()));
- break;
- case glslang::EbtUint16:
- spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : (unsigned short)consts[nextConst].getUConst()));
- break;
-#endif
case glslang::EbtFloat:
spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
break;
case glslang::EbtDouble:
spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst()));
break;
-#ifdef AMD_EXTENSIONS
case glslang::EbtFloat16:
spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
break;
-#endif
case glslang::EbtBool:
spvConsts.push_back(builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst()));
break;
@@ -5756,6 +6228,18 @@
bool zero = nextConst >= consts.size();
spv::Id scalar = 0;
switch (glslangType.getBasicType()) {
+ case glslang::EbtInt8:
+ scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
+ break;
+ case glslang::EbtUint8:
+ scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant);
+ break;
+ case glslang::EbtInt16:
+ scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant);
+ break;
+ case glslang::EbtUint16:
+ scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant);
+ break;
case glslang::EbtInt:
scalar = builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst(), specConstant);
break;
@@ -5768,25 +6252,15 @@
case glslang::EbtUint64:
scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
break;
-#ifdef AMD_EXTENSIONS
- case glslang::EbtInt16:
- scalar = builder.makeInt16Constant(zero ? 0 : (short)consts[nextConst].getIConst(), specConstant);
- break;
- case glslang::EbtUint16:
- scalar = builder.makeUint16Constant(zero ? 0 : (unsigned short)consts[nextConst].getUConst(), specConstant);
- break;
-#endif
case glslang::EbtFloat:
scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
break;
case glslang::EbtDouble:
scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant);
break;
-#ifdef AMD_EXTENSIONS
case glslang::EbtFloat16:
scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
break;
-#endif
case glslang::EbtBool:
scalar = builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst(), specConstant);
break;
diff --git a/SPIRV/SPVRemapper.cpp b/SPIRV/SPVRemapper.cpp
index 4d96df6..412f649 100755
--- a/SPIRV/SPVRemapper.cpp
+++ b/SPIRV/SPVRemapper.cpp
@@ -256,7 +256,7 @@
spv::Id spirvbin_t::localId(spv::Id id, spv::Id newId)
{
- assert(id != spv::NoResult && newId != spv::NoResult);
+ //assert(id != spv::NoResult && newId != spv::NoResult);
if (id > bound()) {
error(std::string("ID out of range: ") + std::to_string(id));
@@ -431,7 +431,7 @@
if (spv::InstructionDesc[opCode].hasResult()) {
const spv::Id resultId = asId(word++);
idPosR[resultId] = start;
-
+
if (typeId != spv::NoResult) {
const unsigned idTypeSize = typeSizeInWords(typeId);
diff --git a/SPIRV/SPVRemapper.h b/SPIRV/SPVRemapper.h
index 97e3f31..5abdd4a 100755
--- a/SPIRV/SPVRemapper.h
+++ b/SPIRV/SPVRemapper.h
@@ -179,7 +179,6 @@
range_t constRange(spv::Op opCode) const;
unsigned typeSizeInWords(spv::Id id) const;
unsigned idTypeSizeInWords(spv::Id id) const;
-
spv::Id& asId(unsigned word) { return spv[word]; }
const spv::Id& asId(unsigned word) const { return spv[word]; }
spv::Op asOpCode(unsigned word) const { return opOpCode(spv[word]); }
diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index c795ca8..035f531 100644
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -46,9 +46,7 @@
#include "SpvBuilder.h"
-#ifdef AMD_EXTENSIONS
- #include "hex_float.h"
-#endif
+#include "hex_float.h"
#ifndef _WIN32
#include <cstdio>
@@ -57,6 +55,7 @@
namespace spv {
Builder::Builder(unsigned int magicNumber, SpvBuildLogger* buildLogger) :
+ targetVersion(0x00010000),
source(SourceLanguageUnknown),
sourceVersion(0),
sourceFileStringId(NoResult),
@@ -193,6 +192,9 @@
// deal with capabilities
switch (width) {
+ case 8:
+ addCapability(CapabilityInt8);
+ break;
case 16:
addCapability(CapabilityInt16);
break;
@@ -818,7 +820,6 @@
return c->getResultId();
}
-#ifdef AMD_EXTENSIONS
Id Builder::makeFloat16Constant(float f16, bool specConstant)
{
Op opcode = specConstant ? OpSpecConstant : OpConstant;
@@ -846,7 +847,6 @@
return c->getResultId();
}
-#endif
Id Builder::findCompositeConstant(Op typeClass, const std::vector<Id>& comps) const
{
@@ -2403,7 +2403,7 @@
{
// Header, before first instructions:
out.push_back(MagicNumber);
- out.push_back(Version);
+ out.push_back(targetVersion);
out.push_back(builderNumber);
out.push_back(uniqueId + 1);
out.push_back(0);
@@ -2433,7 +2433,6 @@
// Debug instructions
dumpInstructions(out, strings);
- dumpModuleProcesses(out);
dumpSourceInstructions(out);
for (int e = 0; e < (int)sourceExtensions.size(); ++e) {
Instruction sourceExtInst(0, 0, OpSourceExtension);
@@ -2441,7 +2440,7 @@
sourceExtInst.dump(out);
}
dumpInstructions(out, names);
- dumpInstructions(out, lines);
+ dumpModuleProcesses(out);
// Annotation instructions
dumpInstructions(out, decorations);
diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index 59b1da2..a83e8ca 100755
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -1,6 +1,7 @@
//
// Copyright (C) 2014-2015 LunarG, Inc.
// Copyright (C) 2015-2016 Google, Inc.
+// Copyright (C) 2017 ARM Limited.
//
// All rights reserved.
//
@@ -65,6 +66,7 @@
static const int maxMatrixSize = 4;
+ void setTargetVersion(unsigned int v) { targetVersion = v; }
void setSource(spv::SourceLanguage lang, int version)
{
source = lang;
@@ -211,19 +213,17 @@
// For making new constants (will return old constant if the requested one was already made).
Id makeBoolConstant(bool b, bool specConstant = false);
+ Id makeInt8Constant(int i, bool specConstant = false) { return makeIntConstant(makeIntType(8), (unsigned)i, specConstant); }
+ Id makeUint8Constant(unsigned u, bool specConstant = false) { return makeIntConstant(makeUintType(8), u, specConstant); }
+ Id makeInt16Constant(int i, bool specConstant = false) { return makeIntConstant(makeIntType(16), (unsigned)i, specConstant); }
+ Id makeUint16Constant(unsigned u, bool specConstant = false) { return makeIntConstant(makeUintType(16), u, specConstant); }
Id makeIntConstant(int i, bool specConstant = false) { return makeIntConstant(makeIntType(32), (unsigned)i, specConstant); }
Id makeUintConstant(unsigned u, bool specConstant = false) { return makeIntConstant(makeUintType(32), u, specConstant); }
Id makeInt64Constant(long long i, bool specConstant = false) { return makeInt64Constant(makeIntType(64), (unsigned long long)i, specConstant); }
Id makeUint64Constant(unsigned long long u, bool specConstant = false) { return makeInt64Constant(makeUintType(64), u, specConstant); }
-#ifdef AMD_EXTENSIONS
- Id makeInt16Constant(short i, bool specConstant = false) { return makeIntConstant(makeIntType(16), (unsigned)((unsigned short)i), specConstant); }
- Id makeUint16Constant(unsigned short u, bool specConstant = false) { return makeIntConstant(makeUintType(16), (unsigned)u, specConstant); }
-#endif
Id makeFloatConstant(float f, bool specConstant = false);
Id makeDoubleConstant(double d, bool specConstant = false);
-#ifdef AMD_EXTENSIONS
Id makeFloat16Constant(float f16, bool specConstant = false);
-#endif
// Turn the array of constants into a proper spv constant of the requested type.
Id makeCompositeConstant(Id type, const std::vector<Id>& comps, bool specConst = false);
@@ -330,7 +330,7 @@
// Generally, the type of 'scalar' does not need to be the same type as the components in 'vector'.
// The type of the created vector is a vector of components of the same type as the scalar.
//
- // Note: One of the arguments will change, with the result coming back that way rather than
+ // Note: One of the arguments will change, with the result coming back that way rather than
// through the return value.
void promoteScalar(Decoration precision, Id& left, Id& right);
@@ -585,6 +585,7 @@
void dumpInstructions(std::vector<unsigned int>&, const std::vector<std::unique_ptr<Instruction> >&) const;
void dumpModuleProcesses(std::vector<unsigned int>&) const;
+ unsigned int targetVersion;
SourceLanguage source;
int sourceVersion;
spv::Id sourceFileStringId;
@@ -611,7 +612,6 @@
std::vector<std::unique_ptr<Instruction> > entryPoints;
std::vector<std::unique_ptr<Instruction> > executionModes;
std::vector<std::unique_ptr<Instruction> > names;
- std::vector<std::unique_ptr<Instruction> > lines;
std::vector<std::unique_ptr<Instruction> > decorations;
std::vector<std::unique_ptr<Instruction> > constantsTypesGlobals;
std::vector<std::unique_ptr<Instruction> > externals;
diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp
index c950a66..c07dfc7 100644
--- a/SPIRV/disassemble.cpp
+++ b/SPIRV/disassemble.cpp
@@ -54,6 +54,7 @@
#ifdef AMD_EXTENSIONS
#include "GLSL.ext.AMD.h"
#endif
+
#ifdef NV_EXTENSIONS
#include "GLSL.ext.NV.h"
#endif
@@ -80,12 +81,15 @@
// used to identify the extended instruction library imported when printing
enum ExtInstSet {
GLSL450Inst,
+
#ifdef AMD_EXTENSIONS
GLSLextAMDInst,
#endif
+
#ifdef NV_EXTENSIONS
GLSLextNVInst,
#endif
+
OpenCLExtInst,
};
@@ -653,7 +657,6 @@
}
#endif
-
#ifdef NV_EXTENSIONS
static const char* GLSLextNVGetDebugNames(const char* name, unsigned entrypoint)
{
diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
old mode 100755
new mode 100644
index f9d5254..3343a65
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -722,7 +722,7 @@
}
}
-const int GroupOperationCeiling = 3;
+const int GroupOperationCeiling = 4;
const char* GroupOperationString(int gop)
{
@@ -732,6 +732,7 @@
case 0: return "Reduce";
case 1: return "InclusiveScan";
case 2: return "ExclusiveScan";
+ case 3: return "ClusteredReduce";
case GroupOperationCeiling:
default: return "Bad";
@@ -830,6 +831,14 @@
case 55: return "StorageImageReadWithoutFormat";
case 56: return "StorageImageWriteWithoutFormat";
case 57: return "MultiViewport";
+ case 61: return "GroupNonUniform";
+ case 62: return "GroupNonUniformVote";
+ case 63: return "GroupNonUniformArithmetic";
+ case 64: return "GroupNonUniformBallot";
+ case 65: return "GroupNonUniformShuffle";
+ case 66: return "GroupNonUniformShuffleRelative";
+ case 67: return "GroupNonUniformClustered";
+ case 68: return "GroupNonUniformQuad";
case 4423: return "SubgroupBallotKHR";
case 4427: return "DrawParameters";
@@ -1191,7 +1200,41 @@
case 318: return "OpAtomicFlagTestAndSet";
case 319: return "OpAtomicFlagClear";
case 320: return "OpImageSparseRead";
-
+ case OpModuleProcessed: return "OpModuleProcesses";
+ case 333: return "OpGroupNonUniformElect";
+ case 334: return "OpGroupNonUniformAll";
+ case 335: return "OpGroupNonUniformAny";
+ case 336: return "OpGroupNonUniformAllEqual";
+ case 337: return "OpGroupNonUniformBroadcast";
+ case 338: return "OpGroupNonUniformBroadcastFirst";
+ case 339: return "OpGroupNonUniformBallot";
+ case 340: return "OpGroupNonUniformInverseBallot";
+ case 341: return "OpGroupNonUniformBallotBitExtract";
+ case 342: return "OpGroupNonUniformBallotBitCount";
+ case 343: return "OpGroupNonUniformBallotFindLSB";
+ case 344: return "OpGroupNonUniformBallotFindMSB";
+ case 345: return "OpGroupNonUniformShuffle";
+ case 346: return "OpGroupNonUniformShuffleXor";
+ case 347: return "OpGroupNonUniformShuffleUp";
+ case 348: return "OpGroupNonUniformShuffleDown";
+ case 349: return "OpGroupNonUniformIAdd";
+ case 350: return "OpGroupNonUniformFAdd";
+ case 351: return "OpGroupNonUniformIMul";
+ case 352: return "OpGroupNonUniformFMul";
+ case 353: return "OpGroupNonUniformSMin";
+ case 354: return "OpGroupNonUniformUMin";
+ case 355: return "OpGroupNonUniformFMin";
+ case 356: return "OpGroupNonUniformSMax";
+ case 357: return "OpGroupNonUniformUMax";
+ case 358: return "OpGroupNonUniformFMax";
+ case 359: return "OpGroupNonUniformBitwiseAnd";
+ case 360: return "OpGroupNonUniformBitwiseOr";
+ case 361: return "OpGroupNonUniformBitwiseXor";
+ case 362: return "OpGroupNonUniformLogicalAnd";
+ case 363: return "OpGroupNonUniformLogicalOr";
+ case 364: return "OpGroupNonUniformLogicalXor";
+ case 365: return "OpGroupNonUniformQuadBroadcast";
+ case 366: return "OpGroupNonUniformQuadSwap";
case 4421: return "OpSubgroupBallotKHR";
case 4422: return "OpSubgroupFirstInvocationKHR";
case 4428: return "OpSubgroupAllKHR";
@@ -1343,6 +1386,7 @@
InstructionDesc[OpReleaseEvent].setResultAndType(false, false);
InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
+ InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
// Specific additional context-dependent operands
@@ -2813,6 +2857,182 @@
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'");
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'");
+ InstructionDesc[OpGroupNonUniformElect].capabilities.push_back(CapabilityGroupNonUniform);
+ InstructionDesc[OpGroupNonUniformElect].operands.push(OperandScope, "'Execution'");
+
+ InstructionDesc[OpGroupNonUniformAll].capabilities.push_back(CapabilityGroupNonUniformVote);
+ InstructionDesc[OpGroupNonUniformAll].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformAll].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformAny].capabilities.push_back(CapabilityGroupNonUniformVote);
+ InstructionDesc[OpGroupNonUniformAny].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformAny].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformAllEqual].capabilities.push_back(CapabilityGroupNonUniformVote);
+ InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformBroadcast].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "ID");
+
+ InstructionDesc[OpGroupNonUniformBroadcastFirst].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformBallot].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformInverseBallot].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformBallotBitExtract].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "Bit");
+
+ InstructionDesc[OpGroupNonUniformBallotBitCount].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformBallotFindLSB].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformBallotFindMSB].capabilities.push_back(CapabilityGroupNonUniformBallot);
+ InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandId, "X");
+
+ InstructionDesc[OpGroupNonUniformShuffle].capabilities.push_back(CapabilityGroupNonUniformShuffle);
+ InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "'Id'");
+
+ InstructionDesc[OpGroupNonUniformShuffleXor].capabilities.push_back(CapabilityGroupNonUniformShuffle);
+ InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "Mask");
+
+ InstructionDesc[OpGroupNonUniformShuffleUp].capabilities.push_back(CapabilityGroupNonUniformShuffleRelative);
+ InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "Offset");
+
+ InstructionDesc[OpGroupNonUniformShuffleDown].capabilities.push_back(CapabilityGroupNonUniformShuffleRelative);
+ InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "Offset");
+
+ InstructionDesc[OpGroupNonUniformIAdd].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformFAdd].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformIMul].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformFMul].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformSMin].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformUMin].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformFMin].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformSMax].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformUMax].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformFMax].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformBitwiseAnd].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformBitwiseOr].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformBitwiseXor].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformLogicalAnd].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformLogicalOr].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformLogicalXor].capabilities.push_back(CapabilityGroupNonUniformArithmetic);
+ InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandGroupOperation, "'Operation'");
+ InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "'ClusterSize'", true);
+
+ InstructionDesc[OpGroupNonUniformQuadBroadcast].capabilities.push_back(CapabilityGroupNonUniformQuad);
+ InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "'Id'");
+
+ InstructionDesc[OpGroupNonUniformQuadSwap].capabilities.push_back(CapabilityGroupNonUniformQuad);
+ InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandScope, "'Execution'");
+ InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "X");
+ InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandLiteralNumber, "'Direction'");
+
InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'");
@@ -2833,6 +3053,8 @@
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
+ InstructionDesc[OpModuleProcessed].operands.push(OperandLiteralString, "'process'");
+
#ifdef AMD_EXTENSIONS
InstructionDesc[OpGroupIAddNonUniformAMD].capabilities.push_back(CapabilityGroups);
InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index 8bddf7e..d528dea 100755
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -46,12 +46,12 @@
typedef unsigned int Id;
-#define SPV_VERSION 0x10000
-#define SPV_REVISION 12
+#define SPV_VERSION 0x10300
+#define SPV_REVISION 1
static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010000;
-static const unsigned int Revision = 12;
+static const unsigned int Version = 0x00010300;
+static const unsigned int Revision = 1;
static const unsigned int OpCodeMask = 0xffff;
static const unsigned int WordCountShift = 16;
@@ -122,7 +122,15 @@
ExecutionModeOutputTriangleStrip = 29,
ExecutionModeVecTypeHint = 30,
ExecutionModeContractionOff = 31,
+ ExecutionModeInitializer = 33,
+ ExecutionModeFinalizer = 34,
+ ExecutionModeSubgroupSize = 35,
+ ExecutionModeSubgroupsPerWorkgroup = 36,
+ ExecutionModeSubgroupsPerWorkgroupId = 37,
+ ExecutionModeLocalSizeId = 38,
+ ExecutionModeLocalSizeHintId = 39,
ExecutionModePostDepthCoverage = 4446,
+ ExecutionModeStencilRefReplacingEXT = 5027,
ExecutionModeMax = 0x7fffffff,
};
@@ -377,6 +385,9 @@
DecorationNoContraction = 42,
DecorationInputAttachmentIndex = 43,
DecorationAlignment = 44,
+ DecorationMaxByteOffset = 45,
+ DecorationAlignmentId = 46,
+ DecorationMaxByteOffsetId = 47,
DecorationExplicitInterpAMD = 4999,
DecorationOverrideCoverageNV = 5248,
DecorationPassthroughNV = 5250,
@@ -427,10 +438,15 @@
BuiltInSubgroupLocalInvocationId = 41,
BuiltInVertexIndex = 42,
BuiltInInstanceIndex = 43,
+ BuiltInSubgroupEqMask = 4416,
BuiltInSubgroupEqMaskKHR = 4416,
+ BuiltInSubgroupGeMask = 4417,
BuiltInSubgroupGeMaskKHR = 4417,
+ BuiltInSubgroupGtMask = 4418,
BuiltInSubgroupGtMaskKHR = 4418,
+ BuiltInSubgroupLeMask = 4419,
BuiltInSubgroupLeMaskKHR = 4419,
+ BuiltInSubgroupLtMask = 4420,
BuiltInSubgroupLtMaskKHR = 4420,
BuiltInBaseVertex = 4424,
BuiltInBaseInstance = 4425,
@@ -468,6 +484,8 @@
enum LoopControlShift {
LoopControlUnrollShift = 0,
LoopControlDontUnrollShift = 1,
+ LoopControlDependencyInfiniteShift = 2,
+ LoopControlDependencyLengthShift = 3,
LoopControlMax = 0x7fffffff,
};
@@ -475,6 +493,8 @@
LoopControlMaskNone = 0,
LoopControlUnrollMask = 0x00000001,
LoopControlDontUnrollMask = 0x00000002,
+ LoopControlDependencyInfiniteMask = 0x00000004,
+ LoopControlDependencyLengthMask = 0x00000008,
};
enum FunctionControlShift {
@@ -548,6 +568,7 @@
GroupOperationReduce = 0,
GroupOperationInclusiveScan = 1,
GroupOperationExclusiveScan = 2,
+ GroupOperationClusteredReduce = 3,
GroupOperationMax = 0x7fffffff,
};
@@ -625,6 +646,17 @@
CapabilityStorageImageReadWithoutFormat = 55,
CapabilityStorageImageWriteWithoutFormat = 56,
CapabilityMultiViewport = 57,
+ CapabilitySubgroupDispatch = 58,
+ CapabilityNamedBarrier = 59,
+ CapabilityPipeStorage = 60,
+ CapabilityGroupNonUniform = 61,
+ CapabilityGroupNonUniformVote = 62,
+ CapabilityGroupNonUniformArithmetic = 63,
+ CapabilityGroupNonUniformBallot = 64,
+ CapabilityGroupNonUniformShuffle = 65,
+ CapabilityGroupNonUniformShuffleRelative = 66,
+ CapabilityGroupNonUniformClustered = 67,
+ CapabilityGroupNonUniformQuad = 68,
CapabilitySubgroupBallotKHR = 4423,
CapabilityDrawParameters = 4427,
CapabilitySubgroupVoteKHR = 4431,
@@ -641,7 +673,9 @@
CapabilityAtomicStorageOps = 4445,
CapabilitySampleMaskPostDepthCoverage = 4447,
CapabilityImageGatherBiasLodAMD = 5009,
+ CapabilityFragmentMaskAMD = 5010,
CapabilityStencilExportEXT = 5013,
+ CapabilityImageReadWriteLodAMD = 5015,
CapabilitySampleMaskOverrideCoverageNV = 5249,
CapabilityGeometryShaderPassthroughNV = 5251,
CapabilityShaderViewportIndexLayerEXT = 5254,
@@ -947,6 +981,52 @@
OpAtomicFlagTestAndSet = 318,
OpAtomicFlagClear = 319,
OpImageSparseRead = 320,
+ OpSizeOf = 321,
+ OpTypePipeStorage = 322,
+ OpConstantPipeStorage = 323,
+ OpCreatePipeFromPipeStorage = 324,
+ OpGetKernelLocalSizeForSubgroupCount = 325,
+ OpGetKernelMaxNumSubgroups = 326,
+ OpTypeNamedBarrier = 327,
+ OpNamedBarrierInitialize = 328,
+ OpMemoryNamedBarrier = 329,
+ OpModuleProcessed = 330,
+ OpExecutionModeId = 331,
+ OpDecorateId = 332,
+ OpGroupNonUniformElect = 333,
+ OpGroupNonUniformAll = 334,
+ OpGroupNonUniformAny = 335,
+ OpGroupNonUniformAllEqual = 336,
+ OpGroupNonUniformBroadcast = 337,
+ OpGroupNonUniformBroadcastFirst = 338,
+ OpGroupNonUniformBallot = 339,
+ OpGroupNonUniformInverseBallot = 340,
+ OpGroupNonUniformBallotBitExtract = 341,
+ OpGroupNonUniformBallotBitCount = 342,
+ OpGroupNonUniformBallotFindLSB = 343,
+ OpGroupNonUniformBallotFindMSB = 344,
+ OpGroupNonUniformShuffle = 345,
+ OpGroupNonUniformShuffleXor = 346,
+ OpGroupNonUniformShuffleUp = 347,
+ OpGroupNonUniformShuffleDown = 348,
+ OpGroupNonUniformIAdd = 349,
+ OpGroupNonUniformFAdd = 350,
+ OpGroupNonUniformIMul = 351,
+ OpGroupNonUniformFMul = 352,
+ OpGroupNonUniformSMin = 353,
+ OpGroupNonUniformUMin = 354,
+ OpGroupNonUniformFMin = 355,
+ OpGroupNonUniformSMax = 356,
+ OpGroupNonUniformUMax = 357,
+ OpGroupNonUniformFMax = 358,
+ OpGroupNonUniformBitwiseAnd = 359,
+ OpGroupNonUniformBitwiseOr = 360,
+ OpGroupNonUniformBitwiseXor = 361,
+ OpGroupNonUniformLogicalAnd = 362,
+ OpGroupNonUniformLogicalOr = 363,
+ OpGroupNonUniformLogicalXor = 364,
+ OpGroupNonUniformQuadBroadcast = 365,
+ OpGroupNonUniformQuadSwap = 366,
OpSubgroupBallotKHR = 4421,
OpSubgroupFirstInvocationKHR = 4422,
OpSubgroupAllKHR = 4428,
@@ -961,6 +1041,8 @@
OpGroupFMaxNonUniformAMD = 5005,
OpGroupUMaxNonUniformAMD = 5006,
OpGroupSMaxNonUniformAMD = 5007,
+ OpFragmentMaskFetchAMD = 5011,
+ OpFragmentFetchAMD = 5012,
OpMax = 0x7fffffff,
};
diff --git a/StandAlone/StandAlone.cpp b/StandAlone/StandAlone.cpp
index 19302cb..977ee62 100644
--- a/StandAlone/StandAlone.cpp
+++ b/StandAlone/StandAlone.cpp
@@ -155,7 +155,7 @@
int ClientInputSemanticsVersion = 100; // maps to, say, #define VULKAN 100
int VulkanClientVersion = 100; // would map to, say, Vulkan 1.0
int OpenGLClientVersion = 450; // doesn't influence anything yet, but maps to OpenGL 4.50
-unsigned int TargetVersion = 0x00001000; // maps to, say, SPIR-V 1.0
+unsigned int TargetVersion = 0x00010000; // maps to, say, SPIR-V 1.0
std::vector<std::string> Processes; // what should be recorded by OpModuleProcessed, or equivalent
// Per descriptor-set binding base data
@@ -501,6 +501,10 @@
if (strcmp(argv[1], "vulkan1.0") == 0) {
setVulkanSpv();
VulkanClientVersion = 100;
+ } else if (strcmp(argv[1], "vulkan1.1") == 0) {
+ setVulkanSpv();
+ TargetVersion = 0x00010300;
+ VulkanClientVersion = 110;
} else if (strcmp(argv[1], "opengl") == 0) {
setOpenGlSpv();
OpenGLClientVersion = 450;
@@ -1328,8 +1332,9 @@
" using -S.\n"
" --suppress-warnings suppress GLSL warnings\n"
" (except as required by #extension : warn)\n"
- " --target-env {vulkan1.0|opengl} set the execution environment code will\n"
- " execute in (as opposed to language\n"
+ " --target-env {vulkan1.0 | vulkan1.1 | opengl} \n"
+ " set execution environment that emitted code\n"
+ " will execute in (as opposed to the language\n"
" semantics selected by --client) defaults:\n"
" 'vulkan1.0' under '--client vulkan<ver>'\n"
" 'opengl' under '--client opengl<ver>'\n"
diff --git a/Test/baseResults/findFunction.frag.out b/Test/baseResults/findFunction.frag.out
new file mode 100644
index 0000000..ec4f3e4
--- /dev/null
+++ b/Test/baseResults/findFunction.frag.out
@@ -0,0 +1,233 @@
+findFunction.frag
+ERROR: 0:39: 'func' : ambiguous best function under implicit type conversion
+ERROR: 0:40: 'func' : no matching overloaded function found
+ERROR: 0:40: '=' : cannot convert from ' const float' to ' temp int64_t'
+ERROR: 0:41: 'func' : no matching overloaded function found
+ERROR: 0:41: '=' : cannot convert from ' const float' to ' temp int64_t'
+ERROR: 0:44: 'func' : no matching overloaded function found
+ERROR: 0:44: '=' : cannot convert from ' const float' to ' temp int64_t'
+ERROR: 0:45: 'func' : ambiguous best function under implicit type conversion
+ERROR: 8 compilation errors. No code generated.
+
+
+Shader version: 450
+Requested GL_KHX_shader_explicit_arithmetic_types
+ERROR: node is still EOpNull!
+0:5 Function Definition: func(i81;i161;i161; ( global int64_t)
+0:5 Function Parameters:
+0:5 'a' ( in int8_t)
+0:5 'b' ( in int16_t)
+0:5 'c' ( in int16_t)
+0:7 Sequence
+0:7 Branch: Return with expression
+0:7 Convert int16_t to int64 ( temp int64_t)
+0:7 inclusive-or ( temp int16_t)
+0:7 Convert int8_t to int16_t ( temp int16_t)
+0:7 'a' ( in int8_t)
+0:7 add ( temp int16_t)
+0:7 'b' ( in int16_t)
+0:7 'c' ( in int16_t)
+0:10 Function Definition: func(i81;i161;i1; ( global int64_t)
+0:10 Function Parameters:
+0:10 'a' ( in int8_t)
+0:10 'b' ( in int16_t)
+0:10 'c' ( in int)
+0:12 Sequence
+0:12 Branch: Return with expression
+0:12 Convert int to int64 ( temp int64_t)
+0:12 inclusive-or ( temp int)
+0:12 Convert int8_t to int ( temp int)
+0:12 'a' ( in int8_t)
+0:12 subtract ( temp int)
+0:12 Convert int16_t to int ( temp int)
+0:12 'b' ( in int16_t)
+0:12 'c' ( in int)
+0:15 Function Definition: func(i1;i1;i1; ( global int64_t)
+0:15 Function Parameters:
+0:15 'a' ( in int)
+0:15 'b' ( in int)
+0:15 'c' ( in int)
+0:17 Sequence
+0:17 Branch: Return with expression
+0:17 Convert int to int64 ( temp int64_t)
+0:17 add ( temp int)
+0:17 divide ( temp int)
+0:17 'a' ( in int)
+0:17 'b' ( in int)
+0:17 'c' ( in int)
+0:20 Function Definition: func(f161;f161;f1; ( global int64_t)
+0:20 Function Parameters:
+0:20 'a' ( in float16_t)
+0:20 'b' ( in float16_t)
+0:20 'c' ( in float)
+0:22 Sequence
+0:22 Branch: Return with expression
+0:22 Convert float to int64 ( temp int64_t)
+0:22 subtract ( temp float)
+0:22 Convert float16_t to float ( temp float)
+0:22 'a' ( in float16_t)
+0:22 component-wise multiply ( temp float)
+0:22 Convert float16_t to float ( temp float)
+0:22 'b' ( in float16_t)
+0:22 'c' ( in float)
+0:25 Function Definition: func(f161;i161;f1; ( global int64_t)
+0:25 Function Parameters:
+0:25 'a' ( in float16_t)
+0:25 'b' ( in int16_t)
+0:25 'c' ( in float)
+0:27 Sequence
+0:27 Branch: Return with expression
+0:27 Convert float to int64 ( temp int64_t)
+0:27 subtract ( temp float)
+0:27 Convert float16_t to float ( temp float)
+0:27 'a' ( in float16_t)
+0:27 component-wise multiply ( temp float)
+0:27 Convert int16_t to float ( temp float)
+0:27 'b' ( in int16_t)
+0:27 'c' ( in float)
+0:30 Function Definition: main( ( global void)
+0:30 Function Parameters:
+0:? Sequence
+0:38 Sequence
+0:38 move second child to first child ( temp int64_t)
+0:38 'b1' ( temp int64_t)
+0:38 Function Call: func(i81;i161;i1; ( global int64_t)
+0:38 'x' ( temp int8_t)
+0:38 'y' ( temp int16_t)
+0:38 'z' ( temp int)
+0:39 Sequence
+0:39 move second child to first child ( temp int64_t)
+0:39 'b2' ( temp int64_t)
+0:39 Function Call: func(f161;i161;f1; ( global int64_t)
+0:39 Convert int16_t to float16_t ( temp float16_t)
+0:39 'y' ( temp int16_t)
+0:39 'y' ( temp int16_t)
+0:39 Convert int to float ( temp float)
+0:39 'z' ( temp int)
+0:42 Sequence
+0:42 move second child to first child ( temp int64_t)
+0:42 'b5' ( temp int64_t)
+0:42 Function Call: func(f161;i161;f1; ( global int64_t)
+0:42 Convert int16_t to float16_t ( temp float16_t)
+0:42 'y' ( temp int16_t)
+0:42 'y' ( temp int16_t)
+0:42 Convert float16_t to float ( temp float)
+0:42 'f16' ( temp float16_t)
+0:43 Sequence
+0:43 move second child to first child ( temp int64_t)
+0:43 'b7' ( temp int64_t)
+0:43 Function Call: func(f161;f161;f1; ( global int64_t)
+0:43 'f16' ( temp float16_t)
+0:43 'f16' ( temp float16_t)
+0:43 Convert int16_t to float ( temp float)
+0:43 'y' ( temp int16_t)
+0:45 Sequence
+0:45 move second child to first child ( temp int64_t)
+0:45 'b9' ( temp int64_t)
+0:45 Function Call: func(f161;f161;f1; ( global int64_t)
+0:45 'f16' ( temp float16_t)
+0:45 Convert int8_t to float16_t ( temp float16_t)
+0:45 'x' ( temp int8_t)
+0:45 Convert float16_t to float ( temp float)
+0:45 'f16' ( temp float16_t)
+0:? Linker Objects
+
+
+Linked fragment stage:
+
+
+Shader version: 450
+Requested GL_KHX_shader_explicit_arithmetic_types
+ERROR: node is still EOpNull!
+0:10 Function Definition: func(i81;i161;i1; ( global int64_t)
+0:10 Function Parameters:
+0:10 'a' ( in int8_t)
+0:10 'b' ( in int16_t)
+0:10 'c' ( in int)
+0:12 Sequence
+0:12 Branch: Return with expression
+0:12 Convert int to int64 ( temp int64_t)
+0:12 inclusive-or ( temp int)
+0:12 Convert int8_t to int ( temp int)
+0:12 'a' ( in int8_t)
+0:12 subtract ( temp int)
+0:12 Convert int16_t to int ( temp int)
+0:12 'b' ( in int16_t)
+0:12 'c' ( in int)
+0:20 Function Definition: func(f161;f161;f1; ( global int64_t)
+0:20 Function Parameters:
+0:20 'a' ( in float16_t)
+0:20 'b' ( in float16_t)
+0:20 'c' ( in float)
+0:22 Sequence
+0:22 Branch: Return with expression
+0:22 Convert float to int64 ( temp int64_t)
+0:22 subtract ( temp float)
+0:22 Convert float16_t to float ( temp float)
+0:22 'a' ( in float16_t)
+0:22 component-wise multiply ( temp float)
+0:22 Convert float16_t to float ( temp float)
+0:22 'b' ( in float16_t)
+0:22 'c' ( in float)
+0:25 Function Definition: func(f161;i161;f1; ( global int64_t)
+0:25 Function Parameters:
+0:25 'a' ( in float16_t)
+0:25 'b' ( in int16_t)
+0:25 'c' ( in float)
+0:27 Sequence
+0:27 Branch: Return with expression
+0:27 Convert float to int64 ( temp int64_t)
+0:27 subtract ( temp float)
+0:27 Convert float16_t to float ( temp float)
+0:27 'a' ( in float16_t)
+0:27 component-wise multiply ( temp float)
+0:27 Convert int16_t to float ( temp float)
+0:27 'b' ( in int16_t)
+0:27 'c' ( in float)
+0:30 Function Definition: main( ( global void)
+0:30 Function Parameters:
+0:? Sequence
+0:38 Sequence
+0:38 move second child to first child ( temp int64_t)
+0:38 'b1' ( temp int64_t)
+0:38 Function Call: func(i81;i161;i1; ( global int64_t)
+0:38 'x' ( temp int8_t)
+0:38 'y' ( temp int16_t)
+0:38 'z' ( temp int)
+0:39 Sequence
+0:39 move second child to first child ( temp int64_t)
+0:39 'b2' ( temp int64_t)
+0:39 Function Call: func(f161;i161;f1; ( global int64_t)
+0:39 Convert int16_t to float16_t ( temp float16_t)
+0:39 'y' ( temp int16_t)
+0:39 'y' ( temp int16_t)
+0:39 Convert int to float ( temp float)
+0:39 'z' ( temp int)
+0:42 Sequence
+0:42 move second child to first child ( temp int64_t)
+0:42 'b5' ( temp int64_t)
+0:42 Function Call: func(f161;i161;f1; ( global int64_t)
+0:42 Convert int16_t to float16_t ( temp float16_t)
+0:42 'y' ( temp int16_t)
+0:42 'y' ( temp int16_t)
+0:42 Convert float16_t to float ( temp float)
+0:42 'f16' ( temp float16_t)
+0:43 Sequence
+0:43 move second child to first child ( temp int64_t)
+0:43 'b7' ( temp int64_t)
+0:43 Function Call: func(f161;f161;f1; ( global int64_t)
+0:43 'f16' ( temp float16_t)
+0:43 'f16' ( temp float16_t)
+0:43 Convert int16_t to float ( temp float)
+0:43 'y' ( temp int16_t)
+0:45 Sequence
+0:45 move second child to first child ( temp int64_t)
+0:45 'b9' ( temp int64_t)
+0:45 Function Call: func(f161;f161;f1; ( global int64_t)
+0:45 'f16' ( temp float16_t)
+0:45 Convert int8_t to float16_t ( temp float16_t)
+0:45 'x' ( temp int8_t)
+0:45 Convert float16_t to float ( temp float)
+0:45 'f16' ( temp float16_t)
+0:? Linker Objects
+
diff --git a/Test/baseResults/hlsl.wavebroadcast.comp.out b/Test/baseResults/hlsl.wavebroadcast.comp.out
new file mode 100644
index 0000000..45bca74
--- /dev/null
+++ b/Test/baseResults/hlsl.wavebroadcast.comp.out
@@ -0,0 +1,2731 @@
+hlsl.wavebroadcast.comp
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:13 Function Definition: @CSMain(vu3; ( temp void)
+0:13 Function Parameters:
+0:13 'dti' ( in 3-component vector of uint)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 subgroupShuffle ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 13 (const uint)
+0:15 move second child to first child ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 subgroupShuffle ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 13 (const uint)
+0:16 move second child to first child ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 subgroupShuffle ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 Constant:
+0:16 13 (const uint)
+0:17 move second child to first child ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 subgroupShuffle ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 Constant:
+0:17 13 (const uint)
+0:19 move second child to first child ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 subgroupShuffle ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 Constant:
+0:19 13 (const uint)
+0:20 move second child to first child ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 subgroupShuffle ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 13 (const uint)
+0:21 move second child to first child ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 subgroupShuffle ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Constant:
+0:21 13 (const uint)
+0:22 move second child to first child ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 subgroupShuffle ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 Constant:
+0:22 13 (const uint)
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 subgroupShuffle ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 Constant:
+0:24 13 (const uint)
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 subgroupShuffle ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 13 (const uint)
+0:26 move second child to first child ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 subgroupShuffle ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 Constant:
+0:26 13 (const uint)
+0:27 move second child to first child ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 subgroupShuffle ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Constant:
+0:27 13 (const uint)
+0:29 move second child to first child ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 subgroupBroadcastFirst ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:30 move second child to first child ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 subgroupBroadcastFirst ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:31 move second child to first child ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 subgroupBroadcastFirst ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:32 move second child to first child ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 subgroupBroadcastFirst ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:34 move second child to first child ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 subgroupBroadcastFirst ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:35 move second child to first child ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 subgroupBroadcastFirst ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:36 move second child to first child ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 subgroupBroadcastFirst ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:37 move second child to first child ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 subgroupBroadcastFirst ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:39 move second child to first child ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 subgroupBroadcastFirst ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:40 move second child to first child ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 subgroupBroadcastFirst ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:41 move second child to first child ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 subgroupBroadcastFirst ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:42 move second child to first child ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 subgroupBroadcastFirst ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:44 move second child to first child ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 subgroupBroadcastFirst ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:45 move second child to first child ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 subgroupBroadcastFirst ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:46 move second child to first child ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 subgroupBroadcastFirst ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:47 move second child to first child ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 subgroupBroadcastFirst ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:49 move second child to first child ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 subgroupBroadcastFirst ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:50 move second child to first child ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 subgroupBroadcastFirst ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:51 move second child to first child ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 subgroupBroadcastFirst ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:52 move second child to first child ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 subgroupBroadcastFirst ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:13 Function Definition: CSMain( ( temp void)
+0:13 Function Parameters:
+0:? Sequence
+0:13 move second child to first child ( temp 3-component vector of uint)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+0:13 Function Call: @CSMain(vu3; ( temp void)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+
+
+Linked compute stage:
+
+
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:13 Function Definition: @CSMain(vu3; ( temp void)
+0:13 Function Parameters:
+0:13 'dti' ( in 3-component vector of uint)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 subgroupShuffle ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 13 (const uint)
+0:15 move second child to first child ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 subgroupShuffle ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 13 (const uint)
+0:16 move second child to first child ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 subgroupShuffle ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 Constant:
+0:16 13 (const uint)
+0:17 move second child to first child ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 subgroupShuffle ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 Constant:
+0:17 13 (const uint)
+0:19 move second child to first child ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 subgroupShuffle ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 Constant:
+0:19 13 (const uint)
+0:20 move second child to first child ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 subgroupShuffle ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 13 (const uint)
+0:21 move second child to first child ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 subgroupShuffle ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Constant:
+0:21 13 (const uint)
+0:22 move second child to first child ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 subgroupShuffle ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 Constant:
+0:22 13 (const uint)
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 subgroupShuffle ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 Constant:
+0:24 13 (const uint)
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 subgroupShuffle ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 13 (const uint)
+0:26 move second child to first child ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 subgroupShuffle ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 Constant:
+0:26 13 (const uint)
+0:27 move second child to first child ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 subgroupShuffle ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Constant:
+0:27 13 (const uint)
+0:29 move second child to first child ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 subgroupBroadcastFirst ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:30 move second child to first child ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 subgroupBroadcastFirst ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:31 move second child to first child ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 subgroupBroadcastFirst ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:32 move second child to first child ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 subgroupBroadcastFirst ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:34 move second child to first child ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 subgroupBroadcastFirst ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:35 move second child to first child ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 subgroupBroadcastFirst ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:36 move second child to first child ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 subgroupBroadcastFirst ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:37 move second child to first child ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 subgroupBroadcastFirst ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:39 move second child to first child ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 subgroupBroadcastFirst ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:40 move second child to first child ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 subgroupBroadcastFirst ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:41 move second child to first child ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 subgroupBroadcastFirst ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:42 move second child to first child ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 subgroupBroadcastFirst ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:44 move second child to first child ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 subgroupBroadcastFirst ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:45 move second child to first child ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 subgroupBroadcastFirst ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:46 move second child to first child ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 subgroupBroadcastFirst ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:47 move second child to first child ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 subgroupBroadcastFirst ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:49 move second child to first child ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 subgroupBroadcastFirst ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:50 move second child to first child ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 subgroupBroadcastFirst ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:51 move second child to first child ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 subgroupBroadcastFirst ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:52 move second child to first child ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 subgroupBroadcastFirst ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:13 Function Definition: CSMain( ( temp void)
+0:13 Function Parameters:
+0:? Sequence
+0:13 move second child to first child ( temp 3-component vector of uint)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+0:13 Function Call: @CSMain(vu3; ( temp void)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+
+// Module Version 10000
+// Generated by (magic number): 80002
+// Id's are bound by 359
+
+ Capability Shader
+ Capability Float64
+ Capability GroupNonUniform
+ Capability GroupNonUniformBallot
+ Capability GroupNonUniformShuffle
+ 1: ExtInstImport "GLSL.std.450"
+ MemoryModel Logical GLSL450
+ EntryPoint GLCompute 4 "CSMain" 354
+ ExecutionMode 4 LocalSize 32 16 1
+ Source HLSL 500
+ Name 4 "CSMain"
+ Name 11 "@CSMain(vu3;"
+ Name 10 "dti"
+ Name 20 "Types"
+ MemberName 20(Types) 0 "u"
+ MemberName 20(Types) 1 "i"
+ MemberName 20(Types) 2 "f"
+ MemberName 20(Types) 3 "d"
+ Name 22 "data"
+ MemberName 22(data) 0 "@data"
+ Name 24 "data"
+ Name 352 "dti"
+ Name 354 "dti"
+ Name 356 "param"
+ MemberDecorate 20(Types) 0 Offset 0
+ MemberDecorate 20(Types) 1 Offset 16
+ MemberDecorate 20(Types) 2 Offset 32
+ MemberDecorate 20(Types) 3 Offset 64
+ Decorate 21 ArrayStride 96
+ MemberDecorate 22(data) 0 Offset 0
+ Decorate 22(data) BufferBlock
+ Decorate 24(data) DescriptorSet 0
+ Decorate 354(dti) BuiltIn GlobalInvocationId
+ 2: TypeVoid
+ 3: TypeFunction 2
+ 6: TypeInt 32 0
+ 7: TypeVector 6(int) 3
+ 8: TypePointer Function 7(ivec3)
+ 9: TypeFunction 2 8(ptr)
+ 13: TypeVector 6(int) 4
+ 14: TypeInt 32 1
+ 15: TypeVector 14(int) 4
+ 16: TypeFloat 32
+ 17: TypeVector 16(float) 4
+ 18: TypeFloat 64
+ 19: TypeVector 18(float) 4
+ 20(Types): TypeStruct 13(ivec4) 15(ivec4) 17(fvec4) 19(fvec4)
+ 21: TypeRuntimeArray 20(Types)
+ 22(data): TypeStruct 21
+ 23: TypePointer Uniform 22(data)
+ 24(data): 23(ptr) Variable Uniform
+ 25: 14(int) Constant 0
+ 26: 6(int) Constant 0
+ 27: TypePointer Function 6(int)
+ 32: TypePointer Uniform 13(ivec4)
+ 35: 6(int) Constant 13
+ 36: 6(int) Constant 3
+ 43: TypePointer Uniform 6(int)
+ 52: TypeVector 6(int) 2
+ 73: 14(int) Constant 1
+ 76: TypePointer Uniform 15(ivec4)
+ 85: TypePointer Uniform 14(int)
+ 94: TypeVector 14(int) 2
+ 106: TypeVector 14(int) 3
+ 116: 14(int) Constant 2
+ 119: TypePointer Uniform 17(fvec4)
+ 128: TypePointer Uniform 16(float)
+ 137: TypeVector 16(float) 2
+ 149: TypeVector 16(float) 3
+ 159: 14(int) Constant 3
+ 162: TypePointer Uniform 19(fvec4)
+ 171: TypePointer Uniform 18(float)
+ 180: TypeVector 18(float) 2
+ 192: TypeVector 18(float) 3
+ 353: TypePointer Input 7(ivec3)
+ 354(dti): 353(ptr) Variable Input
+ 4(CSMain): 2 Function None 3
+ 5: Label
+ 352(dti): 8(ptr) Variable Function
+ 356(param): 8(ptr) Variable Function
+ 355: 7(ivec3) Load 354(dti)
+ Store 352(dti) 355
+ 357: 7(ivec3) Load 352(dti)
+ Store 356(param) 357
+ 358: 2 FunctionCall 11(@CSMain(vu3;) 356(param)
+ Return
+ FunctionEnd
+11(@CSMain(vu3;): 2 Function None 9
+ 10(dti): 8(ptr) FunctionParameter
+ 12: Label
+ 28: 27(ptr) AccessChain 10(dti) 26
+ 29: 6(int) Load 28
+ 30: 27(ptr) AccessChain 10(dti) 26
+ 31: 6(int) Load 30
+ 33: 32(ptr) AccessChain 24(data) 25 31 25
+ 34: 13(ivec4) Load 33
+ 37: 13(ivec4) GroupNonUniformShuffle 36 34 35
+ 38: 32(ptr) AccessChain 24(data) 25 29 25
+ Store 38 37
+ 39: 27(ptr) AccessChain 10(dti) 26
+ 40: 6(int) Load 39
+ 41: 27(ptr) AccessChain 10(dti) 26
+ 42: 6(int) Load 41
+ 44: 43(ptr) AccessChain 24(data) 25 42 25 26
+ 45: 6(int) Load 44
+ 46: 6(int) GroupNonUniformShuffle 36 45 35
+ 47: 43(ptr) AccessChain 24(data) 25 40 25 26
+ Store 47 46
+ 48: 27(ptr) AccessChain 10(dti) 26
+ 49: 6(int) Load 48
+ 50: 27(ptr) AccessChain 10(dti) 26
+ 51: 6(int) Load 50
+ 53: 32(ptr) AccessChain 24(data) 25 51 25
+ 54: 13(ivec4) Load 53
+ 55: 52(ivec2) VectorShuffle 54 54 0 1
+ 56: 52(ivec2) GroupNonUniformShuffle 36 55 35
+ 57: 32(ptr) AccessChain 24(data) 25 49 25
+ 58: 13(ivec4) Load 57
+ 59: 13(ivec4) VectorShuffle 58 56 4 5 2 3
+ Store 57 59
+ 60: 27(ptr) AccessChain 10(dti) 26
+ 61: 6(int) Load 60
+ 62: 27(ptr) AccessChain 10(dti) 26
+ 63: 6(int) Load 62
+ 64: 32(ptr) AccessChain 24(data) 25 63 25
+ 65: 13(ivec4) Load 64
+ 66: 7(ivec3) VectorShuffle 65 65 0 1 2
+ 67: 7(ivec3) GroupNonUniformShuffle 36 66 35
+ 68: 32(ptr) AccessChain 24(data) 25 61 25
+ 69: 13(ivec4) Load 68
+ 70: 13(ivec4) VectorShuffle 69 67 4 5 6 3
+ Store 68 70
+ 71: 27(ptr) AccessChain 10(dti) 26
+ 72: 6(int) Load 71
+ 74: 27(ptr) AccessChain 10(dti) 26
+ 75: 6(int) Load 74
+ 77: 76(ptr) AccessChain 24(data) 25 75 73
+ 78: 15(ivec4) Load 77
+ 79: 15(ivec4) GroupNonUniformShuffle 36 78 35
+ 80: 76(ptr) AccessChain 24(data) 25 72 73
+ Store 80 79
+ 81: 27(ptr) AccessChain 10(dti) 26
+ 82: 6(int) Load 81
+ 83: 27(ptr) AccessChain 10(dti) 26
+ 84: 6(int) Load 83
+ 86: 85(ptr) AccessChain 24(data) 25 84 73 26
+ 87: 14(int) Load 86
+ 88: 14(int) GroupNonUniformShuffle 36 87 35
+ 89: 85(ptr) AccessChain 24(data) 25 82 73 26
+ Store 89 88
+ 90: 27(ptr) AccessChain 10(dti) 26
+ 91: 6(int) Load 90
+ 92: 27(ptr) AccessChain 10(dti) 26
+ 93: 6(int) Load 92
+ 95: 76(ptr) AccessChain 24(data) 25 93 73
+ 96: 15(ivec4) Load 95
+ 97: 94(ivec2) VectorShuffle 96 96 0 1
+ 98: 94(ivec2) GroupNonUniformShuffle 36 97 35
+ 99: 76(ptr) AccessChain 24(data) 25 91 73
+ 100: 15(ivec4) Load 99
+ 101: 15(ivec4) VectorShuffle 100 98 4 5 2 3
+ Store 99 101
+ 102: 27(ptr) AccessChain 10(dti) 26
+ 103: 6(int) Load 102
+ 104: 27(ptr) AccessChain 10(dti) 26
+ 105: 6(int) Load 104
+ 107: 76(ptr) AccessChain 24(data) 25 105 73
+ 108: 15(ivec4) Load 107
+ 109: 106(ivec3) VectorShuffle 108 108 0 1 2
+ 110: 106(ivec3) GroupNonUniformShuffle 36 109 35
+ 111: 76(ptr) AccessChain 24(data) 25 103 73
+ 112: 15(ivec4) Load 111
+ 113: 15(ivec4) VectorShuffle 112 110 4 5 6 3
+ Store 111 113
+ 114: 27(ptr) AccessChain 10(dti) 26
+ 115: 6(int) Load 114
+ 117: 27(ptr) AccessChain 10(dti) 26
+ 118: 6(int) Load 117
+ 120: 119(ptr) AccessChain 24(data) 25 118 116
+ 121: 17(fvec4) Load 120
+ 122: 17(fvec4) GroupNonUniformShuffle 36 121 35
+ 123: 119(ptr) AccessChain 24(data) 25 115 116
+ Store 123 122
+ 124: 27(ptr) AccessChain 10(dti) 26
+ 125: 6(int) Load 124
+ 126: 27(ptr) AccessChain 10(dti) 26
+ 127: 6(int) Load 126
+ 129: 128(ptr) AccessChain 24(data) 25 127 116 26
+ 130: 16(float) Load 129
+ 131: 16(float) GroupNonUniformShuffle 36 130 35
+ 132: 128(ptr) AccessChain 24(data) 25 125 116 26
+ Store 132 131
+ 133: 27(ptr) AccessChain 10(dti) 26
+ 134: 6(int) Load 133
+ 135: 27(ptr) AccessChain 10(dti) 26
+ 136: 6(int) Load 135
+ 138: 119(ptr) AccessChain 24(data) 25 136 116
+ 139: 17(fvec4) Load 138
+ 140: 137(fvec2) VectorShuffle 139 139 0 1
+ 141: 137(fvec2) GroupNonUniformShuffle 36 140 35
+ 142: 119(ptr) AccessChain 24(data) 25 134 116
+ 143: 17(fvec4) Load 142
+ 144: 17(fvec4) VectorShuffle 143 141 4 5 2 3
+ Store 142 144
+ 145: 27(ptr) AccessChain 10(dti) 26
+ 146: 6(int) Load 145
+ 147: 27(ptr) AccessChain 10(dti) 26
+ 148: 6(int) Load 147
+ 150: 119(ptr) AccessChain 24(data) 25 148 116
+ 151: 17(fvec4) Load 150
+ 152: 149(fvec3) VectorShuffle 151 151 0 1 2
+ 153: 149(fvec3) GroupNonUniformShuffle 36 152 35
+ 154: 119(ptr) AccessChain 24(data) 25 146 116
+ 155: 17(fvec4) Load 154
+ 156: 17(fvec4) VectorShuffle 155 153 4 5 6 3
+ Store 154 156
+ 157: 27(ptr) AccessChain 10(dti) 26
+ 158: 6(int) Load 157
+ 160: 27(ptr) AccessChain 10(dti) 26
+ 161: 6(int) Load 160
+ 163: 162(ptr) AccessChain 24(data) 25 161 159
+ 164: 19(fvec4) Load 163
+ 165: 19(fvec4) GroupNonUniformBroadcastFirst 36 164
+ 166: 162(ptr) AccessChain 24(data) 25 158 159
+ Store 166 165
+ 167: 27(ptr) AccessChain 10(dti) 26
+ 168: 6(int) Load 167
+ 169: 27(ptr) AccessChain 10(dti) 26
+ 170: 6(int) Load 169
+ 172: 171(ptr) AccessChain 24(data) 25 170 159 26
+ 173: 18(float) Load 172
+ 174: 18(float) GroupNonUniformBroadcastFirst 36 173
+ 175: 171(ptr) AccessChain 24(data) 25 168 159 26
+ Store 175 174
+ 176: 27(ptr) AccessChain 10(dti) 26
+ 177: 6(int) Load 176
+ 178: 27(ptr) AccessChain 10(dti) 26
+ 179: 6(int) Load 178
+ 181: 162(ptr) AccessChain 24(data) 25 179 159
+ 182: 19(fvec4) Load 181
+ 183: 180(fvec2) VectorShuffle 182 182 0 1
+ 184: 180(fvec2) GroupNonUniformBroadcastFirst 36 183
+ 185: 162(ptr) AccessChain 24(data) 25 177 159
+ 186: 19(fvec4) Load 185
+ 187: 19(fvec4) VectorShuffle 186 184 4 5 2 3
+ Store 185 187
+ 188: 27(ptr) AccessChain 10(dti) 26
+ 189: 6(int) Load 188
+ 190: 27(ptr) AccessChain 10(dti) 26
+ 191: 6(int) Load 190
+ 193: 162(ptr) AccessChain 24(data) 25 191 159
+ 194: 19(fvec4) Load 193
+ 195: 192(fvec3) VectorShuffle 194 194 0 1 2
+ 196: 192(fvec3) GroupNonUniformBroadcastFirst 36 195
+ 197: 162(ptr) AccessChain 24(data) 25 189 159
+ 198: 19(fvec4) Load 197
+ 199: 19(fvec4) VectorShuffle 198 196 4 5 6 3
+ Store 197 199
+ 200: 27(ptr) AccessChain 10(dti) 26
+ 201: 6(int) Load 200
+ 202: 27(ptr) AccessChain 10(dti) 26
+ 203: 6(int) Load 202
+ 204: 32(ptr) AccessChain 24(data) 25 203 25
+ 205: 13(ivec4) Load 204
+ 206: 13(ivec4) GroupNonUniformBroadcastFirst 36 205
+ 207: 32(ptr) AccessChain 24(data) 25 201 25
+ Store 207 206
+ 208: 27(ptr) AccessChain 10(dti) 26
+ 209: 6(int) Load 208
+ 210: 27(ptr) AccessChain 10(dti) 26
+ 211: 6(int) Load 210
+ 212: 43(ptr) AccessChain 24(data) 25 211 25 26
+ 213: 6(int) Load 212
+ 214: 6(int) GroupNonUniformBroadcastFirst 36 213
+ 215: 43(ptr) AccessChain 24(data) 25 209 25 26
+ Store 215 214
+ 216: 27(ptr) AccessChain 10(dti) 26
+ 217: 6(int) Load 216
+ 218: 27(ptr) AccessChain 10(dti) 26
+ 219: 6(int) Load 218
+ 220: 32(ptr) AccessChain 24(data) 25 219 25
+ 221: 13(ivec4) Load 220
+ 222: 52(ivec2) VectorShuffle 221 221 0 1
+ 223: 52(ivec2) GroupNonUniformBroadcastFirst 36 222
+ 224: 32(ptr) AccessChain 24(data) 25 217 25
+ 225: 13(ivec4) Load 224
+ 226: 13(ivec4) VectorShuffle 225 223 4 5 2 3
+ Store 224 226
+ 227: 27(ptr) AccessChain 10(dti) 26
+ 228: 6(int) Load 227
+ 229: 27(ptr) AccessChain 10(dti) 26
+ 230: 6(int) Load 229
+ 231: 32(ptr) AccessChain 24(data) 25 230 25
+ 232: 13(ivec4) Load 231
+ 233: 7(ivec3) VectorShuffle 232 232 0 1 2
+ 234: 7(ivec3) GroupNonUniformBroadcastFirst 36 233
+ 235: 32(ptr) AccessChain 24(data) 25 228 25
+ 236: 13(ivec4) Load 235
+ 237: 13(ivec4) VectorShuffle 236 234 4 5 6 3
+ Store 235 237
+ 238: 27(ptr) AccessChain 10(dti) 26
+ 239: 6(int) Load 238
+ 240: 27(ptr) AccessChain 10(dti) 26
+ 241: 6(int) Load 240
+ 242: 76(ptr) AccessChain 24(data) 25 241 73
+ 243: 15(ivec4) Load 242
+ 244: 15(ivec4) GroupNonUniformBroadcastFirst 36 243
+ 245: 76(ptr) AccessChain 24(data) 25 239 73
+ Store 245 244
+ 246: 27(ptr) AccessChain 10(dti) 26
+ 247: 6(int) Load 246
+ 248: 27(ptr) AccessChain 10(dti) 26
+ 249: 6(int) Load 248
+ 250: 85(ptr) AccessChain 24(data) 25 249 73 26
+ 251: 14(int) Load 250
+ 252: 14(int) GroupNonUniformBroadcastFirst 36 251
+ 253: 85(ptr) AccessChain 24(data) 25 247 73 26
+ Store 253 252
+ 254: 27(ptr) AccessChain 10(dti) 26
+ 255: 6(int) Load 254
+ 256: 27(ptr) AccessChain 10(dti) 26
+ 257: 6(int) Load 256
+ 258: 76(ptr) AccessChain 24(data) 25 257 73
+ 259: 15(ivec4) Load 258
+ 260: 94(ivec2) VectorShuffle 259 259 0 1
+ 261: 94(ivec2) GroupNonUniformBroadcastFirst 36 260
+ 262: 76(ptr) AccessChain 24(data) 25 255 73
+ 263: 15(ivec4) Load 262
+ 264: 15(ivec4) VectorShuffle 263 261 4 5 2 3
+ Store 262 264
+ 265: 27(ptr) AccessChain 10(dti) 26
+ 266: 6(int) Load 265
+ 267: 27(ptr) AccessChain 10(dti) 26
+ 268: 6(int) Load 267
+ 269: 76(ptr) AccessChain 24(data) 25 268 73
+ 270: 15(ivec4) Load 269
+ 271: 106(ivec3) VectorShuffle 270 270 0 1 2
+ 272: 106(ivec3) GroupNonUniformBroadcastFirst 36 271
+ 273: 76(ptr) AccessChain 24(data) 25 266 73
+ 274: 15(ivec4) Load 273
+ 275: 15(ivec4) VectorShuffle 274 272 4 5 6 3
+ Store 273 275
+ 276: 27(ptr) AccessChain 10(dti) 26
+ 277: 6(int) Load 276
+ 278: 27(ptr) AccessChain 10(dti) 26
+ 279: 6(int) Load 278
+ 280: 119(ptr) AccessChain 24(data) 25 279 116
+ 281: 17(fvec4) Load 280
+ 282: 17(fvec4) GroupNonUniformBroadcastFirst 36 281
+ 283: 119(ptr) AccessChain 24(data) 25 277 116
+ Store 283 282
+ 284: 27(ptr) AccessChain 10(dti) 26
+ 285: 6(int) Load 284
+ 286: 27(ptr) AccessChain 10(dti) 26
+ 287: 6(int) Load 286
+ 288: 128(ptr) AccessChain 24(data) 25 287 116 26
+ 289: 16(float) Load 288
+ 290: 16(float) GroupNonUniformBroadcastFirst 36 289
+ 291: 128(ptr) AccessChain 24(data) 25 285 116 26
+ Store 291 290
+ 292: 27(ptr) AccessChain 10(dti) 26
+ 293: 6(int) Load 292
+ 294: 27(ptr) AccessChain 10(dti) 26
+ 295: 6(int) Load 294
+ 296: 119(ptr) AccessChain 24(data) 25 295 116
+ 297: 17(fvec4) Load 296
+ 298: 137(fvec2) VectorShuffle 297 297 0 1
+ 299: 137(fvec2) GroupNonUniformBroadcastFirst 36 298
+ 300: 119(ptr) AccessChain 24(data) 25 293 116
+ 301: 17(fvec4) Load 300
+ 302: 17(fvec4) VectorShuffle 301 299 4 5 2 3
+ Store 300 302
+ 303: 27(ptr) AccessChain 10(dti) 26
+ 304: 6(int) Load 303
+ 305: 27(ptr) AccessChain 10(dti) 26
+ 306: 6(int) Load 305
+ 307: 119(ptr) AccessChain 24(data) 25 306 116
+ 308: 17(fvec4) Load 307
+ 309: 149(fvec3) VectorShuffle 308 308 0 1 2
+ 310: 149(fvec3) GroupNonUniformBroadcastFirst 36 309
+ 311: 119(ptr) AccessChain 24(data) 25 304 116
+ 312: 17(fvec4) Load 311
+ 313: 17(fvec4) VectorShuffle 312 310 4 5 6 3
+ Store 311 313
+ 314: 27(ptr) AccessChain 10(dti) 26
+ 315: 6(int) Load 314
+ 316: 27(ptr) AccessChain 10(dti) 26
+ 317: 6(int) Load 316
+ 318: 162(ptr) AccessChain 24(data) 25 317 159
+ 319: 19(fvec4) Load 318
+ 320: 19(fvec4) GroupNonUniformBroadcastFirst 36 319
+ 321: 162(ptr) AccessChain 24(data) 25 315 159
+ Store 321 320
+ 322: 27(ptr) AccessChain 10(dti) 26
+ 323: 6(int) Load 322
+ 324: 27(ptr) AccessChain 10(dti) 26
+ 325: 6(int) Load 324
+ 326: 171(ptr) AccessChain 24(data) 25 325 159 26
+ 327: 18(float) Load 326
+ 328: 18(float) GroupNonUniformBroadcastFirst 36 327
+ 329: 171(ptr) AccessChain 24(data) 25 323 159 26
+ Store 329 328
+ 330: 27(ptr) AccessChain 10(dti) 26
+ 331: 6(int) Load 330
+ 332: 27(ptr) AccessChain 10(dti) 26
+ 333: 6(int) Load 332
+ 334: 162(ptr) AccessChain 24(data) 25 333 159
+ 335: 19(fvec4) Load 334
+ 336: 180(fvec2) VectorShuffle 335 335 0 1
+ 337: 180(fvec2) GroupNonUniformBroadcastFirst 36 336
+ 338: 162(ptr) AccessChain 24(data) 25 331 159
+ 339: 19(fvec4) Load 338
+ 340: 19(fvec4) VectorShuffle 339 337 4 5 2 3
+ Store 338 340
+ 341: 27(ptr) AccessChain 10(dti) 26
+ 342: 6(int) Load 341
+ 343: 27(ptr) AccessChain 10(dti) 26
+ 344: 6(int) Load 343
+ 345: 162(ptr) AccessChain 24(data) 25 344 159
+ 346: 19(fvec4) Load 345
+ 347: 192(fvec3) VectorShuffle 346 346 0 1 2
+ 348: 192(fvec3) GroupNonUniformBroadcastFirst 36 347
+ 349: 162(ptr) AccessChain 24(data) 25 342 159
+ 350: 19(fvec4) Load 349
+ 351: 19(fvec4) VectorShuffle 350 348 4 5 6 3
+ Store 349 351
+ Return
+ FunctionEnd
diff --git a/Test/baseResults/hlsl.waveordered.comp.out b/Test/baseResults/hlsl.waveordered.comp.out
new file mode 100644
index 0000000..15102d3
--- /dev/null
+++ b/Test/baseResults/hlsl.waveordered.comp.out
@@ -0,0 +1,180 @@
+hlsl.waveordered.comp
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:5 Function Definition: @CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:6 move second child to first child ( temp uint)
+0:6 indirect index (layout( row_major std430) buffer uint)
+0:6 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of uint)
+0:6 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+0:6 Constant:
+0:6 0 (const uint)
+0:6 add ( temp uint)
+0:6 add ( temp uint)
+0:6 component-wise multiply ( temp uint)
+0:6 add ( temp uint)
+0:6 component-wise multiply ( temp uint)
+0:6 direct index ( temp uint)
+0:6 '@gl_NumWorkGroups' ( in 3-component vector of uint NumWorkGroups)
+0:6 Constant:
+0:6 1 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 2 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 1 (const int)
+0:6 component-wise multiply ( temp uint)
+0:6 '@gl_NumSubgroups' ( in uint unknown built-in variable)
+0:6 direct index ( temp uint)
+0:6 '@gl_NumWorkGroups' ( in 3-component vector of uint NumWorkGroups)
+0:6 Constant:
+0:6 0 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 0 (const int)
+0:6 '@gl_SubgroupID' ( in uint unknown built-in variable)
+0:6 Constant:
+0:6 1 (const uint)
+0:5 Function Definition: CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:5 Function Call: @CSMain( ( temp void)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+
+
+Linked compute stage:
+
+
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:5 Function Definition: @CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:6 move second child to first child ( temp uint)
+0:6 indirect index (layout( row_major std430) buffer uint)
+0:6 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of uint)
+0:6 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+0:6 Constant:
+0:6 0 (const uint)
+0:6 add ( temp uint)
+0:6 add ( temp uint)
+0:6 component-wise multiply ( temp uint)
+0:6 add ( temp uint)
+0:6 component-wise multiply ( temp uint)
+0:6 direct index ( temp uint)
+0:6 '@gl_NumWorkGroups' ( in 3-component vector of uint NumWorkGroups)
+0:6 Constant:
+0:6 1 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 2 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 1 (const int)
+0:6 component-wise multiply ( temp uint)
+0:6 '@gl_NumSubgroups' ( in uint unknown built-in variable)
+0:6 direct index ( temp uint)
+0:6 '@gl_NumWorkGroups' ( in 3-component vector of uint NumWorkGroups)
+0:6 Constant:
+0:6 0 (const int)
+0:6 direct index ( temp uint)
+0:6 '@gl_WorkGroupID' ( in 3-component vector of uint WorkGroupID)
+0:6 Constant:
+0:6 0 (const int)
+0:6 '@gl_SubgroupID' ( in uint unknown built-in variable)
+0:6 Constant:
+0:6 1 (const uint)
+0:5 Function Definition: CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:5 Function Call: @CSMain( ( temp void)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+
+// Module Version 10000
+// Generated by (magic number): 80002
+// Id's are bound by 46
+
+ Capability Shader
+ Capability GroupNonUniform
+ 1: ExtInstImport "GLSL.std.450"
+ MemoryModel Logical GLSL450
+ EntryPoint GLCompute 4 "CSMain" 17 22 30 40
+ ExecutionMode 4 LocalSize 32 16 1
+ Source HLSL 500
+ Name 4 "CSMain"
+ Name 6 "@CSMain("
+ Name 10 "data"
+ MemberName 10(data) 0 "@data"
+ Name 12 "data"
+ Name 17 "@gl_NumWorkGroups"
+ Name 22 "@gl_WorkGroupID"
+ Name 30 "@gl_NumSubgroups"
+ Name 40 "@gl_SubgroupID"
+ Decorate 9 ArrayStride 4
+ MemberDecorate 10(data) 0 Offset 0
+ Decorate 10(data) BufferBlock
+ Decorate 12(data) DescriptorSet 0
+ Decorate 17(@gl_NumWorkGroups) BuiltIn NumWorkgroups
+ Decorate 22(@gl_WorkGroupID) BuiltIn WorkgroupId
+ Decorate 30(@gl_NumSubgroups) BuiltIn NumSubgroups
+ Decorate 40(@gl_SubgroupID) BuiltIn SubgroupId
+ 2: TypeVoid
+ 3: TypeFunction 2
+ 8: TypeInt 32 0
+ 9: TypeRuntimeArray 8(int)
+ 10(data): TypeStruct 9
+ 11: TypePointer Uniform 10(data)
+ 12(data): 11(ptr) Variable Uniform
+ 13: TypeInt 32 1
+ 14: 13(int) Constant 0
+ 15: TypeVector 8(int) 3
+ 16: TypePointer Input 15(ivec3)
+17(@gl_NumWorkGroups): 16(ptr) Variable Input
+ 18: 8(int) Constant 1
+ 19: TypePointer Input 8(int)
+22(@gl_WorkGroupID): 16(ptr) Variable Input
+ 23: 8(int) Constant 2
+30(@gl_NumSubgroups): 19(ptr) Variable Input
+ 32: 8(int) Constant 0
+40(@gl_SubgroupID): 19(ptr) Variable Input
+ 43: TypePointer Uniform 8(int)
+ 4(CSMain): 2 Function None 3
+ 5: Label
+ 45: 2 FunctionCall 6(@CSMain()
+ Return
+ FunctionEnd
+ 6(@CSMain(): 2 Function None 3
+ 7: Label
+ 20: 19(ptr) AccessChain 17(@gl_NumWorkGroups) 18
+ 21: 8(int) Load 20
+ 24: 19(ptr) AccessChain 22(@gl_WorkGroupID) 23
+ 25: 8(int) Load 24
+ 26: 8(int) IMul 21 25
+ 27: 19(ptr) AccessChain 22(@gl_WorkGroupID) 18
+ 28: 8(int) Load 27
+ 29: 8(int) IAdd 26 28
+ 31: 8(int) Load 30(@gl_NumSubgroups)
+ 33: 19(ptr) AccessChain 17(@gl_NumWorkGroups) 32
+ 34: 8(int) Load 33
+ 35: 8(int) IMul 31 34
+ 36: 8(int) IMul 29 35
+ 37: 19(ptr) AccessChain 22(@gl_WorkGroupID) 32
+ 38: 8(int) Load 37
+ 39: 8(int) IAdd 36 38
+ 41: 8(int) Load 40(@gl_SubgroupID)
+ 42: 8(int) IAdd 39 41
+ 44: 43(ptr) AccessChain 12(data) 14 42
+ Store 44 18
+ Return
+ FunctionEnd
diff --git a/Test/baseResults/hlsl.waveordered.frag.out b/Test/baseResults/hlsl.waveordered.frag.out
new file mode 100644
index 0000000..abe8634
--- /dev/null
+++ b/Test/baseResults/hlsl.waveordered.frag.out
@@ -0,0 +1,86 @@
+hlsl.waveordered.frag
+ERROR: 0:3: 'WaveGetOrderedIndex' : WaveGetOrderedIndex() unsupported in a pixel/fragment shader
+ERROR: 1 compilation errors. No code generated.
+
+
+Shader version: 500
+gl_FragCoord origin is upper left
+ERROR: node is still EOpNull!
+0:2 Function Definition: @PixelShaderFunction( ( temp 4-component vector of float)
+0:2 Function Parameters:
+0:? Sequence
+0:3 Test condition and select ( temp void)
+0:3 Condition
+0:3 Compare Equal ( temp bool)
+0:3 Constant:
+0:3 0 (const uint)
+0:3 ERROR: Bad aggregation op
+ ( temp uint)
+0:3 true case
+0:? Sequence
+0:5 Branch: Return with expression
+0:? Constant:
+0:? 1.000000
+0:? 2.000000
+0:? 3.000000
+0:? 4.000000
+0:3 false case
+0:? Sequence
+0:9 Branch: Return with expression
+0:? Constant:
+0:? 4.000000
+0:? 3.000000
+0:? 2.000000
+0:? 1.000000
+0:2 Function Definition: PixelShaderFunction( ( temp void)
+0:2 Function Parameters:
+0:? Sequence
+0:2 move second child to first child ( temp 4-component vector of float)
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+0:2 Function Call: @PixelShaderFunction( ( temp 4-component vector of float)
+0:? Linker Objects
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+
+
+Linked fragment stage:
+
+
+Shader version: 500
+gl_FragCoord origin is upper left
+ERROR: node is still EOpNull!
+0:2 Function Definition: @PixelShaderFunction( ( temp 4-component vector of float)
+0:2 Function Parameters:
+0:? Sequence
+0:3 Test condition and select ( temp void)
+0:3 Condition
+0:3 Compare Equal ( temp bool)
+0:3 Constant:
+0:3 0 (const uint)
+0:3 ERROR: Bad aggregation op
+ ( temp uint)
+0:3 true case
+0:? Sequence
+0:5 Branch: Return with expression
+0:? Constant:
+0:? 1.000000
+0:? 2.000000
+0:? 3.000000
+0:? 4.000000
+0:3 false case
+0:? Sequence
+0:9 Branch: Return with expression
+0:? Constant:
+0:? 4.000000
+0:? 3.000000
+0:? 2.000000
+0:? 1.000000
+0:2 Function Definition: PixelShaderFunction( ( temp void)
+0:2 Function Parameters:
+0:? Sequence
+0:2 move second child to first child ( temp 4-component vector of float)
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+0:2 Function Call: @PixelShaderFunction( ( temp 4-component vector of float)
+0:? Linker Objects
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/hlsl.waveordered2.comp.out b/Test/baseResults/hlsl.waveordered2.comp.out
new file mode 100644
index 0000000..b6f0d58
--- /dev/null
+++ b/Test/baseResults/hlsl.waveordered2.comp.out
@@ -0,0 +1,68 @@
+hlsl.waveordered2.comp
+ERROR: 0:7: 'GlobalOrderedCountIncrement' : GlobalOrderedCountIncrement() unsupported
+ERROR: 1 compilation errors. No code generated.
+
+
+Shader version: 500
+local_size = (32, 16, 1)
+ERROR: node is still EOpNull!
+0:5 Function Definition: @CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:6 Sequence
+0:6 move second child to first child ( temp uint)
+0:6 'i' ( temp uint)
+0:6 Constant:
+0:6 42 (const uint)
+0:7 move second child to first child ( temp uint)
+0:7 indirect index (layout( row_major std430) buffer uint)
+0:7 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of uint)
+0:7 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+0:7 Constant:
+0:7 0 (const uint)
+0:7 ERROR: Bad unary op
+ ( temp uint)
+0:7 'i' ( temp uint)
+0:7 Constant:
+0:7 1 (const uint)
+0:5 Function Definition: CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:5 Function Call: @CSMain( ( temp void)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+
+
+Linked compute stage:
+
+
+Shader version: 500
+local_size = (32, 16, 1)
+ERROR: node is still EOpNull!
+0:5 Function Definition: @CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:6 Sequence
+0:6 move second child to first child ( temp uint)
+0:6 'i' ( temp uint)
+0:6 Constant:
+0:6 42 (const uint)
+0:7 move second child to first child ( temp uint)
+0:7 indirect index (layout( row_major std430) buffer uint)
+0:7 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of uint)
+0:7 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+0:7 Constant:
+0:7 0 (const uint)
+0:7 ERROR: Bad unary op
+ ( temp uint)
+0:7 'i' ( temp uint)
+0:7 Constant:
+0:7 1 (const uint)
+0:5 Function Definition: CSMain( ( temp void)
+0:5 Function Parameters:
+0:? Sequence
+0:5 Function Call: @CSMain( ( temp void)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of uint @data})
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/hlsl.waveordered2.frag.out b/Test/baseResults/hlsl.waveordered2.frag.out
new file mode 100644
index 0000000..6d44c53
--- /dev/null
+++ b/Test/baseResults/hlsl.waveordered2.frag.out
@@ -0,0 +1,98 @@
+hlsl.waveordered2.frag
+ERROR: 0:4: 'GlobalOrderedCountIncrement' : GlobalOrderedCountIncrement() unsupported
+ERROR: 1 compilation errors. No code generated.
+
+
+Shader version: 500
+gl_FragCoord origin is upper left
+ERROR: node is still EOpNull!
+0:2 Function Definition: @PixelShaderFunction( ( temp 4-component vector of float)
+0:2 Function Parameters:
+0:? Sequence
+0:3 Sequence
+0:3 move second child to first child ( temp uint)
+0:3 'i' ( temp uint)
+0:3 Constant:
+0:3 42 (const uint)
+0:4 Test condition and select ( temp void)
+0:4 Condition
+0:4 Compare Equal ( temp bool)
+0:4 Constant:
+0:4 0 (const uint)
+0:4 ERROR: Bad unary op
+ ( temp uint)
+0:4 'i' ( temp uint)
+0:4 true case
+0:? Sequence
+0:6 Branch: Return with expression
+0:? Constant:
+0:? 1.000000
+0:? 2.000000
+0:? 3.000000
+0:? 4.000000
+0:4 false case
+0:? Sequence
+0:10 Branch: Return with expression
+0:? Constant:
+0:? 4.000000
+0:? 3.000000
+0:? 2.000000
+0:? 1.000000
+0:2 Function Definition: PixelShaderFunction( ( temp void)
+0:2 Function Parameters:
+0:? Sequence
+0:2 move second child to first child ( temp 4-component vector of float)
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+0:2 Function Call: @PixelShaderFunction( ( temp 4-component vector of float)
+0:? Linker Objects
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+
+
+Linked fragment stage:
+
+
+Shader version: 500
+gl_FragCoord origin is upper left
+ERROR: node is still EOpNull!
+0:2 Function Definition: @PixelShaderFunction( ( temp 4-component vector of float)
+0:2 Function Parameters:
+0:? Sequence
+0:3 Sequence
+0:3 move second child to first child ( temp uint)
+0:3 'i' ( temp uint)
+0:3 Constant:
+0:3 42 (const uint)
+0:4 Test condition and select ( temp void)
+0:4 Condition
+0:4 Compare Equal ( temp bool)
+0:4 Constant:
+0:4 0 (const uint)
+0:4 ERROR: Bad unary op
+ ( temp uint)
+0:4 'i' ( temp uint)
+0:4 true case
+0:? Sequence
+0:6 Branch: Return with expression
+0:? Constant:
+0:? 1.000000
+0:? 2.000000
+0:? 3.000000
+0:? 4.000000
+0:4 false case
+0:? Sequence
+0:10 Branch: Return with expression
+0:? Constant:
+0:? 4.000000
+0:? 3.000000
+0:? 2.000000
+0:? 1.000000
+0:2 Function Definition: PixelShaderFunction( ( temp void)
+0:2 Function Parameters:
+0:? Sequence
+0:2 move second child to first child ( temp 4-component vector of float)
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+0:2 Function Call: @PixelShaderFunction( ( temp 4-component vector of float)
+0:? Linker Objects
+0:? '@entryPointOutput' (layout( location=0) out 4-component vector of float)
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/hlsl.waveprefix.comp.out b/Test/baseResults/hlsl.waveprefix.comp.out
new file mode 100644
index 0000000..10ce0f9
--- /dev/null
+++ b/Test/baseResults/hlsl.waveprefix.comp.out
@@ -0,0 +1,2681 @@
+hlsl.waveprefix.comp
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:13 Function Definition: @CSMain(vu3; ( temp void)
+0:13 Function Parameters:
+0:13 'dti' ( in 3-component vector of uint)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 subgroupInclusiveAdd ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:15 move second child to first child ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 subgroupInclusiveAdd ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:16 move second child to first child ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 subgroupInclusiveAdd ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:17 move second child to first child ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 subgroupInclusiveAdd ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:19 move second child to first child ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 subgroupInclusiveAdd ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:20 move second child to first child ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 subgroupInclusiveAdd ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:21 move second child to first child ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 subgroupInclusiveAdd ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:22 move second child to first child ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 subgroupInclusiveAdd ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 subgroupInclusiveAdd ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 subgroupInclusiveAdd ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:26 move second child to first child ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 subgroupInclusiveAdd ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:27 move second child to first child ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 subgroupInclusiveAdd ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:29 move second child to first child ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 subgroupInclusiveAdd ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:30 move second child to first child ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 subgroupInclusiveAdd ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:31 move second child to first child ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 subgroupInclusiveAdd ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:32 move second child to first child ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 subgroupInclusiveAdd ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:34 move second child to first child ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 subgroupInclusiveMul ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:35 move second child to first child ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 subgroupInclusiveMul ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:36 move second child to first child ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 subgroupInclusiveMul ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:37 move second child to first child ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 subgroupInclusiveMul ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:39 move second child to first child ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 subgroupInclusiveMul ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:40 move second child to first child ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 subgroupInclusiveMul ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:41 move second child to first child ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 subgroupInclusiveMul ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:42 move second child to first child ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 subgroupInclusiveMul ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:44 move second child to first child ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 subgroupInclusiveMul ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:45 move second child to first child ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 subgroupInclusiveMul ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:46 move second child to first child ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 subgroupInclusiveMul ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:47 move second child to first child ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 subgroupInclusiveMul ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:49 move second child to first child ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 subgroupInclusiveMul ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:50 move second child to first child ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 subgroupInclusiveMul ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:51 move second child to first child ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 subgroupInclusiveMul ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:52 move second child to first child ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 subgroupInclusiveMul ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:13 Function Definition: CSMain( ( temp void)
+0:13 Function Parameters:
+0:? Sequence
+0:13 move second child to first child ( temp 3-component vector of uint)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+0:13 Function Call: @CSMain(vu3; ( temp void)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+
+
+Linked compute stage:
+
+
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:13 Function Definition: @CSMain(vu3; ( temp void)
+0:13 Function Parameters:
+0:13 'dti' ( in 3-component vector of uint)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 subgroupInclusiveAdd ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:15 move second child to first child ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 subgroupInclusiveAdd ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:16 move second child to first child ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 subgroupInclusiveAdd ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:17 move second child to first child ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 subgroupInclusiveAdd ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:19 move second child to first child ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 subgroupInclusiveAdd ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:20 move second child to first child ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 subgroupInclusiveAdd ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:21 move second child to first child ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 subgroupInclusiveAdd ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:22 move second child to first child ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 subgroupInclusiveAdd ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 subgroupInclusiveAdd ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 subgroupInclusiveAdd ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:26 move second child to first child ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 subgroupInclusiveAdd ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:27 move second child to first child ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 subgroupInclusiveAdd ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:29 move second child to first child ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 subgroupInclusiveAdd ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:30 move second child to first child ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 subgroupInclusiveAdd ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:31 move second child to first child ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 subgroupInclusiveAdd ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:32 move second child to first child ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 subgroupInclusiveAdd ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:34 move second child to first child ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 subgroupInclusiveMul ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:35 move second child to first child ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 subgroupInclusiveMul ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:36 move second child to first child ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 subgroupInclusiveMul ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:37 move second child to first child ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 subgroupInclusiveMul ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:39 move second child to first child ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 subgroupInclusiveMul ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:40 move second child to first child ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 subgroupInclusiveMul ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:41 move second child to first child ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 subgroupInclusiveMul ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:42 move second child to first child ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 subgroupInclusiveMul ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:44 move second child to first child ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 subgroupInclusiveMul ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:45 move second child to first child ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 subgroupInclusiveMul ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:46 move second child to first child ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 subgroupInclusiveMul ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:47 move second child to first child ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 subgroupInclusiveMul ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:49 move second child to first child ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 subgroupInclusiveMul ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:50 move second child to first child ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 subgroupInclusiveMul ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:51 move second child to first child ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 subgroupInclusiveMul ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:52 move second child to first child ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 subgroupInclusiveMul ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:13 Function Definition: CSMain( ( temp void)
+0:13 Function Parameters:
+0:? Sequence
+0:13 move second child to first child ( temp 3-component vector of uint)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+0:13 Function Call: @CSMain(vu3; ( temp void)
+0:? 'dti' ( temp 3-component vector of uint)
+0:? Linker Objects
+0:? 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:? 'dti' ( in 3-component vector of uint GlobalInvocationID)
+
+// Module Version 10000
+// Generated by (magic number): 80002
+// Id's are bound by 358
+
+ Capability Shader
+ Capability Float64
+ Capability GroupNonUniform
+ Capability GroupNonUniformArithmetic
+ 1: ExtInstImport "GLSL.std.450"
+ MemoryModel Logical GLSL450
+ EntryPoint GLCompute 4 "CSMain" 353
+ ExecutionMode 4 LocalSize 32 16 1
+ Source HLSL 500
+ Name 4 "CSMain"
+ Name 11 "@CSMain(vu3;"
+ Name 10 "dti"
+ Name 20 "Types"
+ MemberName 20(Types) 0 "u"
+ MemberName 20(Types) 1 "i"
+ MemberName 20(Types) 2 "f"
+ MemberName 20(Types) 3 "d"
+ Name 22 "data"
+ MemberName 22(data) 0 "@data"
+ Name 24 "data"
+ Name 351 "dti"
+ Name 353 "dti"
+ Name 355 "param"
+ MemberDecorate 20(Types) 0 Offset 0
+ MemberDecorate 20(Types) 1 Offset 16
+ MemberDecorate 20(Types) 2 Offset 32
+ MemberDecorate 20(Types) 3 Offset 64
+ Decorate 21 ArrayStride 96
+ MemberDecorate 22(data) 0 Offset 0
+ Decorate 22(data) BufferBlock
+ Decorate 24(data) DescriptorSet 0
+ Decorate 353(dti) BuiltIn GlobalInvocationId
+ 2: TypeVoid
+ 3: TypeFunction 2
+ 6: TypeInt 32 0
+ 7: TypeVector 6(int) 3
+ 8: TypePointer Function 7(ivec3)
+ 9: TypeFunction 2 8(ptr)
+ 13: TypeVector 6(int) 4
+ 14: TypeInt 32 1
+ 15: TypeVector 14(int) 4
+ 16: TypeFloat 32
+ 17: TypeVector 16(float) 4
+ 18: TypeFloat 64
+ 19: TypeVector 18(float) 4
+ 20(Types): TypeStruct 13(ivec4) 15(ivec4) 17(fvec4) 19(fvec4)
+ 21: TypeRuntimeArray 20(Types)
+ 22(data): TypeStruct 21
+ 23: TypePointer Uniform 22(data)
+ 24(data): 23(ptr) Variable Uniform
+ 25: 14(int) Constant 0
+ 26: 6(int) Constant 0
+ 27: TypePointer Function 6(int)
+ 32: TypePointer Uniform 13(ivec4)
+ 35: 6(int) Constant 3
+ 42: TypePointer Uniform 6(int)
+ 51: TypeVector 6(int) 2
+ 72: 14(int) Constant 1
+ 75: TypePointer Uniform 15(ivec4)
+ 84: TypePointer Uniform 14(int)
+ 93: TypeVector 14(int) 2
+ 105: TypeVector 14(int) 3
+ 115: 14(int) Constant 2
+ 118: TypePointer Uniform 17(fvec4)
+ 127: TypePointer Uniform 16(float)
+ 136: TypeVector 16(float) 2
+ 148: TypeVector 16(float) 3
+ 158: 14(int) Constant 3
+ 161: TypePointer Uniform 19(fvec4)
+ 170: TypePointer Uniform 18(float)
+ 179: TypeVector 18(float) 2
+ 191: TypeVector 18(float) 3
+ 352: TypePointer Input 7(ivec3)
+ 353(dti): 352(ptr) Variable Input
+ 4(CSMain): 2 Function None 3
+ 5: Label
+ 351(dti): 8(ptr) Variable Function
+ 355(param): 8(ptr) Variable Function
+ 354: 7(ivec3) Load 353(dti)
+ Store 351(dti) 354
+ 356: 7(ivec3) Load 351(dti)
+ Store 355(param) 356
+ 357: 2 FunctionCall 11(@CSMain(vu3;) 355(param)
+ Return
+ FunctionEnd
+11(@CSMain(vu3;): 2 Function None 9
+ 10(dti): 8(ptr) FunctionParameter
+ 12: Label
+ 28: 27(ptr) AccessChain 10(dti) 26
+ 29: 6(int) Load 28
+ 30: 27(ptr) AccessChain 10(dti) 26
+ 31: 6(int) Load 30
+ 33: 32(ptr) AccessChain 24(data) 25 31 25
+ 34: 13(ivec4) Load 33
+ 36: 13(ivec4) GroupNonUniformIAdd 35 InclusiveScan 34
+ 37: 32(ptr) AccessChain 24(data) 25 29 25
+ Store 37 36
+ 38: 27(ptr) AccessChain 10(dti) 26
+ 39: 6(int) Load 38
+ 40: 27(ptr) AccessChain 10(dti) 26
+ 41: 6(int) Load 40
+ 43: 42(ptr) AccessChain 24(data) 25 41 25 26
+ 44: 6(int) Load 43
+ 45: 6(int) GroupNonUniformIAdd 35 InclusiveScan 44
+ 46: 42(ptr) AccessChain 24(data) 25 39 25 26
+ Store 46 45
+ 47: 27(ptr) AccessChain 10(dti) 26
+ 48: 6(int) Load 47
+ 49: 27(ptr) AccessChain 10(dti) 26
+ 50: 6(int) Load 49
+ 52: 32(ptr) AccessChain 24(data) 25 50 25
+ 53: 13(ivec4) Load 52
+ 54: 51(ivec2) VectorShuffle 53 53 0 1
+ 55: 51(ivec2) GroupNonUniformIAdd 35 InclusiveScan 54
+ 56: 32(ptr) AccessChain 24(data) 25 48 25
+ 57: 13(ivec4) Load 56
+ 58: 13(ivec4) VectorShuffle 57 55 4 5 2 3
+ Store 56 58
+ 59: 27(ptr) AccessChain 10(dti) 26
+ 60: 6(int) Load 59
+ 61: 27(ptr) AccessChain 10(dti) 26
+ 62: 6(int) Load 61
+ 63: 32(ptr) AccessChain 24(data) 25 62 25
+ 64: 13(ivec4) Load 63
+ 65: 7(ivec3) VectorShuffle 64 64 0 1 2
+ 66: 7(ivec3) GroupNonUniformIAdd 35 InclusiveScan 65
+ 67: 32(ptr) AccessChain 24(data) 25 60 25
+ 68: 13(ivec4) Load 67
+ 69: 13(ivec4) VectorShuffle 68 66 4 5 6 3
+ Store 67 69
+ 70: 27(ptr) AccessChain 10(dti) 26
+ 71: 6(int) Load 70
+ 73: 27(ptr) AccessChain 10(dti) 26
+ 74: 6(int) Load 73
+ 76: 75(ptr) AccessChain 24(data) 25 74 72
+ 77: 15(ivec4) Load 76
+ 78: 15(ivec4) GroupNonUniformIAdd 35 InclusiveScan 77
+ 79: 75(ptr) AccessChain 24(data) 25 71 72
+ Store 79 78
+ 80: 27(ptr) AccessChain 10(dti) 26
+ 81: 6(int) Load 80
+ 82: 27(ptr) AccessChain 10(dti) 26
+ 83: 6(int) Load 82
+ 85: 84(ptr) AccessChain 24(data) 25 83 72 26
+ 86: 14(int) Load 85
+ 87: 14(int) GroupNonUniformIAdd 35 InclusiveScan 86
+ 88: 84(ptr) AccessChain 24(data) 25 81 72 26
+ Store 88 87
+ 89: 27(ptr) AccessChain 10(dti) 26
+ 90: 6(int) Load 89
+ 91: 27(ptr) AccessChain 10(dti) 26
+ 92: 6(int) Load 91
+ 94: 75(ptr) AccessChain 24(data) 25 92 72
+ 95: 15(ivec4) Load 94
+ 96: 93(ivec2) VectorShuffle 95 95 0 1
+ 97: 93(ivec2) GroupNonUniformIAdd 35 InclusiveScan 96
+ 98: 75(ptr) AccessChain 24(data) 25 90 72
+ 99: 15(ivec4) Load 98
+ 100: 15(ivec4) VectorShuffle 99 97 4 5 2 3
+ Store 98 100
+ 101: 27(ptr) AccessChain 10(dti) 26
+ 102: 6(int) Load 101
+ 103: 27(ptr) AccessChain 10(dti) 26
+ 104: 6(int) Load 103
+ 106: 75(ptr) AccessChain 24(data) 25 104 72
+ 107: 15(ivec4) Load 106
+ 108: 105(ivec3) VectorShuffle 107 107 0 1 2
+ 109: 105(ivec3) GroupNonUniformIAdd 35 InclusiveScan 108
+ 110: 75(ptr) AccessChain 24(data) 25 102 72
+ 111: 15(ivec4) Load 110
+ 112: 15(ivec4) VectorShuffle 111 109 4 5 6 3
+ Store 110 112
+ 113: 27(ptr) AccessChain 10(dti) 26
+ 114: 6(int) Load 113
+ 116: 27(ptr) AccessChain 10(dti) 26
+ 117: 6(int) Load 116
+ 119: 118(ptr) AccessChain 24(data) 25 117 115
+ 120: 17(fvec4) Load 119
+ 121: 17(fvec4) GroupNonUniformFAdd 35 InclusiveScan 120
+ 122: 118(ptr) AccessChain 24(data) 25 114 115
+ Store 122 121
+ 123: 27(ptr) AccessChain 10(dti) 26
+ 124: 6(int) Load 123
+ 125: 27(ptr) AccessChain 10(dti) 26
+ 126: 6(int) Load 125
+ 128: 127(ptr) AccessChain 24(data) 25 126 115 26
+ 129: 16(float) Load 128
+ 130: 16(float) GroupNonUniformFAdd 35 InclusiveScan 129
+ 131: 127(ptr) AccessChain 24(data) 25 124 115 26
+ Store 131 130
+ 132: 27(ptr) AccessChain 10(dti) 26
+ 133: 6(int) Load 132
+ 134: 27(ptr) AccessChain 10(dti) 26
+ 135: 6(int) Load 134
+ 137: 118(ptr) AccessChain 24(data) 25 135 115
+ 138: 17(fvec4) Load 137
+ 139: 136(fvec2) VectorShuffle 138 138 0 1
+ 140: 136(fvec2) GroupNonUniformFAdd 35 InclusiveScan 139
+ 141: 118(ptr) AccessChain 24(data) 25 133 115
+ 142: 17(fvec4) Load 141
+ 143: 17(fvec4) VectorShuffle 142 140 4 5 2 3
+ Store 141 143
+ 144: 27(ptr) AccessChain 10(dti) 26
+ 145: 6(int) Load 144
+ 146: 27(ptr) AccessChain 10(dti) 26
+ 147: 6(int) Load 146
+ 149: 118(ptr) AccessChain 24(data) 25 147 115
+ 150: 17(fvec4) Load 149
+ 151: 148(fvec3) VectorShuffle 150 150 0 1 2
+ 152: 148(fvec3) GroupNonUniformFAdd 35 InclusiveScan 151
+ 153: 118(ptr) AccessChain 24(data) 25 145 115
+ 154: 17(fvec4) Load 153
+ 155: 17(fvec4) VectorShuffle 154 152 4 5 6 3
+ Store 153 155
+ 156: 27(ptr) AccessChain 10(dti) 26
+ 157: 6(int) Load 156
+ 159: 27(ptr) AccessChain 10(dti) 26
+ 160: 6(int) Load 159
+ 162: 161(ptr) AccessChain 24(data) 25 160 158
+ 163: 19(fvec4) Load 162
+ 164: 19(fvec4) GroupNonUniformFAdd 35 InclusiveScan 163
+ 165: 161(ptr) AccessChain 24(data) 25 157 158
+ Store 165 164
+ 166: 27(ptr) AccessChain 10(dti) 26
+ 167: 6(int) Load 166
+ 168: 27(ptr) AccessChain 10(dti) 26
+ 169: 6(int) Load 168
+ 171: 170(ptr) AccessChain 24(data) 25 169 158 26
+ 172: 18(float) Load 171
+ 173: 18(float) GroupNonUniformFAdd 35 InclusiveScan 172
+ 174: 170(ptr) AccessChain 24(data) 25 167 158 26
+ Store 174 173
+ 175: 27(ptr) AccessChain 10(dti) 26
+ 176: 6(int) Load 175
+ 177: 27(ptr) AccessChain 10(dti) 26
+ 178: 6(int) Load 177
+ 180: 161(ptr) AccessChain 24(data) 25 178 158
+ 181: 19(fvec4) Load 180
+ 182: 179(fvec2) VectorShuffle 181 181 0 1
+ 183: 179(fvec2) GroupNonUniformFAdd 35 InclusiveScan 182
+ 184: 161(ptr) AccessChain 24(data) 25 176 158
+ 185: 19(fvec4) Load 184
+ 186: 19(fvec4) VectorShuffle 185 183 4 5 2 3
+ Store 184 186
+ 187: 27(ptr) AccessChain 10(dti) 26
+ 188: 6(int) Load 187
+ 189: 27(ptr) AccessChain 10(dti) 26
+ 190: 6(int) Load 189
+ 192: 161(ptr) AccessChain 24(data) 25 190 158
+ 193: 19(fvec4) Load 192
+ 194: 191(fvec3) VectorShuffle 193 193 0 1 2
+ 195: 191(fvec3) GroupNonUniformFAdd 35 InclusiveScan 194
+ 196: 161(ptr) AccessChain 24(data) 25 188 158
+ 197: 19(fvec4) Load 196
+ 198: 19(fvec4) VectorShuffle 197 195 4 5 6 3
+ Store 196 198
+ 199: 27(ptr) AccessChain 10(dti) 26
+ 200: 6(int) Load 199
+ 201: 27(ptr) AccessChain 10(dti) 26
+ 202: 6(int) Load 201
+ 203: 32(ptr) AccessChain 24(data) 25 202 25
+ 204: 13(ivec4) Load 203
+ 205: 13(ivec4) GroupNonUniformIMul 35 InclusiveScan 204
+ 206: 32(ptr) AccessChain 24(data) 25 200 25
+ Store 206 205
+ 207: 27(ptr) AccessChain 10(dti) 26
+ 208: 6(int) Load 207
+ 209: 27(ptr) AccessChain 10(dti) 26
+ 210: 6(int) Load 209
+ 211: 42(ptr) AccessChain 24(data) 25 210 25 26
+ 212: 6(int) Load 211
+ 213: 6(int) GroupNonUniformIMul 35 InclusiveScan 212
+ 214: 42(ptr) AccessChain 24(data) 25 208 25 26
+ Store 214 213
+ 215: 27(ptr) AccessChain 10(dti) 26
+ 216: 6(int) Load 215
+ 217: 27(ptr) AccessChain 10(dti) 26
+ 218: 6(int) Load 217
+ 219: 32(ptr) AccessChain 24(data) 25 218 25
+ 220: 13(ivec4) Load 219
+ 221: 51(ivec2) VectorShuffle 220 220 0 1
+ 222: 51(ivec2) GroupNonUniformIMul 35 InclusiveScan 221
+ 223: 32(ptr) AccessChain 24(data) 25 216 25
+ 224: 13(ivec4) Load 223
+ 225: 13(ivec4) VectorShuffle 224 222 4 5 2 3
+ Store 223 225
+ 226: 27(ptr) AccessChain 10(dti) 26
+ 227: 6(int) Load 226
+ 228: 27(ptr) AccessChain 10(dti) 26
+ 229: 6(int) Load 228
+ 230: 32(ptr) AccessChain 24(data) 25 229 25
+ 231: 13(ivec4) Load 230
+ 232: 7(ivec3) VectorShuffle 231 231 0 1 2
+ 233: 7(ivec3) GroupNonUniformIMul 35 InclusiveScan 232
+ 234: 32(ptr) AccessChain 24(data) 25 227 25
+ 235: 13(ivec4) Load 234
+ 236: 13(ivec4) VectorShuffle 235 233 4 5 6 3
+ Store 234 236
+ 237: 27(ptr) AccessChain 10(dti) 26
+ 238: 6(int) Load 237
+ 239: 27(ptr) AccessChain 10(dti) 26
+ 240: 6(int) Load 239
+ 241: 75(ptr) AccessChain 24(data) 25 240 72
+ 242: 15(ivec4) Load 241
+ 243: 15(ivec4) GroupNonUniformIMul 35 InclusiveScan 242
+ 244: 75(ptr) AccessChain 24(data) 25 238 72
+ Store 244 243
+ 245: 27(ptr) AccessChain 10(dti) 26
+ 246: 6(int) Load 245
+ 247: 27(ptr) AccessChain 10(dti) 26
+ 248: 6(int) Load 247
+ 249: 84(ptr) AccessChain 24(data) 25 248 72 26
+ 250: 14(int) Load 249
+ 251: 14(int) GroupNonUniformIMul 35 InclusiveScan 250
+ 252: 84(ptr) AccessChain 24(data) 25 246 72 26
+ Store 252 251
+ 253: 27(ptr) AccessChain 10(dti) 26
+ 254: 6(int) Load 253
+ 255: 27(ptr) AccessChain 10(dti) 26
+ 256: 6(int) Load 255
+ 257: 75(ptr) AccessChain 24(data) 25 256 72
+ 258: 15(ivec4) Load 257
+ 259: 93(ivec2) VectorShuffle 258 258 0 1
+ 260: 93(ivec2) GroupNonUniformIMul 35 InclusiveScan 259
+ 261: 75(ptr) AccessChain 24(data) 25 254 72
+ 262: 15(ivec4) Load 261
+ 263: 15(ivec4) VectorShuffle 262 260 4 5 2 3
+ Store 261 263
+ 264: 27(ptr) AccessChain 10(dti) 26
+ 265: 6(int) Load 264
+ 266: 27(ptr) AccessChain 10(dti) 26
+ 267: 6(int) Load 266
+ 268: 75(ptr) AccessChain 24(data) 25 267 72
+ 269: 15(ivec4) Load 268
+ 270: 105(ivec3) VectorShuffle 269 269 0 1 2
+ 271: 105(ivec3) GroupNonUniformIMul 35 InclusiveScan 270
+ 272: 75(ptr) AccessChain 24(data) 25 265 72
+ 273: 15(ivec4) Load 272
+ 274: 15(ivec4) VectorShuffle 273 271 4 5 6 3
+ Store 272 274
+ 275: 27(ptr) AccessChain 10(dti) 26
+ 276: 6(int) Load 275
+ 277: 27(ptr) AccessChain 10(dti) 26
+ 278: 6(int) Load 277
+ 279: 118(ptr) AccessChain 24(data) 25 278 115
+ 280: 17(fvec4) Load 279
+ 281: 17(fvec4) GroupNonUniformFMul 35 InclusiveScan 280
+ 282: 118(ptr) AccessChain 24(data) 25 276 115
+ Store 282 281
+ 283: 27(ptr) AccessChain 10(dti) 26
+ 284: 6(int) Load 283
+ 285: 27(ptr) AccessChain 10(dti) 26
+ 286: 6(int) Load 285
+ 287: 127(ptr) AccessChain 24(data) 25 286 115 26
+ 288: 16(float) Load 287
+ 289: 16(float) GroupNonUniformFMul 35 InclusiveScan 288
+ 290: 127(ptr) AccessChain 24(data) 25 284 115 26
+ Store 290 289
+ 291: 27(ptr) AccessChain 10(dti) 26
+ 292: 6(int) Load 291
+ 293: 27(ptr) AccessChain 10(dti) 26
+ 294: 6(int) Load 293
+ 295: 118(ptr) AccessChain 24(data) 25 294 115
+ 296: 17(fvec4) Load 295
+ 297: 136(fvec2) VectorShuffle 296 296 0 1
+ 298: 136(fvec2) GroupNonUniformFMul 35 InclusiveScan 297
+ 299: 118(ptr) AccessChain 24(data) 25 292 115
+ 300: 17(fvec4) Load 299
+ 301: 17(fvec4) VectorShuffle 300 298 4 5 2 3
+ Store 299 301
+ 302: 27(ptr) AccessChain 10(dti) 26
+ 303: 6(int) Load 302
+ 304: 27(ptr) AccessChain 10(dti) 26
+ 305: 6(int) Load 304
+ 306: 118(ptr) AccessChain 24(data) 25 305 115
+ 307: 17(fvec4) Load 306
+ 308: 148(fvec3) VectorShuffle 307 307 0 1 2
+ 309: 148(fvec3) GroupNonUniformFMul 35 InclusiveScan 308
+ 310: 118(ptr) AccessChain 24(data) 25 303 115
+ 311: 17(fvec4) Load 310
+ 312: 17(fvec4) VectorShuffle 311 309 4 5 6 3
+ Store 310 312
+ 313: 27(ptr) AccessChain 10(dti) 26
+ 314: 6(int) Load 313
+ 315: 27(ptr) AccessChain 10(dti) 26
+ 316: 6(int) Load 315
+ 317: 161(ptr) AccessChain 24(data) 25 316 158
+ 318: 19(fvec4) Load 317
+ 319: 19(fvec4) GroupNonUniformFMul 35 InclusiveScan 318
+ 320: 161(ptr) AccessChain 24(data) 25 314 158
+ Store 320 319
+ 321: 27(ptr) AccessChain 10(dti) 26
+ 322: 6(int) Load 321
+ 323: 27(ptr) AccessChain 10(dti) 26
+ 324: 6(int) Load 323
+ 325: 170(ptr) AccessChain 24(data) 25 324 158 26
+ 326: 18(float) Load 325
+ 327: 18(float) GroupNonUniformFMul 35 InclusiveScan 326
+ 328: 170(ptr) AccessChain 24(data) 25 322 158 26
+ Store 328 327
+ 329: 27(ptr) AccessChain 10(dti) 26
+ 330: 6(int) Load 329
+ 331: 27(ptr) AccessChain 10(dti) 26
+ 332: 6(int) Load 331
+ 333: 161(ptr) AccessChain 24(data) 25 332 158
+ 334: 19(fvec4) Load 333
+ 335: 179(fvec2) VectorShuffle 334 334 0 1
+ 336: 179(fvec2) GroupNonUniformFMul 35 InclusiveScan 335
+ 337: 161(ptr) AccessChain 24(data) 25 330 158
+ 338: 19(fvec4) Load 337
+ 339: 19(fvec4) VectorShuffle 338 336 4 5 2 3
+ Store 337 339
+ 340: 27(ptr) AccessChain 10(dti) 26
+ 341: 6(int) Load 340
+ 342: 27(ptr) AccessChain 10(dti) 26
+ 343: 6(int) Load 342
+ 344: 161(ptr) AccessChain 24(data) 25 343 158
+ 345: 19(fvec4) Load 344
+ 346: 191(fvec3) VectorShuffle 345 345 0 1 2
+ 347: 191(fvec3) GroupNonUniformFMul 35 InclusiveScan 346
+ 348: 161(ptr) AccessChain 24(data) 25 341 158
+ 349: 19(fvec4) Load 348
+ 350: 19(fvec4) VectorShuffle 349 347 4 5 6 3
+ Store 348 350
+ Return
+ FunctionEnd
diff --git a/Test/baseResults/hlsl.wavequad.comp.out b/Test/baseResults/hlsl.wavequad.comp.out
new file mode 100644
index 0000000..79d16d3
--- /dev/null
+++ b/Test/baseResults/hlsl.wavequad.comp.out
@@ -0,0 +1,8027 @@
+hlsl.wavequad.comp
+Shader version: 500
+local_size = (32, 16, 1)
+0:? Sequence
+0:13 Function Definition: @CSMain(vu3; ( temp void)
+0:13 Function Parameters:
+0:13 'dti' ( in 3-component vector of uint)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 subgroupQuadBroadcast ( temp 4-component vector of uint)
+0:14 u: direct index for structure ( temp 4-component vector of uint)
+0:14 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:14 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 direct index ( temp uint)
+0:14 'dti' ( in 3-component vector of uint)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const int)
+0:14 Constant:
+0:14 0 (const uint)
+0:15 move second child to first child ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 subgroupQuadBroadcast ( temp uint)
+0:15 direct index ( temp uint)
+0:15 u: direct index for structure ( temp 4-component vector of uint)
+0:15 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:15 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 direct index ( temp uint)
+0:15 'dti' ( in 3-component vector of uint)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const int)
+0:15 Constant:
+0:15 0 (const uint)
+0:16 move second child to first child ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 subgroupQuadBroadcast ( temp 2-component vector of uint)
+0:16 vector swizzle ( temp 2-component vector of uint)
+0:16 u: direct index for structure ( temp 4-component vector of uint)
+0:16 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:16 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 direct index ( temp uint)
+0:16 'dti' ( in 3-component vector of uint)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 0 (const int)
+0:16 Sequence
+0:16 Constant:
+0:16 0 (const int)
+0:16 Constant:
+0:16 1 (const int)
+0:16 Constant:
+0:16 0 (const uint)
+0:17 move second child to first child ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 subgroupQuadBroadcast ( temp 3-component vector of uint)
+0:17 vector swizzle ( temp 3-component vector of uint)
+0:17 u: direct index for structure ( temp 4-component vector of uint)
+0:17 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:17 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 direct index ( temp uint)
+0:17 'dti' ( in 3-component vector of uint)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 0 (const int)
+0:17 Sequence
+0:17 Constant:
+0:17 0 (const int)
+0:17 Constant:
+0:17 1 (const int)
+0:17 Constant:
+0:17 2 (const int)
+0:17 Constant:
+0:17 0 (const uint)
+0:19 move second child to first child ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 subgroupQuadBroadcast ( temp 4-component vector of int)
+0:19 i: direct index for structure ( temp 4-component vector of int)
+0:19 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:19 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:19 Constant:
+0:19 0 (const uint)
+0:19 direct index ( temp uint)
+0:19 'dti' ( in 3-component vector of uint)
+0:19 Constant:
+0:19 0 (const int)
+0:19 Constant:
+0:19 1 (const int)
+0:19 Constant:
+0:19 0 (const uint)
+0:20 move second child to first child ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 subgroupQuadBroadcast ( temp int)
+0:20 direct index ( temp int)
+0:20 i: direct index for structure ( temp 4-component vector of int)
+0:20 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:20 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:20 Constant:
+0:20 0 (const uint)
+0:20 direct index ( temp uint)
+0:20 'dti' ( in 3-component vector of uint)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 0 (const int)
+0:20 Constant:
+0:20 0 (const uint)
+0:21 move second child to first child ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 subgroupQuadBroadcast ( temp 2-component vector of int)
+0:21 vector swizzle ( temp 2-component vector of int)
+0:21 i: direct index for structure ( temp 4-component vector of int)
+0:21 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:21 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:21 Constant:
+0:21 0 (const uint)
+0:21 direct index ( temp uint)
+0:21 'dti' ( in 3-component vector of uint)
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Sequence
+0:21 Constant:
+0:21 0 (const int)
+0:21 Constant:
+0:21 1 (const int)
+0:21 Constant:
+0:21 0 (const uint)
+0:22 move second child to first child ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 subgroupQuadBroadcast ( temp 3-component vector of int)
+0:22 vector swizzle ( temp 3-component vector of int)
+0:22 i: direct index for structure ( temp 4-component vector of int)
+0:22 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:22 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:22 Constant:
+0:22 0 (const uint)
+0:22 direct index ( temp uint)
+0:22 'dti' ( in 3-component vector of uint)
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Sequence
+0:22 Constant:
+0:22 0 (const int)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 2 (const int)
+0:22 Constant:
+0:22 0 (const uint)
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 subgroupQuadBroadcast ( temp 4-component vector of float)
+0:24 f: direct index for structure ( temp 4-component vector of float)
+0:24 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:24 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:24 Constant:
+0:24 0 (const uint)
+0:24 direct index ( temp uint)
+0:24 'dti' ( in 3-component vector of uint)
+0:24 Constant:
+0:24 0 (const int)
+0:24 Constant:
+0:24 2 (const int)
+0:24 Constant:
+0:24 0 (const uint)
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 subgroupQuadBroadcast ( temp float)
+0:25 direct index ( temp float)
+0:25 f: direct index for structure ( temp 4-component vector of float)
+0:25 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:25 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:25 Constant:
+0:25 0 (const uint)
+0:25 direct index ( temp uint)
+0:25 'dti' ( in 3-component vector of uint)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 2 (const int)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 0 (const uint)
+0:26 move second child to first child ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 subgroupQuadBroadcast ( temp 2-component vector of float)
+0:26 vector swizzle ( temp 2-component vector of float)
+0:26 f: direct index for structure ( temp 4-component vector of float)
+0:26 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:26 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:26 Constant:
+0:26 0 (const uint)
+0:26 direct index ( temp uint)
+0:26 'dti' ( in 3-component vector of uint)
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 2 (const int)
+0:26 Sequence
+0:26 Constant:
+0:26 0 (const int)
+0:26 Constant:
+0:26 1 (const int)
+0:26 Constant:
+0:26 0 (const uint)
+0:27 move second child to first child ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 subgroupQuadBroadcast ( temp 3-component vector of float)
+0:27 vector swizzle ( temp 3-component vector of float)
+0:27 f: direct index for structure ( temp 4-component vector of float)
+0:27 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:27 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:27 Constant:
+0:27 0 (const uint)
+0:27 direct index ( temp uint)
+0:27 'dti' ( in 3-component vector of uint)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Sequence
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 1 (const int)
+0:27 Constant:
+0:27 2 (const int)
+0:27 Constant:
+0:27 0 (const uint)
+0:29 move second child to first child ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 subgroupQuadBroadcast ( temp 4-component vector of double)
+0:29 d: direct index for structure ( temp 4-component vector of double)
+0:29 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:29 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:29 Constant:
+0:29 0 (const uint)
+0:29 direct index ( temp uint)
+0:29 'dti' ( in 3-component vector of uint)
+0:29 Constant:
+0:29 0 (const int)
+0:29 Constant:
+0:29 3 (const int)
+0:29 Constant:
+0:29 0 (const uint)
+0:30 move second child to first child ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 subgroupQuadBroadcast ( temp double)
+0:30 direct index ( temp double)
+0:30 d: direct index for structure ( temp 4-component vector of double)
+0:30 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:30 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:30 Constant:
+0:30 0 (const uint)
+0:30 direct index ( temp uint)
+0:30 'dti' ( in 3-component vector of uint)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0 (const int)
+0:30 Constant:
+0:30 0 (const uint)
+0:31 move second child to first child ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 subgroupQuadBroadcast ( temp 2-component vector of double)
+0:31 vector swizzle ( temp 2-component vector of double)
+0:31 d: direct index for structure ( temp 4-component vector of double)
+0:31 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:31 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:31 Constant:
+0:31 0 (const uint)
+0:31 direct index ( temp uint)
+0:31 'dti' ( in 3-component vector of uint)
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 3 (const int)
+0:31 Sequence
+0:31 Constant:
+0:31 0 (const int)
+0:31 Constant:
+0:31 1 (const int)
+0:31 Constant:
+0:31 0 (const uint)
+0:32 move second child to first child ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 subgroupQuadBroadcast ( temp 3-component vector of double)
+0:32 vector swizzle ( temp 3-component vector of double)
+0:32 d: direct index for structure ( temp 4-component vector of double)
+0:32 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:32 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:32 Constant:
+0:32 0 (const uint)
+0:32 direct index ( temp uint)
+0:32 'dti' ( in 3-component vector of uint)
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 3 (const int)
+0:32 Sequence
+0:32 Constant:
+0:32 0 (const int)
+0:32 Constant:
+0:32 1 (const int)
+0:32 Constant:
+0:32 2 (const int)
+0:32 Constant:
+0:32 0 (const uint)
+0:34 move second child to first child ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 subgroupQuadBroadcast ( temp 4-component vector of uint)
+0:34 u: direct index for structure ( temp 4-component vector of uint)
+0:34 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:34 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:34 Constant:
+0:34 0 (const uint)
+0:34 direct index ( temp uint)
+0:34 'dti' ( in 3-component vector of uint)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 0 (const int)
+0:34 Constant:
+0:34 1 (const uint)
+0:35 move second child to first child ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 subgroupQuadBroadcast ( temp uint)
+0:35 direct index ( temp uint)
+0:35 u: direct index for structure ( temp 4-component vector of uint)
+0:35 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:35 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:35 Constant:
+0:35 0 (const uint)
+0:35 direct index ( temp uint)
+0:35 'dti' ( in 3-component vector of uint)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 0 (const int)
+0:35 Constant:
+0:35 1 (const uint)
+0:36 move second child to first child ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 subgroupQuadBroadcast ( temp 2-component vector of uint)
+0:36 vector swizzle ( temp 2-component vector of uint)
+0:36 u: direct index for structure ( temp 4-component vector of uint)
+0:36 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:36 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:36 Constant:
+0:36 0 (const uint)
+0:36 direct index ( temp uint)
+0:36 'dti' ( in 3-component vector of uint)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 0 (const int)
+0:36 Sequence
+0:36 Constant:
+0:36 0 (const int)
+0:36 Constant:
+0:36 1 (const int)
+0:36 Constant:
+0:36 1 (const uint)
+0:37 move second child to first child ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 subgroupQuadBroadcast ( temp 3-component vector of uint)
+0:37 vector swizzle ( temp 3-component vector of uint)
+0:37 u: direct index for structure ( temp 4-component vector of uint)
+0:37 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:37 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:37 Constant:
+0:37 0 (const uint)
+0:37 direct index ( temp uint)
+0:37 'dti' ( in 3-component vector of uint)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 0 (const int)
+0:37 Sequence
+0:37 Constant:
+0:37 0 (const int)
+0:37 Constant:
+0:37 1 (const int)
+0:37 Constant:
+0:37 2 (const int)
+0:37 Constant:
+0:37 1 (const uint)
+0:39 move second child to first child ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 subgroupQuadBroadcast ( temp 4-component vector of int)
+0:39 i: direct index for structure ( temp 4-component vector of int)
+0:39 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:39 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:39 Constant:
+0:39 0 (const uint)
+0:39 direct index ( temp uint)
+0:39 'dti' ( in 3-component vector of uint)
+0:39 Constant:
+0:39 0 (const int)
+0:39 Constant:
+0:39 1 (const int)
+0:39 Constant:
+0:39 1 (const uint)
+0:40 move second child to first child ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 subgroupQuadBroadcast ( temp int)
+0:40 direct index ( temp int)
+0:40 i: direct index for structure ( temp 4-component vector of int)
+0:40 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:40 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:40 Constant:
+0:40 0 (const uint)
+0:40 direct index ( temp uint)
+0:40 'dti' ( in 3-component vector of uint)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const int)
+0:40 Constant:
+0:40 0 (const int)
+0:40 Constant:
+0:40 1 (const uint)
+0:41 move second child to first child ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 subgroupQuadBroadcast ( temp 2-component vector of int)
+0:41 vector swizzle ( temp 2-component vector of int)
+0:41 i: direct index for structure ( temp 4-component vector of int)
+0:41 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:41 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:41 Constant:
+0:41 0 (const uint)
+0:41 direct index ( temp uint)
+0:41 'dti' ( in 3-component vector of uint)
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Sequence
+0:41 Constant:
+0:41 0 (const int)
+0:41 Constant:
+0:41 1 (const int)
+0:41 Constant:
+0:41 1 (const uint)
+0:42 move second child to first child ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 subgroupQuadBroadcast ( temp 3-component vector of int)
+0:42 vector swizzle ( temp 3-component vector of int)
+0:42 i: direct index for structure ( temp 4-component vector of int)
+0:42 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:42 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:42 Constant:
+0:42 0 (const uint)
+0:42 direct index ( temp uint)
+0:42 'dti' ( in 3-component vector of uint)
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Sequence
+0:42 Constant:
+0:42 0 (const int)
+0:42 Constant:
+0:42 1 (const int)
+0:42 Constant:
+0:42 2 (const int)
+0:42 Constant:
+0:42 1 (const uint)
+0:44 move second child to first child ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 subgroupQuadBroadcast ( temp 4-component vector of float)
+0:44 f: direct index for structure ( temp 4-component vector of float)
+0:44 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:44 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:44 Constant:
+0:44 0 (const uint)
+0:44 direct index ( temp uint)
+0:44 'dti' ( in 3-component vector of uint)
+0:44 Constant:
+0:44 0 (const int)
+0:44 Constant:
+0:44 2 (const int)
+0:44 Constant:
+0:44 1 (const uint)
+0:45 move second child to first child ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 subgroupQuadBroadcast ( temp float)
+0:45 direct index ( temp float)
+0:45 f: direct index for structure ( temp 4-component vector of float)
+0:45 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:45 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:45 Constant:
+0:45 0 (const uint)
+0:45 direct index ( temp uint)
+0:45 'dti' ( in 3-component vector of uint)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 2 (const int)
+0:45 Constant:
+0:45 0 (const int)
+0:45 Constant:
+0:45 1 (const uint)
+0:46 move second child to first child ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 subgroupQuadBroadcast ( temp 2-component vector of float)
+0:46 vector swizzle ( temp 2-component vector of float)
+0:46 f: direct index for structure ( temp 4-component vector of float)
+0:46 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:46 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:46 Constant:
+0:46 0 (const uint)
+0:46 direct index ( temp uint)
+0:46 'dti' ( in 3-component vector of uint)
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 2 (const int)
+0:46 Sequence
+0:46 Constant:
+0:46 0 (const int)
+0:46 Constant:
+0:46 1 (const int)
+0:46 Constant:
+0:46 1 (const uint)
+0:47 move second child to first child ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 subgroupQuadBroadcast ( temp 3-component vector of float)
+0:47 vector swizzle ( temp 3-component vector of float)
+0:47 f: direct index for structure ( temp 4-component vector of float)
+0:47 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:47 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:47 Constant:
+0:47 0 (const uint)
+0:47 direct index ( temp uint)
+0:47 'dti' ( in 3-component vector of uint)
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Sequence
+0:47 Constant:
+0:47 0 (const int)
+0:47 Constant:
+0:47 1 (const int)
+0:47 Constant:
+0:47 2 (const int)
+0:47 Constant:
+0:47 1 (const uint)
+0:49 move second child to first child ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 subgroupQuadBroadcast ( temp 4-component vector of double)
+0:49 d: direct index for structure ( temp 4-component vector of double)
+0:49 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:49 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:49 Constant:
+0:49 0 (const uint)
+0:49 direct index ( temp uint)
+0:49 'dti' ( in 3-component vector of uint)
+0:49 Constant:
+0:49 0 (const int)
+0:49 Constant:
+0:49 3 (const int)
+0:49 Constant:
+0:49 1 (const uint)
+0:50 move second child to first child ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 subgroupQuadBroadcast ( temp double)
+0:50 direct index ( temp double)
+0:50 d: direct index for structure ( temp 4-component vector of double)
+0:50 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:50 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:50 Constant:
+0:50 0 (const uint)
+0:50 direct index ( temp uint)
+0:50 'dti' ( in 3-component vector of uint)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 3 (const int)
+0:50 Constant:
+0:50 0 (const int)
+0:50 Constant:
+0:50 1 (const uint)
+0:51 move second child to first child ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 subgroupQuadBroadcast ( temp 2-component vector of double)
+0:51 vector swizzle ( temp 2-component vector of double)
+0:51 d: direct index for structure ( temp 4-component vector of double)
+0:51 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:51 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:51 Constant:
+0:51 0 (const uint)
+0:51 direct index ( temp uint)
+0:51 'dti' ( in 3-component vector of uint)
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 3 (const int)
+0:51 Sequence
+0:51 Constant:
+0:51 0 (const int)
+0:51 Constant:
+0:51 1 (const int)
+0:51 Constant:
+0:51 1 (const uint)
+0:52 move second child to first child ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 subgroupQuadBroadcast ( temp 3-component vector of double)
+0:52 vector swizzle ( temp 3-component vector of double)
+0:52 d: direct index for structure ( temp 4-component vector of double)
+0:52 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:52 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:52 Constant:
+0:52 0 (const uint)
+0:52 direct index ( temp uint)
+0:52 'dti' ( in 3-component vector of uint)
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 3 (const int)
+0:52 Sequence
+0:52 Constant:
+0:52 0 (const int)
+0:52 Constant:
+0:52 1 (const int)
+0:52 Constant:
+0:52 2 (const int)
+0:52 Constant:
+0:52 1 (const uint)
+0:54 move second child to first child ( temp 4-component vector of uint)
+0:54 u: direct index for structure ( temp 4-component vector of uint)
+0:54 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:54 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:54 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:54 Constant:
+0:54 0 (const uint)
+0:54 direct index ( temp uint)
+0:54 'dti' ( in 3-component vector of uint)
+0:54 Constant:
+0:54 0 (const int)
+0:54 Constant:
+0:54 0 (const int)
+0:54 subgroupQuadBroadcast ( temp 4-component vector of uint)
+0:54 u: direct index for structure ( temp 4-component vector of uint)
+0:54 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:54 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:54 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:54 Constant:
+0:54 0 (const uint)
+0:54 direct index ( temp uint)
+0:54 'dti' ( in 3-component vector of uint)
+0:54 Constant:
+0:54 0 (const int)
+0:54 Constant:
+0:54 0 (const int)
+0:54 Constant:
+0:54 2 (const uint)
+0:55 move second child to first child ( temp uint)
+0:55 direct index ( temp uint)
+0:55 u: direct index for structure ( temp 4-component vector of uint)
+0:55 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:55 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:55 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:55 Constant:
+0:55 0 (const uint)
+0:55 direct index ( temp uint)
+0:55 'dti' ( in 3-component vector of uint)
+0:55 Constant:
+0:55 0 (const int)
+0:55 Constant:
+0:55 0 (const int)
+0:55 Constant:
+0:55 0 (const int)
+0:55 subgroupQuadBroadcast ( temp uint)
+0:55 direct index ( temp uint)
+0:55 u: direct index for structure ( temp 4-component vector of uint)
+0:55 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:55 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:55 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:55 Constant:
+0:55 0 (const uint)
+0:55 direct index ( temp uint)
+0:55 'dti' ( in 3-component vector of uint)
+0:55 Constant:
+0:55 0 (const int)
+0:55 Constant:
+0:55 0 (const int)
+0:55 Constant:
+0:55 0 (const int)
+0:55 Constant:
+0:55 2 (const uint)
+0:56 move second child to first child ( temp 2-component vector of uint)
+0:56 vector swizzle ( temp 2-component vector of uint)
+0:56 u: direct index for structure ( temp 4-component vector of uint)
+0:56 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:56 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:56 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:56 Constant:
+0:56 0 (const uint)
+0:56 direct index ( temp uint)
+0:56 'dti' ( in 3-component vector of uint)
+0:56 Constant:
+0:56 0 (const int)
+0:56 Constant:
+0:56 0 (const int)
+0:56 Sequence
+0:56 Constant:
+0:56 0 (const int)
+0:56 Constant:
+0:56 1 (const int)
+0:56 subgroupQuadBroadcast ( temp 2-component vector of uint)
+0:56 vector swizzle ( temp 2-component vector of uint)
+0:56 u: direct index for structure ( temp 4-component vector of uint)
+0:56 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:56 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:56 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:56 Constant:
+0:56 0 (const uint)
+0:56 direct index ( temp uint)
+0:56 'dti' ( in 3-component vector of uint)
+0:56 Constant:
+0:56 0 (const int)
+0:56 Constant:
+0:56 0 (const int)
+0:56 Sequence
+0:56 Constant:
+0:56 0 (const int)
+0:56 Constant:
+0:56 1 (const int)
+0:56 Constant:
+0:56 2 (const uint)
+0:57 move second child to first child ( temp 3-component vector of uint)
+0:57 vector swizzle ( temp 3-component vector of uint)
+0:57 u: direct index for structure ( temp 4-component vector of uint)
+0:57 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:57 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:57 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:57 Constant:
+0:57 0 (const uint)
+0:57 direct index ( temp uint)
+0:57 'dti' ( in 3-component vector of uint)
+0:57 Constant:
+0:57 0 (const int)
+0:57 Constant:
+0:57 0 (const int)
+0:57 Sequence
+0:57 Constant:
+0:57 0 (const int)
+0:57 Constant:
+0:57 1 (const int)
+0:57 Constant:
+0:57 2 (const int)
+0:57 subgroupQuadBroadcast ( temp 3-component vector of uint)
+0:57 vector swizzle ( temp 3-component vector of uint)
+0:57 u: direct index for structure ( temp 4-component vector of uint)
+0:57 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:57 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:57 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:57 Constant:
+0:57 0 (const uint)
+0:57 direct index ( temp uint)
+0:57 'dti' ( in 3-component vector of uint)
+0:57 Constant:
+0:57 0 (const int)
+0:57 Constant:
+0:57 0 (const int)
+0:57 Sequence
+0:57 Constant:
+0:57 0 (const int)
+0:57 Constant:
+0:57 1 (const int)
+0:57 Constant:
+0:57 2 (const int)
+0:57 Constant:
+0:57 2 (const uint)
+0:59 move second child to first child ( temp 4-component vector of int)
+0:59 i: direct index for structure ( temp 4-component vector of int)
+0:59 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:59 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:59 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:59 Constant:
+0:59 0 (const uint)
+0:59 direct index ( temp uint)
+0:59 'dti' ( in 3-component vector of uint)
+0:59 Constant:
+0:59 0 (const int)
+0:59 Constant:
+0:59 1 (const int)
+0:59 subgroupQuadBroadcast ( temp 4-component vector of int)
+0:59 i: direct index for structure ( temp 4-component vector of int)
+0:59 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:59 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:59 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:59 Constant:
+0:59 0 (const uint)
+0:59 direct index ( temp uint)
+0:59 'dti' ( in 3-component vector of uint)
+0:59 Constant:
+0:59 0 (const int)
+0:59 Constant:
+0:59 1 (const int)
+0:59 Constant:
+0:59 2 (const uint)
+0:60 move second child to first child ( temp int)
+0:60 direct index ( temp int)
+0:60 i: direct index for structure ( temp 4-component vector of int)
+0:60 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:60 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:60 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:60 Constant:
+0:60 0 (const uint)
+0:60 direct index ( temp uint)
+0:60 'dti' ( in 3-component vector of uint)
+0:60 Constant:
+0:60 0 (const int)
+0:60 Constant:
+0:60 1 (const int)
+0:60 Constant:
+0:60 0 (const int)
+0:60 subgroupQuadBroadcast ( temp int)
+0:60 direct index ( temp int)
+0:60 i: direct index for structure ( temp 4-component vector of int)
+0:60 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:60 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:60 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:60 Constant:
+0:60 0 (const uint)
+0:60 direct index ( temp uint)
+0:60 'dti' ( in 3-component vector of uint)
+0:60 Constant:
+0:60 0 (const int)
+0:60 Constant:
+0:60 1 (const int)
+0:60 Constant:
+0:60 0 (const int)
+0:60 Constant:
+0:60 2 (const uint)
+0:61 move second child to first child ( temp 2-component vector of int)
+0:61 vector swizzle ( temp 2-component vector of int)
+0:61 i: direct index for structure ( temp 4-component vector of int)
+0:61 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:61 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:61 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:61 Constant:
+0:61 0 (const uint)
+0:61 direct index ( temp uint)
+0:61 'dti' ( in 3-component vector of uint)
+0:61 Constant:
+0:61 0 (const int)
+0:61 Constant:
+0:61 1 (const int)
+0:61 Sequence
+0:61 Constant:
+0:61 0 (const int)
+0:61 Constant:
+0:61 1 (const int)
+0:61 subgroupQuadBroadcast ( temp 2-component vector of int)
+0:61 vector swizzle ( temp 2-component vector of int)
+0:61 i: direct index for structure ( temp 4-component vector of int)
+0:61 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:61 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:61 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:61 Constant:
+0:61 0 (const uint)
+0:61 direct index ( temp uint)
+0:61 'dti' ( in 3-component vector of uint)
+0:61 Constant:
+0:61 0 (const int)
+0:61 Constant:
+0:61 1 (const int)
+0:61 Sequence
+0:61 Constant:
+0:61 0 (const int)
+0:61 Constant:
+0:61 1 (const int)
+0:61 Constant:
+0:61 2 (const uint)
+0:62 move second child to first child ( temp 3-component vector of int)
+0:62 vector swizzle ( temp 3-component vector of int)
+0:62 i: direct index for structure ( temp 4-component vector of int)
+0:62 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:62 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:62 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:62 Constant:
+0:62 0 (const uint)
+0:62 direct index ( temp uint)
+0:62 'dti' ( in 3-component vector of uint)
+0:62 Constant:
+0:62 0 (const int)
+0:62 Constant:
+0:62 1 (const int)
+0:62 Sequence
+0:62 Constant:
+0:62 0 (const int)
+0:62 Constant:
+0:62 1 (const int)
+0:62 Constant:
+0:62 2 (const int)
+0:62 subgroupQuadBroadcast ( temp 3-component vector of int)
+0:62 vector swizzle ( temp 3-component vector of int)
+0:62 i: direct index for structure ( temp 4-component vector of int)
+0:62 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:62 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:62 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:62 Constant:
+0:62 0 (const uint)
+0:62 direct index ( temp uint)
+0:62 'dti' ( in 3-component vector of uint)
+0:62 Constant:
+0:62 0 (const int)
+0:62 Constant:
+0:62 1 (const int)
+0:62 Sequence
+0:62 Constant:
+0:62 0 (const int)
+0:62 Constant:
+0:62 1 (const int)
+0:62 Constant:
+0:62 2 (const int)
+0:62 Constant:
+0:62 2 (const uint)
+0:64 move second child to first child ( temp 4-component vector of float)
+0:64 f: direct index for structure ( temp 4-component vector of float)
+0:64 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:64 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:64 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:64 Constant:
+0:64 0 (const uint)
+0:64 direct index ( temp uint)
+0:64 'dti' ( in 3-component vector of uint)
+0:64 Constant:
+0:64 0 (const int)
+0:64 Constant:
+0:64 2 (const int)
+0:64 subgroupQuadBroadcast ( temp 4-component vector of float)
+0:64 f: direct index for structure ( temp 4-component vector of float)
+0:64 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:64 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:64 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:64 Constant:
+0:64 0 (const uint)
+0:64 direct index ( temp uint)
+0:64 'dti' ( in 3-component vector of uint)
+0:64 Constant:
+0:64 0 (const int)
+0:64 Constant:
+0:64 2 (const int)
+0:64 Constant:
+0:64 2 (const uint)
+0:65 move second child to first child ( temp float)
+0:65 direct index ( temp float)
+0:65 f: direct index for structure ( temp 4-component vector of float)
+0:65 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:65 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:65 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:65 Constant:
+0:65 0 (const uint)
+0:65 direct index ( temp uint)
+0:65 'dti' ( in 3-component vector of uint)
+0:65 Constant:
+0:65 0 (const int)
+0:65 Constant:
+0:65 2 (const int)
+0:65 Constant:
+0:65 0 (const int)
+0:65 subgroupQuadBroadcast ( temp float)
+0:65 direct index ( temp float)
+0:65 f: direct index for structure ( temp 4-component vector of float)
+0:65 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:65 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:65 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:65 Constant:
+0:65 0 (const uint)
+0:65 direct index ( temp uint)
+0:65 'dti' ( in 3-component vector of uint)
+0:65 Constant:
+0:65 0 (const int)
+0:65 Constant:
+0:65 2 (const int)
+0:65 Constant:
+0:65 0 (const int)
+0:65 Constant:
+0:65 2 (const uint)
+0:66 move second child to first child ( temp 2-component vector of float)
+0:66 vector swizzle ( temp 2-component vector of float)
+0:66 f: direct index for structure ( temp 4-component vector of float)
+0:66 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:66 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:66 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:66 Constant:
+0:66 0 (const uint)
+0:66 direct index ( temp uint)
+0:66 'dti' ( in 3-component vector of uint)
+0:66 Constant:
+0:66 0 (const int)
+0:66 Constant:
+0:66 2 (const int)
+0:66 Sequence
+0:66 Constant:
+0:66 0 (const int)
+0:66 Constant:
+0:66 1 (const int)
+0:66 subgroupQuadBroadcast ( temp 2-component vector of float)
+0:66 vector swizzle ( temp 2-component vector of float)
+0:66 f: direct index for structure ( temp 4-component vector of float)
+0:66 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:66 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:66 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:66 Constant:
+0:66 0 (const uint)
+0:66 direct index ( temp uint)
+0:66 'dti' ( in 3-component vector of uint)
+0:66 Constant:
+0:66 0 (const int)
+0:66 Constant:
+0:66 2 (const int)
+0:66 Sequence
+0:66 Constant:
+0:66 0 (const int)
+0:66 Constant:
+0:66 1 (const int)
+0:66 Constant:
+0:66 2 (const uint)
+0:67 move second child to first child ( temp 3-component vector of float)
+0:67 vector swizzle ( temp 3-component vector of float)
+0:67 f: direct index for structure ( temp 4-component vector of float)
+0:67 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:67 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:67 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:67 Constant:
+0:67 0 (const uint)
+0:67 direct index ( temp uint)
+0:67 'dti' ( in 3-component vector of uint)
+0:67 Constant:
+0:67 0 (const int)
+0:67 Constant:
+0:67 2 (const int)
+0:67 Sequence
+0:67 Constant:
+0:67 0 (const int)
+0:67 Constant:
+0:67 1 (const int)
+0:67 Constant:
+0:67 2 (const int)
+0:67 subgroupQuadBroadcast ( temp 3-component vector of float)
+0:67 vector swizzle ( temp 3-component vector of float)
+0:67 f: direct index for structure ( temp 4-component vector of float)
+0:67 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:67 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:67 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:67 Constant:
+0:67 0 (const uint)
+0:67 direct index ( temp uint)
+0:67 'dti' ( in 3-component vector of uint)
+0:67 Constant:
+0:67 0 (const int)
+0:67 Constant:
+0:67 2 (const int)
+0:67 Sequence
+0:67 Constant:
+0:67 0 (const int)
+0:67 Constant:
+0:67 1 (const int)
+0:67 Constant:
+0:67 2 (const int)
+0:67 Constant:
+0:67 2 (const uint)
+0:69 move second child to first child ( temp 4-component vector of double)
+0:69 d: direct index for structure ( temp 4-component vector of double)
+0:69 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:69 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:69 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:69 Constant:
+0:69 0 (const uint)
+0:69 direct index ( temp uint)
+0:69 'dti' ( in 3-component vector of uint)
+0:69 Constant:
+0:69 0 (const int)
+0:69 Constant:
+0:69 3 (const int)
+0:69 subgroupQuadBroadcast ( temp 4-component vector of double)
+0:69 d: direct index for structure ( temp 4-component vector of double)
+0:69 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:69 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:69 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:69 Constant:
+0:69 0 (const uint)
+0:69 direct index ( temp uint)
+0:69 'dti' ( in 3-component vector of uint)
+0:69 Constant:
+0:69 0 (const int)
+0:69 Constant:
+0:69 3 (const int)
+0:69 Constant:
+0:69 2 (const uint)
+0:70 move second child to first child ( temp double)
+0:70 direct index ( temp double)
+0:70 d: direct index for structure ( temp 4-component vector of double)
+0:70 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:70 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:70 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:70 Constant:
+0:70 0 (const uint)
+0:70 direct index ( temp uint)
+0:70 'dti' ( in 3-component vector of uint)
+0:70 Constant:
+0:70 0 (const int)
+0:70 Constant:
+0:70 3 (const int)
+0:70 Constant:
+0:70 0 (const int)
+0:70 subgroupQuadBroadcast ( temp double)
+0:70 direct index ( temp double)
+0:70 d: direct index for structure ( temp 4-component vector of double)
+0:70 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:70 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:70 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:70 Constant:
+0:70 0 (const uint)
+0:70 direct index ( temp uint)
+0:70 'dti' ( in 3-component vector of uint)
+0:70 Constant:
+0:70 0 (const int)
+0:70 Constant:
+0:70 3 (const int)
+0:70 Constant:
+0:70 0 (const int)
+0:70 Constant:
+0:70 2 (const uint)
+0:71 move second child to first child ( temp 2-component vector of double)
+0:71 vector swizzle ( temp 2-component vector of double)
+0:71 d: direct index for structure ( temp 4-component vector of double)
+0:71 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:71 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:71 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:71 Constant:
+0:71 0 (const uint)
+0:71 direct index ( temp uint)
+0:71 'dti' ( in 3-component vector of uint)
+0:71 Constant:
+0:71 0 (const int)
+0:71 Constant:
+0:71 3 (const int)
+0:71 Sequence
+0:71 Constant:
+0:71 0 (const int)
+0:71 Constant:
+0:71 1 (const int)
+0:71 subgroupQuadBroadcast ( temp 2-component vector of double)
+0:71 vector swizzle ( temp 2-component vector of double)
+0:71 d: direct index for structure ( temp 4-component vector of double)
+0:71 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:71 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:71 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:71 Constant:
+0:71 0 (const uint)
+0:71 direct index ( temp uint)
+0:71 'dti' ( in 3-component vector of uint)
+0:71 Constant:
+0:71 0 (const int)
+0:71 Constant:
+0:71 3 (const int)
+0:71 Sequence
+0:71 Constant:
+0:71 0 (const int)
+0:71 Constant:
+0:71 1 (const int)
+0:71 Constant:
+0:71 2 (const uint)
+0:72 move second child to first child ( temp 3-component vector of double)
+0:72 vector swizzle ( temp 3-component vector of double)
+0:72 d: direct index for structure ( temp 4-component vector of double)
+0:72 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:72 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:72 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:72 Constant:
+0:72 0 (const uint)
+0:72 direct index ( temp uint)
+0:72 'dti' ( in 3-component vector of uint)
+0:72 Constant:
+0:72 0 (const int)
+0:72 Constant:
+0:72 3 (const int)
+0:72 Sequence
+0:72 Constant:
+0:72 0 (const int)
+0:72 Constant:
+0:72 1 (const int)
+0:72 Constant:
+0:72 2 (const int)
+0:72 subgroupQuadBroadcast ( temp 3-component vector of double)
+0:72 vector swizzle ( temp 3-component vector of double)
+0:72 d: direct index for structure ( temp 4-component vector of double)
+0:72 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:72 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:72 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:72 Constant:
+0:72 0 (const uint)
+0:72 direct index ( temp uint)
+0:72 'dti' ( in 3-component vector of uint)
+0:72 Constant:
+0:72 0 (const int)
+0:72 Constant:
+0:72 3 (const int)
+0:72 Sequence
+0:72 Constant:
+0:72 0 (const int)
+0:72 Constant:
+0:72 1 (const int)
+0:72 Constant:
+0:72 2 (const int)
+0:72 Constant:
+0:72 2 (const uint)
+0:74 move second child to first child ( temp 4-component vector of uint)
+0:74 u: direct index for structure ( temp 4-component vector of uint)
+0:74 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:74 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:74 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:74 Constant:
+0:74 0 (const uint)
+0:74 direct index ( temp uint)
+0:74 'dti' ( in 3-component vector of uint)
+0:74 Constant:
+0:74 0 (const int)
+0:74 Constant:
+0:74 0 (const int)
+0:74 subgroupQuadBroadcast ( temp 4-component vector of uint)
+0:74 u: direct index for structure ( temp 4-component vector of uint)
+0:74 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:74 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:74 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:74 Constant:
+0:74 0 (const uint)
+0:74 direct index ( temp uint)
+0:74 'dti' ( in 3-component vector of uint)
+0:74 Constant:
+0:74 0 (const int)
+0:74 Constant:
+0:74 0 (const int)
+0:74 Constant:
+0:74 3 (const uint)
+0:75 move second child to first child ( temp uint)
+0:75 direct index ( temp uint)
+0:75 u: direct index for structure ( temp 4-component vector of uint)
+0:75 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:75 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:75 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:75 Constant:
+0:75 0 (const uint)
+0:75 direct index ( temp uint)
+0:75 'dti' ( in 3-component vector of uint)
+0:75 Constant:
+0:75 0 (const int)
+0:75 Constant:
+0:75 0 (const int)
+0:75 Constant:
+0:75 0 (const int)
+0:75 subgroupQuadBroadcast ( temp uint)
+0:75 direct index ( temp uint)
+0:75 u: direct index for structure ( temp 4-component vector of uint)
+0:75 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:75 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:75 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:75 Constant:
+0:75 0 (const uint)
+0:75 direct index ( temp uint)
+0:75 'dti' ( in 3-component vector of uint)
+0:75 Constant:
+0:75 0 (const int)
+0:75 Constant:
+0:75 0 (const int)
+0:75 Constant:
+0:75 0 (const int)
+0:75 Constant:
+0:75 3 (const uint)
+0:76 move second child to first child ( temp 2-component vector of uint)
+0:76 vector swizzle ( temp 2-component vector of uint)
+0:76 u: direct index for structure ( temp 4-component vector of uint)
+0:76 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:76 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:76 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:76 Constant:
+0:76 0 (const uint)
+0:76 direct index ( temp uint)
+0:76 'dti' ( in 3-component vector of uint)
+0:76 Constant:
+0:76 0 (const int)
+0:76 Constant:
+0:76 0 (const int)
+0:76 Sequence
+0:76 Constant:
+0:76 0 (const int)
+0:76 Constant:
+0:76 1 (const int)
+0:76 subgroupQuadBroadcast ( temp 2-component vector of uint)
+0:76 vector swizzle ( temp 2-component vector of uint)
+0:76 u: direct index for structure ( temp 4-component vector of uint)
+0:76 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:76 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:76 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:76 Constant:
+0:76 0 (const uint)
+0:76 direct index ( temp uint)
+0:76 'dti' ( in 3-component vector of uint)
+0:76 Constant:
+0:76 0 (const int)
+0:76 Constant:
+0:76 0 (const int)
+0:76 Sequence
+0:76 Constant:
+0:76 0 (const int)
+0:76 Constant:
+0:76 1 (const int)
+0:76 Constant:
+0:76 3 (const uint)
+0:77 move second child to first child ( temp 3-component vector of uint)
+0:77 vector swizzle ( temp 3-component vector of uint)
+0:77 u: direct index for structure ( temp 4-component vector of uint)
+0:77 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:77 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:77 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:77 Constant:
+0:77 0 (const uint)
+0:77 direct index ( temp uint)
+0:77 'dti' ( in 3-component vector of uint)
+0:77 Constant:
+0:77 0 (const int)
+0:77 Constant:
+0:77 0 (const int)
+0:77 Sequence
+0:77 Constant:
+0:77 0 (const int)
+0:77 Constant:
+0:77 1 (const int)
+0:77 Constant:
+0:77 2 (const int)
+0:77 subgroupQuadBroadcast ( temp 3-component vector of uint)
+0:77 vector swizzle ( temp 3-component vector of uint)
+0:77 u: direct index for structure ( temp 4-component vector of uint)
+0:77 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:77 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:77 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:77 Constant:
+0:77 0 (const uint)
+0:77 direct index ( temp uint)
+0:77 'dti' ( in 3-component vector of uint)
+0:77 Constant:
+0:77 0 (const int)
+0:77 Constant:
+0:77 0 (const int)
+0:77 Sequence
+0:77 Constant:
+0:77 0 (const int)
+0:77 Constant:
+0:77 1 (const int)
+0:77 Constant:
+0:77 2 (const int)
+0:77 Constant:
+0:77 3 (const uint)
+0:79 move second child to first child ( temp 4-component vector of int)
+0:79 i: direct index for structure ( temp 4-component vector of int)
+0:79 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:79 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:79 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:79 Constant:
+0:79 0 (const uint)
+0:79 direct index ( temp uint)
+0:79 'dti' ( in 3-component vector of uint)
+0:79 Constant:
+0:79 0 (const int)
+0:79 Constant:
+0:79 1 (const int)
+0:79 subgroupQuadBroadcast ( temp 4-component vector of int)
+0:79 i: direct index for structure ( temp 4-component vector of int)
+0:79 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:79 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:79 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:79 Constant:
+0:79 0 (const uint)
+0:79 direct index ( temp uint)
+0:79 'dti' ( in 3-component vector of uint)
+0:79 Constant:
+0:79 0 (const int)
+0:79 Constant:
+0:79 1 (const int)
+0:79 Constant:
+0:79 3 (const uint)
+0:80 move second child to first child ( temp int)
+0:80 direct index ( temp int)
+0:80 i: direct index for structure ( temp 4-component vector of int)
+0:80 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:80 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:80 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:80 Constant:
+0:80 0 (const uint)
+0:80 direct index ( temp uint)
+0:80 'dti' ( in 3-component vector of uint)
+0:80 Constant:
+0:80 0 (const int)
+0:80 Constant:
+0:80 1 (const int)
+0:80 Constant:
+0:80 0 (const int)
+0:80 subgroupQuadBroadcast ( temp int)
+0:80 direct index ( temp int)
+0:80 i: direct index for structure ( temp 4-component vector of int)
+0:80 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:80 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:80 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:80 Constant:
+0:80 0 (const uint)
+0:80 direct index ( temp uint)
+0:80 'dti' ( in 3-component vector of uint)
+0:80 Constant:
+0:80 0 (const int)
+0:80 Constant:
+0:80 1 (const int)
+0:80 Constant:
+0:80 0 (const int)
+0:80 Constant:
+0:80 3 (const uint)
+0:81 move second child to first child ( temp 2-component vector of int)
+0:81 vector swizzle ( temp 2-component vector of int)
+0:81 i: direct index for structure ( temp 4-component vector of int)
+0:81 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:81 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:81 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:81 Constant:
+0:81 0 (const uint)
+0:81 direct index ( temp uint)
+0:81 'dti' ( in 3-component vector of uint)
+0:81 Constant:
+0:81 0 (const int)
+0:81 Constant:
+0:81 1 (const int)
+0:81 Sequence
+0:81 Constant:
+0:81 0 (const int)
+0:81 Constant:
+0:81 1 (const int)
+0:81 subgroupQuadBroadcast ( temp 2-component vector of int)
+0:81 vector swizzle ( temp 2-component vector of int)
+0:81 i: direct index for structure ( temp 4-component vector of int)
+0:81 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:81 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:81 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:81 Constant:
+0:81 0 (const uint)
+0:81 direct index ( temp uint)
+0:81 'dti' ( in 3-component vector of uint)
+0:81 Constant:
+0:81 0 (const int)
+0:81 Constant:
+0:81 1 (const int)
+0:81 Sequence
+0:81 Constant:
+0:81 0 (const int)
+0:81 Constant:
+0:81 1 (const int)
+0:81 Constant:
+0:81 3 (const uint)
+0:82 move second child to first child ( temp 3-component vector of int)
+0:82 vector swizzle ( temp 3-component vector of int)
+0:82 i: direct index for structure ( temp 4-component vector of int)
+0:82 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:82 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:82 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:82 Constant:
+0:82 0 (const uint)
+0:82 direct index ( temp uint)
+0:82 'dti' ( in 3-component vector of uint)
+0:82 Constant:
+0:82 0 (const int)
+0:82 Constant:
+0:82 1 (const int)
+0:82 Sequence
+0:82 Constant:
+0:82 0 (const int)
+0:82 Constant:
+0:82 1 (const int)
+0:82 Constant:
+0:82 2 (const int)
+0:82 subgroupQuadBroadcast ( temp 3-component vector of int)
+0:82 vector swizzle ( temp 3-component vector of int)
+0:82 i: direct index for structure ( temp 4-component vector of int)
+0:82 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:82 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:82 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:82 Constant:
+0:82 0 (const uint)
+0:82 direct index ( temp uint)
+0:82 'dti' ( in 3-component vector of uint)
+0:82 Constant:
+0:82 0 (const int)
+0:82 Constant:
+0:82 1 (const int)
+0:82 Sequence
+0:82 Constant:
+0:82 0 (const int)
+0:82 Constant:
+0:82 1 (const int)
+0:82 Constant:
+0:82 2 (const int)
+0:82 Constant:
+0:82 3 (const uint)
+0:84 move second child to first child ( temp 4-component vector of float)
+0:84 f: direct index for structure ( temp 4-component vector of float)
+0:84 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:84 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:84 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:84 Constant:
+0:84 0 (const uint)
+0:84 direct index ( temp uint)
+0:84 'dti' ( in 3-component vector of uint)
+0:84 Constant:
+0:84 0 (const int)
+0:84 Constant:
+0:84 2 (const int)
+0:84 subgroupQuadBroadcast ( temp 4-component vector of float)
+0:84 f: direct index for structure ( temp 4-component vector of float)
+0:84 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:84 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:84 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:84 Constant:
+0:84 0 (const uint)
+0:84 direct index ( temp uint)
+0:84 'dti' ( in 3-component vector of uint)
+0:84 Constant:
+0:84 0 (const int)
+0:84 Constant:
+0:84 2 (const int)
+0:84 Constant:
+0:84 3 (const uint)
+0:85 move second child to first child ( temp float)
+0:85 direct index ( temp float)
+0:85 f: direct index for structure ( temp 4-component vector of float)
+0:85 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:85 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:85 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:85 Constant:
+0:85 0 (const uint)
+0:85 direct index ( temp uint)
+0:85 'dti' ( in 3-component vector of uint)
+0:85 Constant:
+0:85 0 (const int)
+0:85 Constant:
+0:85 2 (const int)
+0:85 Constant:
+0:85 0 (const int)
+0:85 subgroupQuadBroadcast ( temp float)
+0:85 direct index ( temp float)
+0:85 f: direct index for structure ( temp 4-component vector of float)
+0:85 indirect index (layout( row_major std430) buffer structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:85 @data: direct index for structure (layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d})
+0:85 'data' (layout( row_major std430) buffer block{layout( row_major std430) buffer implicitly-sized array of structure{ temp 4-component vector of uint u, temp 4-component vector of int i, temp 4-component vector of float f, temp 4-component vector of double d} @data})
+0:85 Constant:
+0:85 0 (const uint)
+0:85 direct index ( temp uint)
+0:85 'dti' ( in 3-component vector of uint)
+0:85 Constant:
+0:85 0 (const int)
+0:85 Constant:
+0:85 2 (const int)
+0:85 Constant:
+0:85 0 (const int)
+0:85 Constant:
+0:85 3 (const uint)
+0:86 move second child to first child ( temp 2-component vector of float)
+0:86 vector swizzle ( temp 2-comp