Implement the extension GL_EXT_spirv_intrinsics

- Add support of SPIR-V execution mode qualifiers.
- Add support of SPIR-V storage class qualifier.
- Add support of SPIR-V decorate qualifiers.
- Add support of SPIR-V type specifier.
- Add support of SPIR-V intruction qualifiers.
- Add support of spirv_by_reference/spirv_literal parameter qualifier.
- Add shader stage macros introduced by this extension.

diff --git a/BUILD.gn b/BUILD.gn
index 973ca98..a37e1d2 100644 (file)
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -131,6 +131,7 @@ template("glslang_sources_common") {
       "glslang/Include/PoolAlloc.h",
       "glslang/Include/ResourceLimits.h",
       "glslang/Include/ShHandle.h",
+      "glslang/Include/SpirvIntrinsics.h",
       "glslang/Include/Types.h",
       "glslang/Include/arrays.h",
       "glslang/Include/intermediate.h",
@@ -151,6 +152,7 @@ template("glslang_sources_common") {
       "glslang/MachineIndependent/Scan.h",
       "glslang/MachineIndependent/ScanContext.h",
       "glslang/MachineIndependent/ShaderLang.cpp",
+      "glslang/MachineIndependent/SpirvIntrinsics.cpp",
       "glslang/MachineIndependent/SymbolTable.cpp",
       "glslang/MachineIndependent/SymbolTable.h",
       "glslang/MachineIndependent/Versions.cpp",

diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index 5a25c8d..ac2fef9 100644 (file)
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -160,6 +160,7 @@ protected:
     spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const;
     spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector<unsigned int>& operands) const;
     spv::StorageClass TranslateStorageClass(const glslang::TType&);
+    void TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>&, std::vector<unsigned>&) const;
     void addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType);
     spv::Id createSpvVariable(const glslang::TIntermSymbol*, spv::Id forcedType);
     spv::Id getSampledType(const glslang::TSampler&);
@@ -1249,6 +1250,10 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
 {
     if (type.getBasicType() == glslang::EbtRayQuery)
         return spv::StorageClassPrivate;
+#ifndef GLSLANG_WEB
+    if (type.getQualifier().isSpirvByReference())
+        return spv::StorageClassFunction;
+#endif
     if (type.getQualifier().isPipeInput())
         return spv::StorageClassInput;
     if (type.getQualifier().isPipeOutput())
@@ -1297,6 +1302,7 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
     case glslang::EvqHitAttr:        return spv::StorageClassHitAttributeKHR;
     case glslang::EvqCallableData:   return spv::StorageClassCallableDataKHR;
     case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
+    case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
 #endif
     default:
         assert(0);
@@ -1306,6 +1312,52 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
     return spv::StorageClassFunction;
 }
 
+// Translate glslang constants to SPIR-V literals
+void TGlslangToSpvTraverser::TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>& constants,
+                                               std::vector<unsigned>& literals) const
+{
+    for (auto constant : constants) {
+        if (constant->getBasicType() == glslang::EbtFloat) {
+            float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
+            unsigned literal = *reinterpret_cast<unsigned*>(&floatValue);
+            literals.push_back(literal);
+        } else if (constant->getBasicType() == glslang::EbtInt) {
+            unsigned literal = constant->getConstArray()[0].getIConst();
+            literals.push_back(literal);
+        } else if (constant->getBasicType() == glslang::EbtUint) {
+            unsigned literal = constant->getConstArray()[0].getUConst();
+            literals.push_back(literal);
+        } else if (constant->getBasicType() == glslang::EbtBool) {
+            unsigned literal = constant->getConstArray()[0].getBConst();
+            literals.push_back(literal);
+        } else if (constant->getBasicType() == glslang::EbtString) {
+            auto str = constant->getConstArray()[0].getSConst()->c_str();
+            unsigned literal = 0;
+            char* literalPtr = reinterpret_cast<char*>(&literal);
+            unsigned charCount = 0;
+            char ch = 0;
+            do {
+                ch = *(str++);
+                *(literalPtr++) = ch;
+                ++charCount;
+                if (charCount == 4) {
+                    literals.push_back(literal);
+                    literalPtr = reinterpret_cast<char*>(&literal);
+                    charCount = 0;
+                }
+            } while (ch != 0);
+
+            // Partial literal is padded with 0
+            if (charCount > 0) {
+                for (; charCount < 4; ++charCount)
+                    *(literalPtr++) = 0;
+                literals.push_back(literal);
+            }
+        } else
+            assert(0); // Unexpected type
+    }
+}
+
 // Add capabilities pertaining to how an array is indexed.
 void TGlslangToSpvTraverser::addIndirectionIndexCapabilities(const glslang::TType& baseType,
                                                              const glslang::TType& indexType)
@@ -1735,6 +1787,53 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
     default:
         break;
     }
+
+#ifndef GLSLANG_WEB
+    //
+    // Add SPIR-V requirements (GL_EXT_spirv_intrinsics)
+    //
+    if (glslangIntermediate->hasSpirvRequirement()) {
+        const glslang::TSpirvRequirement& spirvRequirement = glslangIntermediate->getSpirvRequirement();
+
+        // Add SPIR-V extension requirement
+        for (auto& extension : spirvRequirement.extensions)
+            builder.addExtension(extension.c_str());
+
+        // Add SPIR-V capability requirement
+        for (auto capability : spirvRequirement.capabilities)
+            builder.addCapability(static_cast<spv::Capability>(capability));
+    }
+
+    //
+    // Add SPIR-V execution mode qualifiers (GL_EXT_spirv_intrinsics)
+    //
+    if (glslangIntermediate->hasSpirvExecutionMode()) {
+        const glslang::TSpirvExecutionMode spirvExecutionMode = glslangIntermediate->getSpirvExecutionMode();
+
+        // Add spirv_execution_mode
+        for (auto& mode : spirvExecutionMode.modes) {
+            if (!mode.second.empty()) {
+                std::vector<unsigned> literals;
+                TranslateLiterals(mode.second, literals);
+                builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first), literals);
+            } else
+                builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first));
+        }
+
+        // Add spirv_execution_mode_id
+        for (auto& modeId : spirvExecutionMode.modeIds) {
+            std::vector<spv::Id> operandIds;
+            assert(!modeId.second.empty());
+            for (auto extraOperand : modeId.second) {
+                int nextConst = 0;
+                spv::Id operandId = createSpvConstantFromConstUnionArray(
+                    extraOperand->getType(), extraOperand->getConstArray(), nextConst, false);
+                operandIds.push_back(operandId);
+            }
+            builder.addExecutionModeId(shaderEntry, static_cast<spv::ExecutionMode>(modeId.first), operandIds);
+        }
+    }
+#endif
 }
 
 // Finish creating SPV, after the traversal is complete.
@@ -2317,10 +2416,14 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
         node->getOp() == glslang::EOpRayQueryGetWorldRayDirection ||
         node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque ||
         node->getOp() == glslang::EOpRayQueryTerminate ||
-        node->getOp() == glslang::EOpRayQueryConfirmIntersection) {
+        node->getOp() == glslang::EOpRayQueryConfirmIntersection ||
+        (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference())) {
         operand = builder.accessChainGetLValue(); // Special case l-value operands
         lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
         lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType());
+    } else if (operandNode->getAsTyped()->getQualifier().isSpirvLiteral()) {
+        // Will be translated to a literal value, make a placeholder here
+        operand = spv::NoResult;
     } else
 #endif
     {
@@ -2341,6 +2444,38 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
         result = createUnaryOperation(node->getOp(), decorations, resultType(), operand,
             node->getOperand()->getBasicType(), lvalueCoherentFlags);
 
+#ifndef GLSLANG_WEB
+    // it could be attached to a SPIR-V intruction
+    if (!result) {
+        if (node->getOp() == glslang::EOpSpirvInst) {
+            const auto& spirvInst = node->getSpirvInstruction();
+            if (spirvInst.set == "") {
+                spv::IdImmediate idImmOp = {true, operand};
+                if (operandNode->getAsTyped()->getQualifier().isSpirvLiteral()) {
+                    // Translate the constant to a literal value
+                    std::vector<unsigned> literals;
+                    glslang::TVector<const glslang::TIntermConstantUnion*> constants;
+                    constants.push_back(operandNode->getAsConstantUnion());
+                    TranslateLiterals(constants, literals);
+                    idImmOp = {false, literals[0]};
+                }
+
+                if (node->getBasicType() == glslang::EbtVoid)
+                    builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), {idImmOp});
+                else
+                    result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), {idImmOp});
+            } else {
+                result = builder.createBuiltinCall(
+                    resultType(), spirvInst.set == "GLSL.std.450" ? stdBuiltins : getExtBuiltins(spirvInst.set.c_str()),
+                    spirvInst.id, {operand});
+            }
+
+            if (node->getBasicType() == glslang::EbtVoid)
+                return false; // done with this node
+        }
+    }
+#endif
+
     if (result) {
         if (invertedType) {
             result = createInvertedSwizzle(decorations.precision, *node->getOperand(), result);
@@ -3037,6 +3172,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             if (arg == 1)
                 lvalue = true;
             break;
+        case glslang::EOpSpirvInst:
+            if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference())
+                lvalue = true;
+            break;
 #endif
         default:
             break;
@@ -3142,7 +3281,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                  visitSymbol(itNode->second);
                  spv::Id symId = getSymbolId(itNode->second);
                  operands.push_back(symId);
-             } else {
+#ifndef GLSLANG_WEB
+             } else if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvLiteral()) {
+                 // Will be translated to a literal value, make a placeholder here
+                 operands.push_back(spv::NoResult);
+#endif
+             } else  {
                 operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType()));
              }
         }
@@ -3184,6 +3328,34 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             ? node->getSequence()[0]->getAsTyped()->getBasicType() : node->getBasicType();
         result = createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
             lvalueCoherentFlags);
+#ifndef GLSLANG_WEB
+    } else if (node->getOp() == glslang::EOpSpirvInst) {
+        const auto& spirvInst = node->getSpirvInstruction();
+        if (spirvInst.set == "") {
+            std::vector<spv::IdImmediate> idImmOps;
+            for (int i = 0; i < glslangOperands.size(); ++i) {
+                if (glslangOperands[i]->getAsTyped()->getQualifier().isSpirvLiteral()) {
+                    // Translate the constant to a literal value
+                    std::vector<unsigned> literals;
+                    glslang::TVector<const glslang::TIntermConstantUnion*> constants;
+                    constants.push_back(glslangOperands[i]->getAsConstantUnion());
+                    TranslateLiterals(constants, literals);
+                    idImmOps.push_back({false, literals[0]});
+                } else
+                    idImmOps.push_back({true, operands[i]});
+            }
+
+            if (node->getBasicType() == glslang::EbtVoid)
+                builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), idImmOps);
+            else
+                result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), idImmOps);
+        } else {
+            result = builder.createBuiltinCall(
+                resultType(), spirvInst.set == "GLSL.std.450" ? stdBuiltins : getExtBuiltins(spirvInst.set.c_str()),
+                spirvInst.id, operands);
+        }
+        noReturnValue = node->getBasicType() == glslang::EbtVoid;
+#endif
     } else if (node->getOp() == glslang::EOpDebugPrintf) {
         if (!nonSemanticDebugPrintf) {
             nonSemanticDebugPrintf = builder.import("NonSemantic.DebugPrintf");
@@ -3464,6 +3636,11 @@ bool TGlslangToSpvTraverser::visitSwitch(glslang::TVisit /* visit */, glslang::T
 
 void TGlslangToSpvTraverser::visitConstantUnion(glslang::TIntermConstantUnion* node)
 {
+#ifndef GLSLANG_WEB
+    if (node->getQualifier().isSpirvLiteral())
+        return; // Translated to a literal value, skip further processing
+#endif
+
     int nextConst = 0;
     spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false);
 
@@ -3912,6 +4089,77 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
     case glslang::EbtString:
         // no type used for OpString
         return 0;
+#ifndef GLSLANG_WEB
+    case glslang::EbtSpirvType: {
+        // GL_EXT_spirv_intrinsics
+        const auto& spirvType = type.getSpirvType();
+        const auto& spirvInst = spirvType.spirvInst;
+
+        std::vector<spv::Id> operands;
+        for (const auto& typeParam : spirvType.typeParams) {
+            if (typeParam.isConstant) {
+                // Constant expression
+                if (typeParam.constant->isLiteral()) {
+                    if (typeParam.constant->getBasicType() == glslang::EbtFloat) {
+                        float floatValue = static_cast<float>(typeParam.constant->getConstArray()[0].getDConst());
+                        unsigned literal = *reinterpret_cast<unsigned*>(&floatValue);
+                        operands.push_back(literal);
+                    } else if (typeParam.constant->getBasicType() == glslang::EbtInt) {
+                        unsigned literal = typeParam.constant->getConstArray()[0].getIConst();
+                        operands.push_back(literal);
+                    } else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
+                        unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
+                        operands.push_back(literal);
+                    } else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
+                        unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
+                        operands.push_back(literal);
+                    } else if (typeParam.constant->getBasicType() == glslang::EbtString) {
+                        auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
+                        unsigned literal = 0;
+                        char* literalPtr = reinterpret_cast<char*>(&literal);
+                        unsigned charCount = 0;
+                        char ch = 0;
+                        do {
+                            ch = *(str++);
+                            *(literalPtr++) = ch;
+                            ++charCount;
+                            if (charCount == 4) {
+                                operands.push_back(literal);
+                                literalPtr = reinterpret_cast<char*>(&literal);
+                                charCount = 0;
+                            }
+                        } while (ch != 0);
+
+                        // Partial literal is padded with 0
+                        if (charCount > 0) {
+                            for (; charCount < 4; ++charCount)
+                                *(literalPtr++) = 0;
+                            operands.push_back(literal);
+                        }
+                    } else
+                        assert(0); // Unexpected type
+                } else {
+                    int nextConst = 0;
+                    spv::Id constant = createSpvConstantFromConstUnionArray(
+                        typeParam.constant->getType(), typeParam.constant->getConstArray(), nextConst, false);
+                    operands.push_back(constant);
+                }
+            } else {
+                // Type specifier
+                spv::Id typeId = convertGlslangToSpvType(*typeParam.type);
+                operands.push_back(typeId);
+            }
+        }
+
+        if (spirvInst.set == "")
+            spvType = builder.createOp(static_cast<spv::Op>(spirvInst.id), spv::NoType, operands);
+        else {
+            spvType = builder.createBuiltinCall(
+                spv::NoType, getExtBuiltins(spirvInst.set.c_str()), spirvInst.id, operands);
+        }
+        break;
+    }
+#endif
     default:
         assert(0);
         break;
@@ -4225,6 +4473,38 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
             builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
             builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
         }
+
+        //
+        // Add SPIR-V decorations for members (GL_EXT_spirv_intrinsics)
+        //
+        if (glslangMember.getQualifier().hasSprivDecorate()) {
+            const glslang::TSpirvDecorate& spirvDecorate = glslangMember.getQualifier().getSpirvDecorate();
+
+            // Add spirv_decorate
+            for (auto& decorate : spirvDecorate.decorates) {
+                if (!decorate.second.empty()) {
+                    std::vector<unsigned> literals;
+                    TranslateLiterals(decorate.second, literals);
+                    builder.addMemberDecoration(spvType, member, static_cast<spv::Decoration>(decorate.first), literals);
+                }
+                else
+                    builder.addMemberDecoration(spvType, member, static_cast<spv::Decoration>(decorate.first));
+            }
+
+            // spirv_decorate_id not applied to members
+            assert(spirvDecorate.decorateIds.empty());
+
+            // Add spirv_decorate_string
+            for (auto& decorateString : spirvDecorate.decorateStrings) {
+                std::vector<const char*> strings;
+                assert(!decorateString.second.empty());
+                for (auto extraOperand : decorateString.second) {
+                    const char* string = extraOperand->getConstArray()[0].getSConst()->c_str();
+                    strings.push_back(string);
+                }
+                builder.addDecoration(spvType, static_cast<spv::Decoration>(decorateString.first), strings);
+            }
+        }
 #endif
     }
 
@@ -4614,6 +4894,9 @@ bool TGlslangToSpvTraverser::originalParam(glslang::TStorageQualifier qualifier,
     if (glslangIntermediate->getSource() == glslang::EShSourceHlsl)
         return paramType.getBasicType() == glslang::EbtBlock;
     return paramType.containsOpaque() ||                                                       // sampler, etc.
+#ifndef GLSLANG_WEB
+           paramType.getQualifier().isSpirvByReference() ||                                    // spirv_by_reference
+#endif
            (paramType.getBasicType() == glslang::EbtBlock && qualifier == glslang::EvqBuffer); // SSBO
 }
 
@@ -8465,6 +8748,48 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
         builder.addDecoration(id, symbol->getType().getQualifier().restrict ?
             spv::DecorationRestrictPointerEXT : spv::DecorationAliasedPointerEXT);
     }
+
+    //
+    // Add SPIR-V decorations for structure (GL_EXT_spirv_intrinsics)
+    //
+    if (symbol->getType().getQualifier().hasSprivDecorate()) {
+        const glslang::TSpirvDecorate& spirvDecorate = symbol->getType().getQualifier().getSpirvDecorate();
+
+        // Add spirv_decorate
+        for (auto& decorate : spirvDecorate.decorates) {
+            if (!decorate.second.empty()) {
+                std::vector<unsigned> literals;
+                TranslateLiterals(decorate.second, literals);
+                builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first), literals);
+            }
+            else
+                builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first));
+        }
+
+        // Add spirv_decorate_id
+        for (auto& decorateId : spirvDecorate.decorateIds) {
+            std::vector<spv::Id> operandIds;
+            assert(!decorateId.second.empty());
+            for (auto extraOperand : decorateId.second) {
+                int nextConst = 0;
+                spv::Id operandId = createSpvConstantFromConstUnionArray(
+                    extraOperand->getType(), extraOperand->getConstArray(), nextConst, false);
+                operandIds.push_back(operandId);
+            }
+            builder.addDecoration(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
+        }
+
+        // Add spirv_decorate_string
+        for (auto& decorateString : spirvDecorate.decorateStrings) {
+            std::vector<const char*> strings;
+            assert(!decorateString.second.empty());
+            for (auto extraOperand : decorateString.second) {
+                const char* string = extraOperand->getConstArray()[0].getSConst()->c_str();
+                strings.push_back(string);
+            }
+            builder.addDecoration(id, static_cast<spv::Decoration>(decorateString.first), strings);
+        }
+    }
 #endif
 
     return id;

diff --git a/Test/baseResults/cppBad.vert.out b/Test/baseResults/cppBad.vert.out
index aaecdf0..8ab04bc 100644 (file)
--- a/Test/baseResults/cppBad.vert.out
+++ b/Test/baseResults/cppBad.vert.out
@@ -3,7 +3,9 @@ WARNING: 0:1: '#define' : missing space after macro name
 ERROR: 0:3: 'preprocessor evaluation' : bad expression 
 ERROR: 0:3: '#if' : unexpected tokens following directive 
 ERROR: 0:6: 'string' : End of line in string 
-ERROR: 0:6: 'string literal' : required extension not requested: GL_EXT_debug_printf
+ERROR: 0:6: 'string literal' : required extension not requested: Possible extensions include:
+GL_EXT_debug_printf
+GL_EXT_spirv_intrinsics
 ERROR: 0:6: '' :  syntax error, unexpected INT, expecting COMMA or SEMICOLON
 ERROR: 5 compilation errors.  No code generated.
 

diff --git a/Test/baseResults/cppSimple.vert.out b/Test/baseResults/cppSimple.vert.out
index 3257856..0646c5f 100644 (file)
--- a/Test/baseResults/cppSimple.vert.out
+++ b/Test/baseResults/cppSimple.vert.out
@@ -18,8 +18,12 @@ ERROR: 0:117: '#error' : bad5
 ERROR: 0:120: '#if' : unexpected tokens following directive 
 ERROR: 0:121: '#error' : bad6  
 ERROR: 0:122: '#endif' : unexpected tokens following directive 
-ERROR: 0:135: 'string literal' : required extension not requested: GL_EXT_debug_printf
-ERROR: 0:136: 'string literal' : required extension not requested: GL_EXT_debug_printf
+ERROR: 0:135: 'string literal' : required extension not requested: Possible extensions include:
+GL_EXT_debug_printf
+GL_EXT_spirv_intrinsics
+ERROR: 0:136: 'string literal' : required extension not requested: Possible extensions include:
+GL_EXT_debug_printf
+GL_EXT_spirv_intrinsics
 ERROR: 0:136: 'length' : no matching overloaded function found 
 ERROR: 0:136: '=' :  cannot convert from ' const float' to ' global int'
 ERROR: 0:138: ''' : character literals not supported 

diff --git a/Test/baseResults/spv.intrinsicsSpirvByReference.vert.out b/Test/baseResults/spv.intrinsicsSpirvByReference.vert.out
new file mode 100644 (file)
index 0000000..d46b33f
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvByReference.vert.out
@@ -0,0 +1,56 @@
+spv.intrinsicsSpirvByReference.vert
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 30
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 15 17 26
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 10  "func(f1;"
+                              Name 9  "f"
+                              Name 15  "vec2Out"
+                              Name 17  "floatIn"
+                              Name 26  "floatOut"
+                              Name 27  "param"
+                              Decorate 15(vec2Out) Location 0
+                              Decorate 17(floatIn) Location 0
+                              Decorate 26(floatOut) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypePointer Function 6(float)
+               8:             TypeFunction 2 7(ptr)
+              12:    6(float) Constant 1056964608
+              13:             TypeVector 6(float) 2
+              14:             TypePointer Output 13(fvec2)
+     15(vec2Out):     14(ptr) Variable Output
+              16:             TypePointer Input 6(float)
+     17(floatIn):     16(ptr) Variable Input
+              19:             TypeInt 32 0
+              20:     19(int) Constant 1
+              21:             TypePointer Output 6(float)
+              24:     19(int) Constant 0
+    26(floatOut):     21(ptr) Variable Output
+         4(main):           2 Function None 3
+               5:             Label
+       27(param):      7(ptr) Variable Function
+              18:    6(float) Load 17(floatIn)
+              22:     21(ptr) AccessChain 15(vec2Out) 20
+              23:    6(float) ExtInst 1(GLSL.std.450) 35(Modf) 18 22
+              25:     21(ptr) AccessChain 15(vec2Out) 24
+                              Store 25 23
+              28:    6(float) Load 26(floatOut)
+                              Store 27(param) 28
+              29:           2 FunctionCall 10(func(f1;) 27(param)
+                              Return
+                              FunctionEnd
+    10(func(f1;):           2 Function None 8
+            9(f):      7(ptr) FunctionParameter
+              11:             Label
+                              Store 9(f) 12
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvDecorate.frag.out b/Test/baseResults/spv.intrinsicsSpirvDecorate.frag.out
new file mode 100644 (file)
index 0000000..cbd46b0
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvDecorate.frag.out
@@ -0,0 +1,88 @@
+spv.intrinsicsSpirvDecorate.frag
+Validation failed
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 43
+
+                              Capability Shader
+                              Extension  "SPV_AMD_shader_explicit_vertex_parameter"
+               1:             ExtInstImport  "GLSL.std.450"
+              14:             ExtInstImport  "SPV_AMD_shader_explicit_vertex_parameter"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 8 10 18 20 22 25 28 31 34 39
+                              ExecutionMode 4 OriginUpperLeft
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 8  "floatOut"
+                              Name 10  "floatIn"
+                              Name 18  "vec2Out"
+                              Name 20  "gl_BaryCoordNoPerspAMD"
+                              Name 22  "gl_BaryCoordNoPerspCentroidAMD"
+                              Name 25  "gl_BaryCoordNoPerspSampleAMD"
+                              Name 28  "gl_BaryCoordSmoothAMD"
+                              Name 31  "gl_BaryCoordSmoothCentroidAMD"
+                              Name 34  "gl_BaryCoordSmoothSampleAMD"
+                              Name 39  "gl_BaryCoordPullModelAMD"
+                              Decorate 8(floatOut) Location 0
+                              Decorate 10(floatIn) Location 0
+                              Decorate 10(floatIn) ExplicitInterpAMD
+                              Decorate 18(vec2Out) Location 1
+                              Decorate 20(gl_BaryCoordNoPerspAMD) Location 0
+                              Decorate 20(gl_BaryCoordNoPerspAMD) BuiltIn BaryCoordNoPerspAMD
+                              Decorate 22(gl_BaryCoordNoPerspCentroidAMD) Location 1
+                              Decorate 22(gl_BaryCoordNoPerspCentroidAMD) BuiltIn BaryCoordNoPerspCentroidAMD
+                              Decorate 25(gl_BaryCoordNoPerspSampleAMD) Location 2
+                              Decorate 25(gl_BaryCoordNoPerspSampleAMD) BuiltIn BaryCoordNoPerspSampleAMD
+                              Decorate 28(gl_BaryCoordSmoothAMD) Location 3
+                              Decorate 28(gl_BaryCoordSmoothAMD) BuiltIn BaryCoordSmoothAMD
+                              Decorate 31(gl_BaryCoordSmoothCentroidAMD) Location 4
+                              Decorate 31(gl_BaryCoordSmoothCentroidAMD) BuiltIn BaryCoordSmoothCentroidAMD
+                              Decorate 34(gl_BaryCoordSmoothSampleAMD) Location 5
+                              Decorate 34(gl_BaryCoordSmoothSampleAMD) BuiltIn BaryCoordSmoothSampleAMD
+                              Decorate 39(gl_BaryCoordPullModelAMD) Location 6
+                              Decorate 39(gl_BaryCoordPullModelAMD) BuiltIn BaryCoordPullModelAMD
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypePointer Output 6(float)
+     8(floatOut):      7(ptr) Variable Output
+               9:             TypePointer Input 6(float)
+     10(floatIn):      9(ptr) Variable Input
+              12:             TypeInt 32 0
+              13:     12(int) Constant 1
+              16:             TypeVector 6(float) 2
+              17:             TypePointer Output 16(fvec2)
+     18(vec2Out):     17(ptr) Variable Output
+              19:             TypePointer Input 16(fvec2)
+20(gl_BaryCoordNoPerspAMD):     19(ptr) Variable Input
+22(gl_BaryCoordNoPerspCentroidAMD):     19(ptr) Variable Input
+25(gl_BaryCoordNoPerspSampleAMD):     19(ptr) Variable Input
+28(gl_BaryCoordSmoothAMD):     19(ptr) Variable Input
+31(gl_BaryCoordSmoothCentroidAMD):     19(ptr) Variable Input
+34(gl_BaryCoordSmoothSampleAMD):     19(ptr) Variable Input
+              37:             TypeVector 6(float) 3
+              38:             TypePointer Input 37(fvec3)
+39(gl_BaryCoordPullModelAMD):     38(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              11:    6(float) Load 10(floatIn)
+              15:    6(float) ExtInst 14(SPV_AMD_shader_explicit_vertex_parameter) 1(InterpolateAtVertexAMD) 11 13
+                              Store 8(floatOut) 15
+              21:   16(fvec2) Load 20(gl_BaryCoordNoPerspAMD)
+              23:   16(fvec2) Load 22(gl_BaryCoordNoPerspCentroidAMD)
+              24:   16(fvec2) FAdd 21 23
+              26:   16(fvec2) Load 25(gl_BaryCoordNoPerspSampleAMD)
+              27:   16(fvec2) FAdd 24 26
+              29:   16(fvec2) Load 28(gl_BaryCoordSmoothAMD)
+              30:   16(fvec2) FAdd 27 29
+              32:   16(fvec2) Load 31(gl_BaryCoordSmoothCentroidAMD)
+              33:   16(fvec2) FAdd 30 32
+              35:   16(fvec2) Load 34(gl_BaryCoordSmoothSampleAMD)
+              36:   16(fvec2) FAdd 33 35
+              40:   37(fvec3) Load 39(gl_BaryCoordPullModelAMD)
+              41:   16(fvec2) VectorShuffle 40 40 0 1
+              42:   16(fvec2) FAdd 36 41
+                              Store 18(vec2Out) 42
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvExecutionMode.frag.out b/Test/baseResults/spv.intrinsicsSpirvExecutionMode.frag.out
new file mode 100644 (file)
index 0000000..22bc53b
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvExecutionMode.frag.out
@@ -0,0 +1,36 @@
+spv.intrinsicsSpirvExecutionMode.frag
+Validation failed
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 12
+
+                              Capability Shader
+                              Capability StencilExportEXT
+                              Extension  "SPV_EXT_shader_stencil_export"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 8 10
+                              ExecutionMode 4 OriginUpperLeft
+                              ExecutionMode 4 StencilRefReplacingEXT
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 8  "gl_FragStencilRef"
+                              Name 10  "color"
+                              Decorate 8(gl_FragStencilRef) Location 0
+                              Decorate 8(gl_FragStencilRef) BuiltIn FragStencilRefEXT
+                              Decorate 10(color) Flat
+                              Decorate 10(color) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeInt 32 1
+               7:             TypePointer Output 6(int)
+8(gl_FragStencilRef):      7(ptr) Variable Output
+               9:             TypePointer Input 6(int)
+       10(color):      9(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              11:      6(int) Load 10(color)
+                              Store 8(gl_FragStencilRef) 11
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvInstruction.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstruction.vert.out
new file mode 100644 (file)
index 0000000..0e2780c
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvInstruction.vert.out
@@ -0,0 +1,59 @@
+spv.intrinsicsSpirvInstruction.vert
+Validation failed
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 30
+
+                              Capability Shader
+                              Capability Int64
+                              Capability ShaderClockKHR
+                              Extension  "SPV_AMD_shader_trinary_minmax"
+                              Extension  "SPV_KHR_shader_clock"
+               1:             ExtInstImport  "GLSL.std.450"
+              28:             ExtInstImport  "SPV_AMD_shader_trinary_minmax"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 9 13 18 21
+                              Source GLSL 450
+                              SourceExtension  "GL_ARB_gpu_shader_int64"
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 9  "uvec2Out"
+                              Name 13  "i64Out"
+                              Name 18  "vec2Out"
+                              Name 21  "vec3In"
+                              Decorate 9(uvec2Out) Location 0
+                              Decorate 13(i64Out) Location 1
+                              Decorate 18(vec2Out) Location 2
+                              Decorate 21(vec3In) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeInt 32 0
+               7:             TypeVector 6(int) 2
+               8:             TypePointer Output 7(ivec2)
+     9(uvec2Out):      8(ptr) Variable Output
+              11:             TypeInt 64 1
+              12:             TypePointer Output 11(int64_t)
+      13(i64Out):     12(ptr) Variable Output
+              15:             TypeFloat 32
+              16:             TypeVector 15(float) 2
+              17:             TypePointer Output 16(fvec2)
+     18(vec2Out):     17(ptr) Variable Output
+              19:             TypeVector 15(float) 3
+              20:             TypePointer Input 19(fvec3)
+      21(vec3In):     20(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              10:    7(ivec2) ReadClockKHR
+                              Store 9(uvec2Out) 10
+              14: 11(int64_t) ReadClockKHR
+                              Store 13(i64Out) 14
+              22:   19(fvec3) Load 21(vec3In)
+              23:   16(fvec2) VectorShuffle 22 22 0 1
+              24:   19(fvec3) Load 21(vec3In)
+              25:   16(fvec2) VectorShuffle 24 24 1 2
+              26:   19(fvec3) Load 21(vec3In)
+              27:   16(fvec2) VectorShuffle 26 26 2 0
+              29:   16(fvec2) ExtInst 28(SPV_AMD_shader_trinary_minmax) 1(FMin3AMD) 23 25 27
+                              Store 18(vec2Out) 29
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvLiteral.vert.out b/Test/baseResults/spv.intrinsicsSpirvLiteral.vert.out
new file mode 100644 (file)
index 0000000..af4ac16
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvLiteral.vert.out
@@ -0,0 +1,29 @@
+spv.intrinsicsSpirvLiteral.vert
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 12
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main"
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 9  "vec4Out"
+                              Name 10  "vec4In"
+                              Decorate 9(vec4Out) Location 1
+                              Decorate 10(vec4In) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Function 7(fvec4)
+         4(main):           2 Function None 3
+               5:             Label
+      9(vec4Out):      8(ptr) Variable Function
+      10(vec4In):      8(ptr) Variable Function
+              11:    7(fvec4) Load 10(vec4In) None
+                              Store 9(vec4Out) 11 Volatile 
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvStorageClass.rchit.out b/Test/baseResults/spv.intrinsicsSpirvStorageClass.rchit.out
new file mode 100644 (file)
index 0000000..4be5b91
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvStorageClass.rchit.out
@@ -0,0 +1,30 @@
+spv.intrinsicsSpirvStorageClass.rchit
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 13
+
+                              Capability RayTracingKHR
+                              Capability RayTracingProvisionalKHR
+                              Extension  "SPV_KHR_ray_tracing"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint ClosestHitKHR 4  "main"
+                              Source GLSL 460
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 9  "payload"
+                              Decorate 9(payload) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer RayPayloadKHR 7(fvec4)
+      9(payload):      8(ptr) Variable RayPayloadKHR
+              10:    6(float) Constant 0
+              11:    6(float) Constant 1065353216
+              12:    7(fvec4) ConstantComposite 10 11 10 11
+         4(main):           2 Function None 3
+               5:             Label
+                              Store 9(payload) 12
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.intrinsicsSpirvType.rgen.out b/Test/baseResults/spv.intrinsicsSpirvType.rgen.out
new file mode 100644 (file)
index 0000000..ac0c946
--- /dev/null
+++ b/Test/baseResults/spv.intrinsicsSpirvType.rgen.out
@@ -0,0 +1,45 @@
+spv.intrinsicsSpirvType.rgen
+Validation failed
+// Module Version 10000
+// Generated by (magic number): 8000a
+// Id's are bound by 21
+
+                              Capability RayQueryKHR
+                              Capability RayTraversalPrimitiveCullingKHR
+                              Capability RayTracingKHR
+                              Extension  "SPV_KHR_ray_query"
+                              Extension  "SPV_KHR_ray_tracing"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint RayGenerationKHR 4  "main"
+                              Source GLSL 460
+                              SourceExtension  "GL_EXT_spirv_intrinsics"
+                              Name 4  "main"
+                              Name 8  "rq"
+                              Name 11  "as"
+                              Decorate 11(as) Location 0
+                              Decorate 11(as) DescriptorSet 0
+                              Decorate 11(as) Binding 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               7:             TypePointer Function 6
+              10:             TypePointer UniformConstant 9
+          11(as):     10(ptr) Variable UniformConstant
+              13:             TypeInt 32 0
+              14:     13(int) Constant 0
+              15:             TypeFloat 32
+              16:             TypeVector 15(float) 3
+              17:   15(float) Constant 0
+              18:   16(fvec3) ConstantComposite 17 17 17
+              19:   15(float) Constant 1065353216
+              20:   16(fvec3) ConstantComposite 19 19 19
+         4(main):           2 Function None 3
+               5:             Label
+           8(rq):      7(ptr) Variable Function
+               6:             TypeRayQueryKHR
+               9:             TypeAccelerationStructureKHR
+              12:           9 Load 11(as)
+                              RayQueryInitializeKHR 8(rq) 12 14 14 18 17 20 19
+                              RayQueryTerminateKHR 8(rq)
+                              Return
+                              FunctionEnd

diff --git a/Test/spv.intrinsicsSpirvByReference.vert b/Test/spv.intrinsicsSpirvByReference.vert
new file mode 100644 (file)
index 0000000..b02c582
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvByReference.vert
@@ -0,0 +1,21 @@
+#version 450 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+spirv_instruction (set = "GLSL.std.450", id = 35) // modf\r
+float modf(float x, spirv_by_reference float i);\r
+\r
+layout(location = 0) in float floatIn;\r
+layout(location = 0) out vec2 vec2Out;\r
+layout(location = 1) out float floatOut;\r
+\r
+void func(spirv_by_reference float f)\r
+{\r
+    f = 0.5;\r
+}\r
+\r
+void main()\r
+{\r
+    vec2Out.x = modf(floatIn, vec2Out.y);\r
+    func(floatOut);\r
+}\r

diff --git a/Test/spv.intrinsicsSpirvDecorate.frag b/Test/spv.intrinsicsSpirvDecorate.frag
new file mode 100644 (file)
index 0000000..8b495cf
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvDecorate.frag
@@ -0,0 +1,37 @@
+#version 450 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+#define GL_AMD_shader_explicit_vertex_parameter 1\r
+\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4992)\r
+in vec2 gl_BaryCoordNoPerspAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4993)\r
+in vec2 gl_BaryCoordNoPerspCentroidAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4994)\r
+in vec2 gl_BaryCoordNoPerspSampleAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4995)\r
+in vec2 gl_BaryCoordSmoothAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4996)\r
+in vec2 gl_BaryCoordSmoothCentroidAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4997)\r
+in vec2 gl_BaryCoordSmoothSampleAMD;\r
+spirv_decorate (extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 11, 4998)\r
+in vec3 gl_BaryCoordPullModelAMD;\r
+\r
+#define __explicitInterpAMD spirv_decorate(extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], 4999)\r
+\r
+spirv_instruction(extensions = ["SPV_AMD_shader_explicit_vertex_parameter"], set = "SPV_AMD_shader_explicit_vertex_parameter", id = 1)\r
+float interpolateAtVertexAMD(float interpolant, uint vertexIdx);\r
+\r
+layout(location = 0) in __explicitInterpAMD float floatIn;\r
+layout(location = 0) out float floatOut;\r
+layout(location = 1) out vec2 vec2Out;\r
+\r
+void main()\r
+{\r
+    floatOut = interpolateAtVertexAMD(floatIn, 1);\r
+    vec2Out = gl_BaryCoordNoPerspAMD + gl_BaryCoordNoPerspCentroidAMD + gl_BaryCoordNoPerspSampleAMD +\r
+              gl_BaryCoordSmoothAMD + gl_BaryCoordSmoothCentroidAMD + gl_BaryCoordSmoothSampleAMD +\r
+              gl_BaryCoordPullModelAMD.xy;\r
+}\r

diff --git a/Test/spv.intrinsicsSpirvExecutionMode.frag b/Test/spv.intrinsicsSpirvExecutionMode.frag
new file mode 100644 (file)
index 0000000..9213e74
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvExecutionMode.frag
@@ -0,0 +1,17 @@
+#version 450 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+#define GL_ARB_shader_stencil_export 1\r
+\r
+spirv_execution_mode(5027); // StencilRefReplacingEXT\r
+\r
+spirv_decorate(extensions = ["SPV_EXT_shader_stencil_export"], capabilities = [5013], 11, 5014)\r
+out int gl_FragStencilRef;\r
+\r
+layout(location = 0) in flat int color;\r
+\r
+void main()\r
+{\r
+    gl_FragStencilRef = color;\r
+}\r

diff --git a/Test/spv.intrinsicsSpirvInstruction.vert b/Test/spv.intrinsicsSpirvInstruction.vert
new file mode 100644 (file)
index 0000000..a4efb7d
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvInstruction.vert
@@ -0,0 +1,26 @@
+#version 450 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+#extension GL_ARB_gpu_shader_int64: enable\r
+\r
+spirv_instruction (extensions = ["SPV_KHR_shader_clock"], capabilities = [5055], id = 5056)\r
+uvec2 clockRealtime2x32EXT(void);\r
+\r
+spirv_instruction (extensions = ["SPV_KHR_shader_clock"], capabilities = [5055], id = 5056)\r
+int64_t clockRealtimeEXT(void);\r
+\r
+spirv_instruction (extensions = ["SPV_AMD_shader_trinary_minmax"], set = "SPV_AMD_shader_trinary_minmax", id = 1)\r
+vec2 min3(vec2 x, vec2 y, vec2 z);\r
+\r
+layout(location = 0) in vec3 vec3In;\r
+\r
+layout(location = 0) out uvec2 uvec2Out;\r
+layout(location = 1) out int64_t i64Out;\r
+layout(location = 2) out vec2 vec2Out;\r
+\r
+void main()\r
+{\r
+    uvec2Out = clockRealtime2x32EXT();\r
+    i64Out = clockRealtimeEXT();\r
+    vec2Out = min3(vec3In.xy, vec3In.yz, vec3In.zx); \r
+}\r

diff --git a/Test/spv.intrinsicsSpirvLiteral.vert b/Test/spv.intrinsicsSpirvLiteral.vert
new file mode 100644 (file)
index 0000000..a6c012f
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvLiteral.vert
@@ -0,0 +1,17 @@
+#version 450 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+spirv_instruction(id = 61)\r
+vec4 load(spirv_by_reference vec4 pointer, spirv_literal int memoryOperands);\r
+\r
+spirv_instruction(id = 62)\r
+void store(spirv_by_reference vec4 pointer, vec4 object, spirv_literal int memoryOperands);\r
+\r
+layout(location = 0) in vec4 vec4In;\r
+layout(location = 1) out vec4 vec4Out;\r
+\r
+void main()\r
+{\r
+    store(vec4Out, load(vec4In, /*None=*/0x0), /*Volatile=*/0x1);\r
+}\r

diff --git a/Test/spv.intrinsicsSpirvStorageClass.rchit b/Test/spv.intrinsicsSpirvStorageClass.rchit
new file mode 100644 (file)
index 0000000..5d23d4f
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvStorageClass.rchit
@@ -0,0 +1,12 @@
+#version 460\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+#define rayPayloadEXT spirv_storage_class(extensions = ["SPV_KHR_ray_tracing"], capabilities = [5353], 5338)\r
+\r
+layout(location = 1) rayPayloadEXT vec4 payload;\r
+\r
+void main()\r
+{\r
+    payload = vec4(0.0, 1.0, 0.0, 1.0);\r
+}\r

diff --git a/Test/spv.intrinsicsSpirvType.rgen b/Test/spv.intrinsicsSpirvType.rgen
new file mode 100644 (file)
index 0000000..bed0729
--- /dev/null
+++ b/Test/spv.intrinsicsSpirvType.rgen
@@ -0,0 +1,22 @@
+#version 460 core\r
+\r
+#extension GL_EXT_spirv_intrinsics: enable\r
+\r
+#define rayQueryEXT spirv_type (extensions = ["SPV_KHR_ray_query"], capabilities = [4472], id = 4472)\r
+#define accelerationStructureEXT spirv_type (extensions = ["SPV_KHR_ray_query"], capabilities = [4472], id = 5341)\r
+\r
+spirv_instruction (extensions = ["SPV_KHR_ray_query"], capabilities = [4472, 4478], id = 4473)\r
+void rayQueryInitializeEXT(spirv_by_reference rayQueryEXT rayQuery, accelerationStructureEXT topLevel, uint rayFlags, uint cullMask, vec3 origin, float tMin, vec3 direction, float tMax);\r
+\r
+spirv_instruction (extensions = ["SPV_KHR_ray_query"], capabilities = [4478], id = 4474)\r
+void rayQueryTerminateEXT(spirv_by_reference rayQueryEXT rayQuery);\r
+\r
+layout(binding = 0) uniform accelerationStructureEXT as;\r
+\r
+void main()\r
+{\r
+    rayQueryEXT rq;\r
+\r
+    rayQueryInitializeEXT(rq, as, 0, 0, vec3(0.0), 0.0, vec3(1.0), 1.0);\r
+    rayQueryTerminateEXT(rq);\r
+}\r

diff --git a/glslang/CMakeLists.txt b/glslang/CMakeLists.txt
index fc925ea..dab5f8b 100644 (file)
--- a/glslang/CMakeLists.txt
+++ b/glslang/CMakeLists.txt
@@ -73,6 +73,7 @@ set(MACHINEINDEPENDENT_SOURCES
     MachineIndependent/RemoveTree.cpp
     MachineIndependent/Scan.cpp
     MachineIndependent/ShaderLang.cpp
+    MachineIndependent/SpirvIntrinsics.cpp
     MachineIndependent/SymbolTable.cpp
     MachineIndependent/Versions.cpp
     MachineIndependent/intermOut.cpp
@@ -160,6 +161,7 @@ set(GLSLANG_HEADERS
     Include/PoolAlloc.h
     Include/ResourceLimits.h
     Include/ShHandle.h
+    Include/SpirvIntrinsics.h
     Include/Types.h)
 
 add_library(glslang ${LIB_TYPE} ${BISON_GLSLParser_OUTPUT_SOURCE} ${GLSLANG_SOURCES} ${GLSLANG_HEADERS})

diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h
index 55bdd25..1d9da12 100644 (file)
--- a/glslang/Include/BaseTypes.h
+++ b/glslang/Include/BaseTypes.h
@@ -65,6 +65,10 @@ enum TBasicType {
     EbtAccStruct,
     EbtReference,
     EbtRayQuery,
+#ifndef GLSLANG_WEB
+    // SPIR-V type defined by spirv_type
+    EbtSpirvType,
+#endif
 
     // HLSL types that live only temporarily.
     EbtString,
@@ -91,6 +95,9 @@ enum TStorageQualifier {
     EvqUniform,       // read only, shared with app
     EvqBuffer,        // read/write, shared with app
     EvqShared,        // compute shader's read/write 'shared' qualifier
+#ifndef GLSLANG_WEB
+    EvqSpirvStorageClass, // spirv_storage_class
+#endif
 
     EvqPayload,
     EvqPayloadIn,
@@ -321,6 +328,9 @@ __inline const char* GetStorageQualifierString(TStorageQualifier q)
     case EvqGlobal:         return "global";         break;
     case EvqConst:          return "const";          break;
     case EvqConstReadOnly:  return "const (read only)"; break;
+#ifndef GLSLANG_WEB
+    case EvqSpirvStorageClass: return "spirv_storage_class"; break;
+#endif
     case EvqVaryingIn:      return "in";             break;
     case EvqVaryingOut:     return "out";            break;
     case EvqUniform:        return "uniform";        break;

diff --git a/glslang/Include/Common.h b/glslang/Include/Common.h
index 89f0192..1e47239 100644 (file)
--- a/glslang/Include/Common.h
+++ b/glslang/Include/Common.h
@@ -194,6 +194,10 @@ template <class K, class D, class HASH = std::hash<K>, class PRED = std::equal_t
 class TUnorderedMap : public std::unordered_map<K, D, HASH, PRED, pool_allocator<std::pair<K const, D> > > {
 };
 
+template <class K, class CMP = std::less<K> >
+class TSet : public std::set<K, CMP, pool_allocator<K> > {
+};
+
 //
 // Persistent string memory.  Should only be used for strings that survive
 // across compiles/links.

diff --git a/glslang/Include/SpirvIntrinsics.h b/glslang/Include/SpirvIntrinsics.h
new file mode 100644 (file)
index 0000000..e7a999d
--- /dev/null
+++ b/glslang/Include/SpirvIntrinsics.h
@@ -0,0 +1,136 @@
+//
+// Copyright(C) 2021 Advanced Micro Devices, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+
+#pragma once
+
+#ifndef GLSLANG_WEB
+
+//
+// GL_EXT_spirv_intrinsics
+//
+#include "Common.h"
+
+namespace glslang {
+
+class TIntermTyped;
+class TIntermConstantUnion;
+class TType;
+
+// SPIR-V requirements
+struct TSpirvRequirement {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    // capability = [..]
+    TSet<TString> extensions;
+    // extension = [..]
+    TSet<int> capabilities;
+};
+
+// SPIR-V execution modes
+struct TSpirvExecutionMode {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    // spirv_execution_mode
+    TMap<int, TVector<const TIntermConstantUnion*>> modes;
+    // spirv_execution_mode_id
+    TMap<int, TVector<const TIntermConstantUnion*> > modeIds;
+};
+
+// SPIR-V decorations
+struct TSpirvDecorate {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    // spirv_decorate
+    TMap<int, TVector<const TIntermConstantUnion*> > decorates;
+    // spirv_decorate_id
+    TMap<int, TVector<const TIntermConstantUnion*> > decorateIds;
+    // spirv_decorate_string
+    TMap<int, TVector<const TIntermConstantUnion*> > decorateStrings;
+};
+
+// SPIR-V instruction
+struct TSpirvInstruction {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    TSpirvInstruction() { set = ""; id = -1; }
+
+    bool operator==(const TSpirvInstruction& rhs) const { return set == rhs.set && id == rhs.id; }
+    bool operator!=(const TSpirvInstruction& rhs) const { return !operator==(rhs); }
+
+    // spirv_instruction
+    TString set;
+    int     id;
+};
+
+// SPIR-V type parameter
+struct TSpirvTypeParameter {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    TSpirvTypeParameter(const TIntermConstantUnion* arg) { isConstant = true; constant = arg; }
+    TSpirvTypeParameter(const TType* arg) { isConstant = false; type = arg; }
+
+    bool operator==(const TSpirvTypeParameter& rhs) const
+    {
+        return isConstant == rhs.isConstant && ((isConstant && constant == rhs.constant) || (!isConstant && type == rhs.type));
+    }
+    bool operator!=(const TSpirvTypeParameter& rhs) const { return !operator==(rhs); }
+
+    bool isConstant;
+    union {
+        const TIntermConstantUnion* constant;
+        const TType* type;
+    };
+};
+
+typedef TVector<TSpirvTypeParameter> TSpirvTypeParameters;
+
+// SPIR-V type
+struct TSpirvType {
+    POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+
+    bool operator==(const TSpirvType& rhs) const
+    {
+        return spirvInst == rhs.spirvInst && typeParams == rhs.typeParams;
+    }
+    bool operator!=(const TSpirvType& rhs) const { return !operator==(rhs); }
+
+    // spirv_type
+    TSpirvInstruction spirvInst;
+    TSpirvTypeParameters typeParams;
+};
+
+} // end namespace glslang
+
+#endif // GLSLANG_WEB

diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h
index 149ba76..a6bf191 100644 (file)
--- a/glslang/Include/Types.h
+++ b/glslang/Include/Types.h
@@ -44,11 +44,14 @@
 #include "../Include/BaseTypes.h"
 #include "../Public/ShaderLang.h"
 #include "arrays.h"
+#include "SpirvIntrinsics.h"
 
 #include <algorithm>
 
 namespace glslang {
 
+class TIntermAggregate;
+
 const int GlslangMaxTypeLength = 200;  // TODO: need to print block/struct one member per line, so this can stay bounded
 
 const char* const AnonymousPrefix = "anon@"; // for something like a block whose members can be directly accessed
@@ -487,7 +490,6 @@ enum TShaderInterface
     EsiCount
 };
 
-
 class TQualifier {
 public:
     static const int layoutNotSet = -1;
@@ -501,6 +503,8 @@ public:
 #ifndef GLSLANG_WEB
         noContraction = false;
         nullInit = false;
+        spirvByReference = false;
+        spirvLiteral = false;
 #endif
         defaultBlock = false;
     }
@@ -518,6 +522,12 @@ public:
         nullInit = false;
         defaultBlock = false;
         clearLayout();
+#ifndef GLSLANG_WEB
+        spirvStorageClass = -1;
+        spirvDecorate = nullptr;
+        spirvByReference = false;
+        spirvLiteral = false;
+#endif
     }
 
     void clearInterstage()
@@ -596,6 +606,10 @@ public:
     bool isPervertexNV() const { return false; }
     void setNullInit() { }
     bool isNullInit() const { return false; }
+    void setSpirvByReference() { }
+    bool isSpirvByReference() { return false; }
+    void setSpirvLiteral() { }
+    bool isSpirvLiteral() { return false; }
 #else
     bool noContraction: 1; // prevent contraction and reassociation, e.g., for 'precise' keyword, and expressions it affects
     bool nopersp      : 1;
@@ -618,6 +632,8 @@ public:
     bool shadercallcoherent : 1;
     bool nonprivate   : 1;
     bool nullInit : 1;
+    bool spirvByReference : 1;
+    bool spirvLiteral : 1;
     bool isWriteOnly() const { return writeonly; }
     bool isReadOnly() const { return readonly; }
     bool isRestrict() const { return restrict; }
@@ -655,6 +671,10 @@ public:
     bool isPervertexNV() const { return pervertexNV; }
     void setNullInit() { nullInit = true; }
     bool isNullInit() const { return nullInit; }
+    void setSpirvByReference() { spirvByReference = true; }
+    bool isSpirvByReference() const { return spirvByReference; }
+    void setSpirvLiteral() { spirvLiteral = true; }
+    bool isSpirvLiteral() const { return spirvLiteral; }
 #endif
 
     bool isPipeInput() const
@@ -948,6 +968,10 @@ public:
     bool layoutViewportRelative;
     int layoutSecondaryViewportRelativeOffset;
     bool layoutShaderRecord;
+
+    // GL_EXT_spirv_intrinsics
+    int spirvStorageClass;
+    TSpirvDecorate* spirvDecorate;
 #endif
 
     bool hasUniformLayout() const
@@ -1079,6 +1103,15 @@ public:
     {
         return nonUniform;
     }
+
+    // GL_EXT_spirv_intrinsics
+    bool hasSprivDecorate() const { return spirvDecorate != nullptr; }
+    void setSpirvDecorate(int decoration, const TIntermAggregate* args = nullptr);
+    void setSpirvDecorateId(int decoration, const TIntermAggregate* args);
+    void setSpirvDecorateString(int decoration, const TIntermAggregate* args);
+    const TSpirvDecorate& getSpirvDecorate() const { assert(spirvDecorate); return *spirvDecorate; }
+    TSpirvDecorate& getSpirvDecorate() { assert(spirvDecorate); return *spirvDecorate; }
+    TString getSpirvDecorateQualifierString() const;
 #endif
     bool hasSpecConstantId() const
     {
@@ -1423,6 +1456,10 @@ public:
     const TType* userDef;
     TSourceLoc loc;
     TArraySizes* typeParameters;
+#ifndef GLSLANG_WEB
+    // SPIR-V type defined by spirv_type directive
+    TSpirvType* spirvType;
+#endif
 
 #ifdef GLSLANG_WEB
     bool isCoopmat() const { return false; }
@@ -1441,6 +1478,9 @@ public:
         loc = l;
         typeParameters = nullptr;
         coopmat = false;
+#ifndef GLSLANG_WEB
+        spirvType = nullptr;
+#endif
     }
 
     void initQualifiers(bool global = false)
@@ -1477,6 +1517,11 @@ public:
         return matrixCols == 0 && vectorSize == 1 && arraySizes == nullptr && userDef == nullptr;
     }
 
+#ifndef GLSLANG_WEB
+    // GL_EXT_spirv_intrinsics
+    void setSpirvType(const TSpirvInstruction& spirvInst, const TSpirvTypeParameters* typeParams = nullptr);
+#endif
+
     // "Image" is a superset of "Subpass"
     bool isImage()   const { return basicType == EbtSampler && sampler.isImage(); }
     bool isSubpass() const { return basicType == EbtSampler && sampler.isSubpass(); }
@@ -1494,6 +1539,9 @@ public:
                    bool isVector = false) :
                             basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false),
                             arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr)
+#ifndef GLSLANG_WEB
+                            , spirvType(nullptr)
+#endif
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1505,6 +1553,9 @@ public:
           bool isVector = false) :
                             basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false),
                             arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr)
+#ifndef GLSLANG_WEB
+                            , spirvType(nullptr)
+#endif
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1518,6 +1569,9 @@ public:
                             basicType(p.basicType),
                             vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmat(p.coopmat),
                             arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters)
+#ifndef GLSLANG_WEB
+                            , spirvType(p.spirvType)
+#endif
                             {
                                 if (basicType == EbtSampler)
                                     sampler = p.sampler;
@@ -1552,6 +1606,9 @@ public:
         basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
         arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
         sampler(sampler), typeParameters(nullptr)
+#ifndef GLSLANG_WEB
+        , spirvType(nullptr)
+#endif
     {
         qualifier.clear();
         qualifier.storage = q;
@@ -1602,6 +1659,9 @@ public:
     TType(TTypeList* userDef, const TString& n) :
                             basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
                             arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr)
+#ifndef GLSLANG_WEB
+                            , spirvType(nullptr)
+#endif
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1611,6 +1671,9 @@ public:
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) :
                             basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
                             qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr)
+#ifndef GLSLANG_WEB
+                            , spirvType(nullptr)
+#endif
                             {
                                 sampler.clear();
                                 typeName = NewPoolTString(n.c_str());
@@ -1619,6 +1682,9 @@ public:
     explicit TType(TBasicType t, const TType &p, const TString& n) :
                             basicType(t), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false),
                             arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr)
+#ifndef GLSLANG_WEB
+                            , spirvType(nullptr)
+#endif
                             {
                                 assert(t == EbtReference);
                                 typeName = NewPoolTString(n.c_str());
@@ -1649,6 +1715,9 @@ public:
             referentType = copyOf.referentType;
         }
         typeParameters = copyOf.typeParameters;
+#ifndef GLSLANG_WEB
+        spirvType = copyOf.spirvType;
+#endif
         coopmat = copyOf.isCoopMat();
     }
 
@@ -1770,7 +1839,7 @@ public:
     }
     virtual bool isOpaque() const { return basicType == EbtSampler
 #ifndef GLSLANG_WEB
-         || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
+            || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
 #endif
         ; }
     virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
@@ -2018,8 +2087,6 @@ public:
         }
     }
 
-
-
     const char* getBasicString() const
     {
         return TType::getBasicString(basicType);
@@ -2050,6 +2117,7 @@ public:
         case EbtRayQuery:          return "rayQueryEXT";
         case EbtReference:         return "reference";
         case EbtString:            return "string";
+        case EbtSpirvType:         return "spirv_type";
 #endif
         default:                   return "unknown type";
         }
@@ -2070,6 +2138,9 @@ public:
         const auto appendUint = [&](unsigned int u) { typeString.append(std::to_string(u).c_str()); };
         const auto appendInt  = [&](int i)          { typeString.append(std::to_string(i).c_str()); };
 
+        if (qualifier.hasSprivDecorate())
+            appendStr(qualifier.getSpirvDecorateQualifierString().c_str());
+
         if (qualifier.hasLayout()) {
             // To reduce noise, skip this if the only layout is an xfb_buffer
             // with no triggering xfb_offset.
@@ -2219,6 +2290,10 @@ public:
             appendStr(" nonuniform");
         if (qualifier.isNullInit())
             appendStr(" null-init");
+        if (qualifier.isSpirvByReference())
+            appendStr(" spirv_by_reference");
+        if (qualifier.isSpirvLiteral())
+            appendStr(" spirv_literal");
         appendStr(" ");
         appendStr(getStorageQualifierString());
         if (isArray()) {
@@ -2455,6 +2530,15 @@ public:
                 (typeParameters != nullptr && right.typeParameters != nullptr && *typeParameters == *right.typeParameters));
     }
 
+#ifndef GLSLANG_WEB
+    // See if two type's SPIR-V type contents match
+    bool sameSpirvType(const TType& right) const
+    {
+        return ((spirvType == nullptr && right.spirvType == nullptr) ||
+                (spirvType != nullptr && right.spirvType != nullptr && *spirvType == *right.spirvType));
+    }
+#endif
+
     // See if two type's elements match in all ways except basic type
     bool sameElementShape(const TType& right) const
     {
@@ -2493,7 +2577,11 @@ public:
     // See if two types match in all ways (just the actual type, not qualification)
     bool operator==(const TType& right) const
     {
+#ifndef GLSLANG_WEB
+        return sameElementType(right) && sameArrayness(right) && sameTypeParameters(right) && sameSpirvType(right);
+#else
         return sameElementType(right) && sameArrayness(right) && sameTypeParameters(right);
+#endif
     }
 
     bool operator!=(const TType& right) const
@@ -2512,6 +2600,10 @@ public:
         return 0;
     }
 
+#ifndef GLSLANG_WEB
+    const TSpirvType& getSpirvType() const { assert(spirvType); return *spirvType; }
+#endif
+
 protected:
     // Require consumer to pick between deep copy and shallow copy.
     TType(const TType& type);
@@ -2524,6 +2616,19 @@ protected:
     {
         shallowCopy(copyOf);
 
+#ifndef GLSLANG_WEB
+        // GL_EXT_spirv_intrinsics
+        if (copyOf.qualifier.spirvDecorate) {
+            qualifier.spirvDecorate = new TSpirvDecorate;
+            *qualifier.spirvDecorate = *copyOf.qualifier.spirvDecorate;
+        }
+
+        if (copyOf.spirvType) {
+            spirvType = new TSpirvType;
+            *spirvType = *copyOf.spirvType;
+        }
+#endif
+
         if (copyOf.arraySizes) {
             arraySizes = new TArraySizes;
             *arraySizes = *copyOf.arraySizes;
@@ -2583,6 +2688,9 @@ protected:
     TString *typeName;          // for structure type name
     TSampler sampler;
     TArraySizes* typeParameters;// nullptr unless a parameterized type; can be shared across types
+#ifndef GLSLANG_WEB
+    TSpirvType* spirvType;  // SPIR-V type defined by spirv_type directive
+#endif
 };
 
 } // end namespace glslang

diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
index 677b090..172c09c 100644 (file)
--- a/glslang/Include/intermediate.h
+++ b/glslang/Include/intermediate.h
@@ -71,6 +71,9 @@ enum TOperator {
     EOpFunctionCall,
     EOpFunction,        // For function definition
     EOpParameters,      // an aggregate listing the parameters to a function
+#ifndef GLSLANG_WEB
+    EOpSpirvInst,
+#endif
 
     //
     // Unary operators
@@ -1616,8 +1619,15 @@ public:
     virtual       TIntermUnary* getAsUnaryNode()       { return this; }
     virtual const TIntermUnary* getAsUnaryNode() const { return this; }
     virtual void updatePrecision();
+#ifndef GLSLANG_WEB
+    void setSpirvInstruction(const TSpirvInstruction& inst) { spirvInst = inst; }
+    const TSpirvInstruction& getSpirvInstruction() const { return spirvInst; }
+#endif
 protected:
     TIntermTyped* operand;
+#ifndef GLSLANG_WEB
+    TSpirvInstruction spirvInst;
+#endif
 };
 
 typedef TVector<TIntermNode*> TIntermSequence;
@@ -1648,6 +1658,10 @@ public:
     bool getDebug() const { return debug; }
     void setPragmaTable(const TPragmaTable& pTable);
     const TPragmaTable& getPragmaTable() const { return *pragmaTable; }
+#ifndef GLSLANG_WEB
+    void setSpirvInstruction(const TSpirvInstruction& inst) { spirvInst = inst; }
+    const TSpirvInstruction& getSpirvInstruction() const { return spirvInst; }
+#endif
 protected:
     TIntermAggregate(const TIntermAggregate&); // disallow copy constructor
     TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator
@@ -1658,6 +1672,9 @@ protected:
     bool optimize;
     bool debug;
     TPragmaTable* pragmaTable;
+#ifndef GLSLANG_WEB
+    TSpirvInstruction spirvInst;
+#endif
 };
 
 //

diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
index 45c9362..722d976 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.cpp
+++ b/glslang/MachineIndependent/ParseHelper.cpp
@@ -1092,12 +1092,31 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct
     TSymbol* symbol = symbolTable.find(function.getMangledName(), &builtIn);
     if (symbol && symbol->getAsFunction() && builtIn)
         requireProfile(loc, ~EEsProfile, "redefinition of built-in function");
+#ifndef GLSLANG_WEB
+    // Check the validity of using spirv_literal qualifier
+    for (int i = 0; i < function.getParamCount(); ++i) {
+        if (function[i].type->getQualifier().isSpirvLiteral() && function.getBuiltInOp() != EOpSpirvInst)
+            error(loc, "'spirv_literal' can only be used on functions defined with 'spirv_instruction' for argument",
+                  function.getName().c_str(), "%d", i + 1);
+    }
+
+    // For function declaration with SPIR-V instruction qualifier, always ignore the built-in function and
+    // respect this redeclared one.
+    if (symbol && builtIn && function.getBuiltInOp() == EOpSpirvInst)
+        symbol = nullptr;
+#endif
     const TFunction* prevDec = symbol ? symbol->getAsFunction() : 0;
     if (prevDec) {
         if (prevDec->isPrototyped() && prototype)
             profileRequires(loc, EEsProfile, 300, nullptr, "multiple prototypes for same function");
         if (prevDec->getType() != function.getType())
             error(loc, "overloaded functions must have the same return type", function.getName().c_str(), "");
+#ifndef GLSLANG_WEB
+        if (prevDec->getSpirvInstruction() != function.getSpirvInstruction()) {
+            error(loc, "overloaded functions must have the same qualifiers", function.getName().c_str(),
+                  "spirv_instruction");
+        }
+#endif
         for (int i = 0; i < prevDec->getParamCount(); ++i) {
             if ((*prevDec)[i].type->getQualifier().storage != function[i].type->getQualifier().storage)
                 error(loc, "overloaded functions must have the same parameter storage qualifiers for argument", function[i].type->getStorageQualifierString(), "%d", i+1);
@@ -1299,6 +1318,15 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                         if (lValueErrorCheck(arguments->getLoc(), "assign", arg->getAsTyped()))
                             error(arguments->getLoc(), "Non-L-value cannot be passed for 'out' or 'inout' parameters.", "out", "");
                     }
+#ifndef GLSLANG_WEB
+                    if (formalQualifier.isSpirvLiteral()) {
+                        if (!arg->getAsTyped()->getQualifier().isFrontEndConstant()) {
+                            error(arguments->getLoc(),
+                                  "Non front-end constant expressions cannot be passed for 'spirv_literal' parameters.",
+                                  "spirv_literal", "");
+                        }
+                    }
+#endif
                     const TType& argType = arg->getAsTyped()->getType();
                     const TQualifier& argQualifier = argType.getQualifier();
                     if (argQualifier.isMemory() && (argType.containsOpaque() || argType.isReference())) {
@@ -1353,6 +1381,11 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
             if (builtIn && fnCandidate->getBuiltInOp() != EOpNull) {
                 // A function call mapped to a built-in operation.
                 result = handleBuiltInFunctionCall(loc, arguments, *fnCandidate);
+#ifndef GLSLANG_WEB
+            } else if (fnCandidate->getBuiltInOp() == EOpSpirvInst) {
+                // When SPIR-V instruction qualifier is specified, the function call is still mapped to a built-in operation.
+                result = handleBuiltInFunctionCall(loc, arguments, *fnCandidate);
+#endif
             } else {
                 // This is a function call not mapped to built-in operator.
                 // It could still be a built-in function, but only if PureOperatorBuiltins == false.
@@ -1430,6 +1463,35 @@ TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNo
     } else if (result->getAsOperator())
         builtInOpCheck(loc, function, *result->getAsOperator());
 
+#ifndef GLSLANG_WEB
+    // Special handling for function call with SPIR-V instruction qualifier specified
+    if (function.getBuiltInOp() == EOpSpirvInst) {
+        if (auto agg = result->getAsAggregate()) {
+            // Propogate spirv_by_reference/spirv_literal from parameters to arguments
+            auto& sequence = agg->getSequence();
+            for (unsigned i = 0; i < sequence.size(); ++i) {
+                if (function[i].type->getQualifier().isSpirvByReference())
+                    sequence[i]->getAsTyped()->getQualifier().setSpirvByReference();
+                if (function[i].type->getQualifier().isSpirvLiteral())
+                    sequence[i]->getAsTyped()->getQualifier().setSpirvLiteral();
+            }
+
+            // Attach the function call to SPIR-V intruction
+            agg->setSpirvInstruction(function.getSpirvInstruction());
+        } else if (auto unaryNode = result->getAsUnaryNode()) {
+            // Propogate spirv_by_reference/spirv_literal from parameters to arguments
+            if (function[0].type->getQualifier().isSpirvByReference())
+                unaryNode->getOperand()->getQualifier().setSpirvByReference();
+            if (function[0].type->getQualifier().isSpirvLiteral())
+                unaryNode->getOperand()->getQualifier().setSpirvLiteral();
+
+            // Attach the function call to SPIR-V intruction
+            unaryNode->setSpirvInstruction(function.getSpirvInstruction());
+        } else
+            assert(0);
+    }
+#endif
+
     return result;
 }
 
@@ -2931,7 +2993,8 @@ void TParseContext::reservedErrorCheck(const TSourceLoc& loc, const TString& ide
     // "Identifiers starting with "gl_" are reserved for use by OpenGL, and may not be
     // declared in a shader; this results in a compile-time error."
     if (! symbolTable.atBuiltInLevel()) {
-        if (builtInName(identifier))
+        if (builtInName(identifier) && !extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
+            // The extension GL_EXT_spirv_intrinsics allows us to declare identifiers starting with "gl_".
             error(loc, "identifiers starting with \"gl_\" are reserved", identifier.c_str(), "");
 
         // "__" are not supposed to be an error.  ES 300 (and desktop) added the clarification:
@@ -2939,7 +3002,8 @@ void TParseContext::reservedErrorCheck(const TSourceLoc& loc, const TString& ide
         // reserved; using such a name does not itself result in an error, but may result
         // in undefined behavior."
         // however, before that, ES tests required an error.
-        if (identifier.find("__") != TString::npos) {
+        if (identifier.find("__") != TString::npos && !extensionTurnedOn(E_GL_EXT_spirv_intrinsics)) {
+            // The extension GL_EXT_spirv_intrinsics allows us to declare identifiers starting with "__".
             if (isEsProfile() && version < 300)
                 error(loc, "identifiers containing consecutive underscores (\"__\") are reserved, and an error if version < 300", identifier.c_str(), "");
             else
@@ -2960,14 +3024,16 @@ void TParseContext::reservedPpErrorCheck(const TSourceLoc& loc, const char* iden
     // single underscore) are also reserved, and defining such a name results in a
     // compile-time error."
     // however, before that, ES tests required an error.
-    if (strncmp(identifier, "GL_", 3) == 0)
+    if (strncmp(identifier, "GL_", 3) == 0 && !extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
+        // The extension GL_EXT_spirv_intrinsics allows us to declare macros prefixed with "GL_".
         ppError(loc, "names beginning with \"GL_\" can't be (un)defined:", op,  identifier);
     else if (strncmp(identifier, "defined", 8) == 0)
         if (relaxedErrors())
             ppWarn(loc, "\"defined\" is (un)defined:", op,  identifier);
         else
             ppError(loc, "\"defined\" can't be (un)defined:", op,  identifier);
-    else if (strstr(identifier, "__") != 0) {
+    else if (strstr(identifier, "__") != 0 && !extensionTurnedOn(E_GL_EXT_spirv_intrinsics)) {
+        // The extension GL_EXT_spirv_intrinsics allows us to declare macros prefixed with "__".
         if (isEsProfile() && version >= 300 &&
             (strcmp(identifier, "__LINE__") == 0 ||
              strcmp(identifier, "__FILE__") == 0 ||
@@ -3582,6 +3648,14 @@ void TParseContext::globalQualifierFixCheck(const TSourceLoc& loc, TQualifier& q
     if (!nonuniformOkay && qualifier.isNonUniform())
         error(loc, "for non-parameter, can only apply to 'in' or no storage qualifier", "nonuniformEXT", "");
 
+#ifndef GLSLANG_WEB
+    if (qualifier.isSpirvByReference())
+        error(loc, "can only apply to parameter", "spirv_by_reference", "");
+
+    if (qualifier.isSpirvLiteral())
+        error(loc, "can only apply to parameter", "spirv_literal", "");
+#endif
+
     // Storage qualifier isn't ready for memberQualifierCheck, we should skip invariantCheck for it.
     if (!isMemberCheck || structNestingLevel > 0)
         invariantCheck(loc, qualifier);
@@ -3843,6 +3917,41 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
     MERGE_SINGLETON(nonUniform);
 #endif
 
+#ifndef GLSLANG_WEB
+    // SPIR-V storage class qualifier (GL_EXT_spirv_intrinsics)
+    dst.spirvStorageClass = src.spirvStorageClass;
+
+    // SPIR-V decorate qualifiers (GL_EXT_spirv_intrinsics)
+    if (src.hasSprivDecorate()) {
+        if (dst.hasSprivDecorate()) {
+            const TSpirvDecorate& srcSpirvDecorate = src.getSpirvDecorate();
+            TSpirvDecorate& dstSpirvDecorate = dst.getSpirvDecorate();
+            for (auto& decorate : srcSpirvDecorate.decorates) {
+                if (dstSpirvDecorate.decorates.find(decorate.first) != dstSpirvDecorate.decorates.end())
+                    error(loc, "too many SPIR-V decorate qualifiers", "spirv_decorate", "(decoration=%u)", decorate.first);
+                else
+                    dstSpirvDecorate.decorates.insert(decorate);
+            }
+
+            for (auto& decorateId : srcSpirvDecorate.decorateIds) {
+                if (dstSpirvDecorate.decorateIds.find(decorateId.first) != dstSpirvDecorate.decorateIds.end())
+                    error(loc, "too many SPIR-V decorate qualifiers", "spirv_decorate_id", "(decoration=%u)", decorateId.first);
+                else
+                    dstSpirvDecorate.decorateIds.insert(decorateId);
+            }
+
+            for (auto& decorateString : srcSpirvDecorate.decorateStrings) {
+                if (dstSpirvDecorate.decorates.find(decorateString.first) != dstSpirvDecorate.decorates.end())
+                    error(loc, "too many SPIR-V decorate qualifiers", "spirv_decorate_string", "(decoration=%u)", decorateString.first);
+                else
+                    dstSpirvDecorate.decorates.insert(decorateString);
+            }
+        } else {
+            dst.spirvDecorate = src.spirvDecorate;
+        }
+    }
+#endif
+
     if (repeated)
         error(loc, "replicated qualifiers", "", "");
 }
@@ -4806,6 +4915,17 @@ void TParseContext::paramCheckFix(const TSourceLoc& loc, const TQualifier& quali
     }
     if (qualifier.isNonUniform())
         type.getQualifier().nonUniform = qualifier.nonUniform;
+#ifndef GLSLANG_WEB
+    if (qualifier.isSpirvByReference())
+        type.getQualifier().setSpirvByReference();
+    if (qualifier.isSpirvLiteral()) {
+        if (type.getBasicType() == EbtFloat || type.getBasicType() == EbtInt || type.getBasicType() == EbtUint ||
+            type.getBasicType() == EbtBool)
+            type.getQualifier().setSpirvLiteral();
+        else
+            error(loc, "cannot use spirv_literal qualifier", type.getBasicTypeString().c_str(), "");
+#endif
+    }
 
     paramCheckFixStorage(loc, qualifier.storage, type);
 }
@@ -5873,6 +5993,9 @@ void TParseContext::layoutObjectCheck(const TSourceLoc& loc, const TSymbol& symb
         case EvqVaryingIn:
         case EvqVaryingOut:
             if (!type.getQualifier().isTaskMemory() &&
+#ifndef GLSLANG_WEB
+                !type.getQualifier().hasSprivDecorate() &&
+#endif
                 (type.getBasicType() != EbtBlock ||
                  (!(*type.getStruct())[0].type->getQualifier().hasLocation() &&
                    (*type.getStruct())[0].type->getQualifier().builtIn == EbvNone)))
@@ -5934,6 +6057,11 @@ void TParseContext::layoutMemberLocationArrayCheck(const TSourceLoc& loc, bool m
 // Do layout error checking with respect to a type.
 void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
 {
+#ifndef GLSLANG_WEB
+    if (extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
+        return; // Skip any check if GL_EXT_spirv_intrinsics is turned on
+#endif
+
     const TQualifier& qualifier = type.getQualifier();
 
     // first, intra-layout qualifier-only error checking
@@ -7940,6 +8068,10 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con
             memberQualifier.perViewNV = currentBlockQualifier.perViewNV;
         if (currentBlockQualifier.perTaskNV)
             memberQualifier.perTaskNV = currentBlockQualifier.perTaskNV;
+        if (memberQualifier.storage == EvqSpirvStorageClass)
+            error(memberLoc, "member cannot have a spirv_storage_class qualifier", memberType.getFieldName().c_str(), "");
+        if (memberQualifier.hasSprivDecorate() && !memberQualifier.getSpirvDecorate().decorateIds.empty())
+            error(memberLoc, "member cannot have a spirv_decorate_id qualifier", memberType.getFieldName().c_str(), "");
 #endif
         if ((currentBlockQualifier.storage == EvqUniform || currentBlockQualifier.storage == EvqBuffer) && (memberQualifier.isInterpolation() || memberQualifier.isAuxiliary()))
             error(memberLoc, "member of uniform or buffer block cannot have an auxiliary or interpolation qualifier", memberType.getFieldName().c_str(), "");

diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h
index 70d3572..c9e6334 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.h
+++ b/glslang/MachineIndependent/ParseHelper.h
@@ -472,6 +472,20 @@ public:
     void handleLoopAttributes(const TAttributes& attributes, TIntermNode*);
     // Function attributes
     void handleFunctionAttributes(const TSourceLoc&, const TAttributes&, TFunction*);
+
+    // GL_EXT_spirv_intrinsics
+    TSpirvRequirement* makeSpirvRequirement(const TSourceLoc& loc, const TString& name,
+                                            const TIntermAggregate* extensions, const TIntermAggregate* capabilities);
+    TSpirvRequirement* mergeSpirvRequirements(const TSourceLoc& loc, TSpirvRequirement* spirvReq1,
+                                                TSpirvRequirement* spirvReq2);
+    TSpirvTypeParameters* makeSpirvTypeParameters(const TSourceLoc& loc, const TIntermConstantUnion* constant);
+    TSpirvTypeParameters* makeSpirvTypeParameters(const TPublicType& type);
+    TSpirvTypeParameters* mergeSpirvTypeParameters(TSpirvTypeParameters* spirvTypeParams1,
+                                                   TSpirvTypeParameters* spirvTypeParams2);
+    TSpirvInstruction* makeSpirvInstruction(const TSourceLoc& loc, const TString& name, const TString& value);
+    TSpirvInstruction* makeSpirvInstruction(const TSourceLoc& loc, const TString& name, int value);
+    TSpirvInstruction* mergeSpirvInstruction(const TSourceLoc& loc, TSpirvInstruction* spirvInst1,
+                                             TSpirvInstruction* spirvInst2);
 #endif
 
     void checkAndResizeMeshViewDim(const TSourceLoc&, TType&, bool isBlockMember);

diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
index 78c8a36..c387aed 100644 (file)
--- a/glslang/MachineIndependent/Scan.cpp
+++ b/glslang/MachineIndependent/Scan.cpp
@@ -586,6 +586,18 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["f64mat4x2"] =               F64MAT4X2;
     (*KeywordMap)["f64mat4x3"] =               F64MAT4X3;
     (*KeywordMap)["f64mat4x4"] =               F64MAT4X4;
+
+    // GL_EXT_spirv_intrinsics
+    (*KeywordMap)["spirv_instruction"] =       SPIRV_INSTRUCTION;
+    (*KeywordMap)["spirv_execution_mode"] =    SPIRV_EXECUTION_MODE;
+    (*KeywordMap)["spirv_execution_mode_id"] = SPIRV_EXECUTION_MODE_ID;
+    (*KeywordMap)["spirv_decorate"] =          SPIRV_DECORATE;
+    (*KeywordMap)["spirv_decorate_id"] =       SPIRV_DECORATE_ID;
+    (*KeywordMap)["spirv_decorate_string"] =   SPIRV_DECORATE_STRING;
+    (*KeywordMap)["spirv_type"] =              SPIRV_TYPE;
+    (*KeywordMap)["spirv_storage_class"] =     SPIRV_STORAGE_CLASS;
+    (*KeywordMap)["spirv_by_reference"] =      SPIRV_BY_REFERENCE;
+    (*KeywordMap)["spirv_literal"] =           SPIRV_LITERAL;
 #endif
 
     (*KeywordMap)["sampler2D"] =               SAMPLER2D;
@@ -1747,6 +1759,21 @@ int TScanContext::tokenizeIdentifier()
             return keyword;
         else
             return identifierOrType();
+
+    case SPIRV_INSTRUCTION:
+    case SPIRV_EXECUTION_MODE:
+    case SPIRV_EXECUTION_MODE_ID:
+    case SPIRV_DECORATE:
+    case SPIRV_DECORATE_ID:
+    case SPIRV_DECORATE_STRING:
+    case SPIRV_TYPE:
+    case SPIRV_STORAGE_CLASS:
+    case SPIRV_BY_REFERENCE:
+    case SPIRV_LITERAL:
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
+            return keyword;
+        return identifierOrType();
 #endif
 
     default:

diff --git a/glslang/MachineIndependent/SpirvIntrinsics.cpp b/glslang/MachineIndependent/SpirvIntrinsics.cpp
new file mode 100644 (file)
index 0000000..38094ea
--- /dev/null
+++ b/glslang/MachineIndependent/SpirvIntrinsics.cpp
@@ -0,0 +1,355 @@
+//
+// Copyright(C) 2021 Advanced Micro Devices, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef GLSLANG_WEB
+
+//
+// GL_EXT_spirv_intrinsics
+//
+#include "../Include/intermediate.h"
+#include "../Include/SpirvIntrinsics.h"
+#include "../Include/Types.h"
+#include "ParseHelper.h"
+
+namespace glslang {
+
+//
+// Handle SPIR-V requirements
+//
+TSpirvRequirement* TParseContext::makeSpirvRequirement(const TSourceLoc& loc, const TString& name,
+                                                       const TIntermAggregate* extensions,
+                                                       const TIntermAggregate* capabilities)
+{
+    TSpirvRequirement* spirvReq = new TSpirvRequirement;
+
+    if (name == "extensions") {
+        assert(extensions);
+        for (auto extension : extensions->getSequence()) {
+            assert(extension->getAsConstantUnion());
+            spirvReq->extensions.insert(*extension->getAsConstantUnion()->getConstArray()[0].getSConst());
+        }
+    } else if (name == "capabilities") {
+        assert(capabilities);
+        for (auto capability : capabilities->getSequence()) {
+            assert(capability->getAsConstantUnion());
+            spirvReq->capabilities.insert(capability->getAsConstantUnion()->getConstArray()[0].getIConst());
+        }
+    } else
+        error(loc, "unknow SPIR-V requirement", name.c_str(), "");
+
+    return spirvReq;
+}
+
+TSpirvRequirement* TParseContext::mergeSpirvRequirements(const TSourceLoc& loc, TSpirvRequirement* spirvReq1,
+                                                         TSpirvRequirement* spirvReq2)
+{
+    // Merge the second SPIR-V requirement to the first one
+    if (!spirvReq2->extensions.empty()) {
+        if (spirvReq1->extensions.empty())
+            spirvReq1->extensions = spirvReq2->extensions;
+        else
+            error(loc, "too many SPIR-V requirements", "extensions", "");
+    }
+
+    if (!spirvReq2->capabilities.empty()) {
+        if (spirvReq1->capabilities.empty())
+            spirvReq1->capabilities = spirvReq2->capabilities;
+        else
+            error(loc, "too many SPIR-V requirements", "capabilities", "");
+    }
+
+    return spirvReq1;
+}
+
+void TIntermediate::insertSpirvRequirement(const TSpirvRequirement* spirvReq)
+{
+    if (!spirvRequirement)
+        spirvRequirement = new TSpirvRequirement;
+
+    for (auto extension : spirvReq->extensions)
+        spirvRequirement->extensions.insert(extension);
+
+    for (auto capability : spirvReq->capabilities)
+        spirvRequirement->capabilities.insert(capability);
+}
+
+//
+// Handle SPIR-V execution modes
+//
+void TIntermediate::insertSpirvExecutionMode(int executionMode, const TIntermAggregate* args)
+{
+    if (!spirvExecutionMode)
+        spirvExecutionMode = new TSpirvExecutionMode;
+
+    TVector<const TIntermConstantUnion*> extraOperands;
+    if (args) {
+        for (auto arg : args->getSequence()) {
+            auto extraOperand = arg->getAsConstantUnion();
+            assert(extraOperand != nullptr);
+            extraOperands.push_back(extraOperand);
+        }
+    }
+    spirvExecutionMode->modes[executionMode] = extraOperands;
+}
+
+void TIntermediate::insertSpirvExecutionModeId(int executionMode, const TIntermAggregate* args)
+{
+    if (!spirvExecutionMode)
+        spirvExecutionMode = new TSpirvExecutionMode;
+
+    assert(args);
+    TVector<const TIntermConstantUnion*> extraOperands;
+
+    for (auto arg : args->getSequence()) {
+        auto extraOperand = arg->getAsConstantUnion();
+        assert(extraOperand != nullptr);
+        extraOperands.push_back(extraOperand);
+    }
+    spirvExecutionMode->modeIds[executionMode] = extraOperands;
+}
+
+//
+// Handle SPIR-V decorate qualifiers
+//
+void TQualifier::setSpirvDecorate(int decoration, const TIntermAggregate* args)
+{
+    if (!spirvDecorate)
+        spirvDecorate = new TSpirvDecorate;
+
+    TVector<const TIntermConstantUnion*> extraOperands;
+    if (args) {
+        for (auto arg : args->getSequence()) {
+            auto extraOperand = arg->getAsConstantUnion();
+            assert(extraOperand != nullptr);
+            extraOperands.push_back(extraOperand);
+        }
+    }
+    spirvDecorate->decorates[decoration] = extraOperands;
+}
+
+void TQualifier::setSpirvDecorateId(int decoration, const TIntermAggregate* args)
+{
+    if (!spirvDecorate)
+        spirvDecorate = new TSpirvDecorate;
+
+    assert(args);
+    TVector<const TIntermConstantUnion*> extraOperands;
+    for (auto arg : args->getSequence()) {
+        auto extraOperand = arg->getAsConstantUnion();
+        assert(extraOperand != nullptr);
+        extraOperands.push_back(extraOperand);
+    }
+    spirvDecorate->decorateIds[decoration] = extraOperands;
+}
+
+void TQualifier::setSpirvDecorateString(int decoration, const TIntermAggregate* args)
+{
+    if (!spirvDecorate)
+        spirvDecorate = new TSpirvDecorate;
+
+    assert(args);
+    TVector<const TIntermConstantUnion*> extraOperands;
+    for (auto arg : args->getSequence()) {
+        auto extraOperand = arg->getAsConstantUnion();
+        assert(extraOperand != nullptr);
+        extraOperands.push_back(extraOperand);
+    }
+    spirvDecorate->decorateStrings[decoration] = extraOperands;
+}
+
+TString TQualifier::getSpirvDecorateQualifierString() const
+{
+    assert(spirvDecorate);
+
+    TString qualifierString;
+
+    const auto appendFloat = [&](float f) { qualifierString.append(std::to_string(f).c_str()); };
+    const auto appendInt = [&](int i) { qualifierString.append(std::to_string(i).c_str()); };
+    const auto appendUint = [&](unsigned int u) { qualifierString.append(std::to_string(u).c_str()); };
+    const auto appendBool = [&](bool b) { qualifierString.append(std::to_string(b).c_str()); };
+    const auto appendStr = [&](const char* s) { qualifierString.append(s); };
+
+    const auto appendDecorate = [&](const TIntermConstantUnion* constant) {
+        if (constant->getBasicType() == EbtFloat) {
+            float value = static_cast<float>(constant->getConstArray()[0].getDConst());
+            appendFloat(value);
+        }
+        else if (constant->getBasicType() == EbtInt) {
+            int value = constant->getConstArray()[0].getIConst();
+            appendInt(value);
+        }
+        else if (constant->getBasicType() == EbtUint) {
+            unsigned value = constant->getConstArray()[0].getUConst();
+            appendUint(value);
+        }
+        else if (constant->getBasicType() == EbtBool) {
+            bool value = constant->getConstArray()[0].getBConst();
+            appendBool(value);
+        }
+        else if (constant->getBasicType() == EbtString) {
+            const TString* value = constant->getConstArray()[0].getSConst();
+            appendStr(value->c_str());
+        }
+        else
+            assert(0);
+    };
+
+    for (auto& decorate : spirvDecorate->decorates) {
+        appendStr("spirv_decorate(");
+        appendInt(decorate.first);
+        for (auto extraOperand : decorate.second) {
+            appendStr(", ");
+            appendDecorate(extraOperand);
+        }
+        appendStr(") ");
+    }
+
+    for (auto& decorateId : spirvDecorate->decorateIds) {
+        appendStr("spirv_decorate_id(");
+        appendInt(decorateId.first);
+        for (auto extraOperand : decorateId.second) {
+            appendStr(", ");
+            appendDecorate(extraOperand);
+        }
+        appendStr(") ");
+    }
+
+    for (auto& decorateString : spirvDecorate->decorateStrings) {
+        appendStr("spirv_decorate_string(");
+        appendInt(decorateString.first);
+        for (auto extraOperand : decorateString.second) {
+            appendStr(", ");
+            appendDecorate(extraOperand);
+        }
+        appendStr(") ");
+    }
+
+    return qualifierString;
+}
+
+//
+// Handle SPIR-V type specifiers
+//
+void TPublicType::setSpirvType(const TSpirvInstruction& spirvInst, const TSpirvTypeParameters* typeParams)
+{
+    if (!spirvType)
+        spirvType = new TSpirvType;
+
+    basicType = EbtSpirvType;
+    spirvType->spirvInst = spirvInst;
+    if (typeParams)
+        spirvType->typeParams = *typeParams;
+}
+
+TSpirvTypeParameters* TParseContext::makeSpirvTypeParameters(const TSourceLoc& loc, const TIntermConstantUnion* constant)
+{
+    TSpirvTypeParameters* spirvTypeParams = new TSpirvTypeParameters;
+    if (constant->getBasicType() != EbtFloat &&
+        constant->getBasicType() != EbtInt &&
+        constant->getBasicType() != EbtUint &&
+        constant->getBasicType() != EbtBool &&
+        constant->getBasicType() != EbtString)
+        error(loc, "this type not allowed", constant->getType().getBasicString(), "");
+    else {
+        assert(constant);
+        spirvTypeParams->push_back(TSpirvTypeParameter(constant));
+    }
+
+    return spirvTypeParams;
+}
+
+TSpirvTypeParameters* TParseContext::makeSpirvTypeParameters(const TPublicType& type)
+{
+    TSpirvTypeParameters* spirvTypeParams = new TSpirvTypeParameters;
+    spirvTypeParams->push_back(TSpirvTypeParameter(new TType(type)));
+    return spirvTypeParams;
+}
+
+TSpirvTypeParameters* TParseContext::mergeSpirvTypeParameters(TSpirvTypeParameters* spirvTypeParams1, TSpirvTypeParameters* spirvTypeParams2)
+{
+    // Merge SPIR-V type parameters of the second one to the first one
+    for (const auto& spirvTypeParam : *spirvTypeParams2)
+        spirvTypeParams1->push_back(spirvTypeParam);
+    return spirvTypeParams1;
+}
+
+//
+// Handle SPIR-V instruction qualifiers
+//
+TSpirvInstruction* TParseContext::makeSpirvInstruction(const TSourceLoc& loc, const TString& name, const TString& value)
+{
+    TSpirvInstruction* spirvInst = new TSpirvInstruction;
+    if (name == "set")
+        spirvInst->set = value;
+    else
+        error(loc, "unknown SPIR-V instruction qualifier", name.c_str(), "");
+
+    return spirvInst;
+}
+
+TSpirvInstruction* TParseContext::makeSpirvInstruction(const TSourceLoc& loc, const TString& name, int value)
+{
+    TSpirvInstruction* spirvInstuction = new TSpirvInstruction;
+    if (name == "id")
+        spirvInstuction->id = value;
+    else
+        error(loc, "unknown SPIR-V instruction qualifier", name.c_str(), "");
+
+    return spirvInstuction;
+}
+
+TSpirvInstruction* TParseContext::mergeSpirvInstruction(const TSourceLoc& loc, TSpirvInstruction* spirvInst1, TSpirvInstruction* spirvInst2)
+{
+    // Merge qualifiers of the second SPIR-V instruction to those of the first one
+    if (!spirvInst2->set.empty()) {
+        if (spirvInst1->set.empty())
+            spirvInst1->set = spirvInst2->set;
+        else
+            error(loc, "too many SPIR-V instruction qualifiers", "spirv_instruction", "(set)");
+    }
+
+    if (spirvInst2->id != -1) {
+        if (spirvInst1->id == -1)
+            spirvInst1->id = spirvInst2->id;
+        else
+            error(loc, "too many SPIR-V instruction qualifiers", "spirv_instruction", "(id)");
+    }
+
+    return spirvInst1;
+}
+
+} // end namespace glslang
+
+#endif // GLSLANG_WEB

diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp
index 0e5ee19..747b436 100644 (file)
--- a/glslang/MachineIndependent/SymbolTable.cpp
+++ b/glslang/MachineIndependent/SymbolTable.cpp
@@ -77,6 +77,7 @@ void TType::buildMangledName(TString& mangledName) const
     case EbtAtomicUint:         mangledName += "au";     break;
     case EbtAccStruct:          mangledName += "as";     break;
     case EbtRayQuery:           mangledName += "rq";     break;
+    case EbtSpirvType:          mangledName += "spv-t";  break;
 #endif
     case EbtSampler:
         switch (sampler.type) {
@@ -390,6 +391,9 @@ TFunction::TFunction(const TFunction& copyOf) : TSymbol(copyOf)
     implicitThis = copyOf.implicitThis;
     illegalImplicitThis = copyOf.illegalImplicitThis;
     defaultParamCount = copyOf.defaultParamCount;
+#ifndef GLSLANG_WEB
+    spirvInst = copyOf.spirvInst;
+#endif
 }
 
 TFunction* TFunction::clone() const

diff --git a/glslang/MachineIndependent/SymbolTable.h b/glslang/MachineIndependent/SymbolTable.h
index 152dc47..2196093 100644 (file)
--- a/glslang/MachineIndependent/SymbolTable.h
+++ b/glslang/MachineIndependent/SymbolTable.h
@@ -319,6 +319,15 @@ public:
     virtual TParameter& operator[](int i) { assert(writable); return parameters[i]; }
     virtual const TParameter& operator[](int i) const { return parameters[i]; }
 
+#ifndef GLSLANG_WEB
+    virtual void setSpirvInstruction(const TSpirvInstruction& inst)
+    {
+        relateToOperator(EOpSpirvInst);
+        spirvInst = inst;
+    }
+    virtual const TSpirvInstruction& getSpirvInstruction() const { return spirvInst; }
+#endif
+
 #if !defined(GLSLANG_WEB) && !defined(GLSLANG_ANGLE)
     virtual void dump(TInfoSink& infoSink, bool complete = false) const override;
 #endif
@@ -342,6 +351,10 @@ protected:
                                // This is important for a static member function that has member variables in scope,
                                // but is not allowed to use them, or see hidden symbols instead.
     int  defaultParamCount;
+
+#ifndef GLSLANG_WEB
+    TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers
+#endif
 };
 
 //

diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
index c7ce0ca..884f671 100644 (file)
--- a/glslang/MachineIndependent/Versions.cpp
+++ b/glslang/MachineIndependent/Versions.cpp
@@ -333,6 +333,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_shader_image_int64]   = EBhDisable;
     extensionBehavior[E_GL_EXT_terminate_invocation]        = EBhDisable;
     extensionBehavior[E_GL_EXT_shared_memory_block]         = EBhDisable;
+    extensionBehavior[E_GL_EXT_spirv_intrinsics]            = EBhDisable;
 
     // OVR extensions
     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -493,6 +494,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_ray_tracing 1\n"
             "#define GL_EXT_ray_query 1\n"
             "#define GL_EXT_ray_flags_primitive_culling 1\n"
+            "#define GL_EXT_spirv_intrinsics 1\n"
 
             "#define GL_AMD_shader_ballot 1\n"
             "#define GL_AMD_shader_trinary_minmax 1\n"
@@ -602,6 +604,29 @@ void TParseVersions::getPreamble(std::string& preamble)
         preamble += "\n";
     }
 #endif
+
+#ifndef GLSLANG_WEB
+    // GL_EXT_spirv_intrinsics
+    if (!isEsProfile()) {
+        switch (language) {
+        case EShLangVertex:         preamble += "#define GL_VERTEX_SHADER 1 \n";                    break;
+        case EShLangTessControl:    preamble += "#define GL_TESSELLATION_CONTROL_SHADER 1 \n";      break;
+        case EShLangTessEvaluation: preamble += "#define GL_TESSELLATION_EVALUATION_SHADER 1 \n";   break;
+        case EShLangGeometry:       preamble += "#define GL_GEOMETRY_SHADER 1 \n";                  break;
+        case EShLangFragment:       preamble += "#define GL_FRAGMENT_SHADER 1 \n";                  break;
+        case EShLangCompute:        preamble += "#define GL_COMPUTE_SHADER 1 \n";                   break;
+        case EShLangRayGen:         preamble += "#define GL_RAY_GENERATION_SHADER_EXT 1 \n";        break;
+        case EShLangIntersect:      preamble += "#define GL_INTERSECTION_SHADER_EXT 1 \n";          break;
+        case EShLangAnyHit:         preamble += "#define GL_ANY_HIT_SHADER_EXT 1 \n";               break;
+        case EShLangClosestHit:     preamble += "#define GL_CLOSEST_HIT_SHADER_EXT 1 \n";           break;
+        case EShLangMiss:           preamble += "#define GL_MISS_SHADER_EXT 1 \n";                  break;
+        case EShLangCallable:       preamble += "#define GL_CALLABLE_SHADER_EXT 1 \n";              break;
+        case EShLangTaskNV:         preamble += "#define GL_TASK_SHADER_NV 1 \n";                   break;
+        case EShLangMeshNV:         preamble += "#define GL_MESH_SHADER_NV 1 \n";                   break;
+        default:                                                                                    break;
+        }
+    }
+#endif
 }
 
 //

diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
index 01f819d..21846c4 100644 (file)
--- a/glslang/MachineIndependent/Versions.h
+++ b/glslang/MachineIndependent/Versions.h
@@ -205,6 +205,7 @@ const char* const E_GL_EXT_shader_image_int64               = "GL_EXT_shader_ima
 const char* const E_GL_EXT_null_initializer                 = "GL_EXT_null_initializer";
 const char* const E_GL_EXT_shared_memory_block              = "GL_EXT_shared_memory_block";
 const char* const E_GL_EXT_subgroup_uniform_control_flow    = "GL_EXT_subgroup_uniform_control_flow";
+const char* const E_GL_EXT_spirv_intrinsics                 = "GL_EXT_spirv_intrinsics";
 
 // Arrays of extensions for the above viewportEXTs duplications
 

diff --git a/glslang/MachineIndependent/glslang.m4 b/glslang/MachineIndependent/glslang.m4
index 5b1d2a7..93041ce 100644 (file)
--- a/glslang/MachineIndependent/glslang.m4
+++ b/glslang/MachineIndependent/glslang.m4
@@ -116,6 +116,9 @@ using namespace glslang;
             glslang::TIntermNodePair nodePair;
             glslang::TIntermTyped* intermTypedNode;
             glslang::TAttributes* attributes;
+            glslang::TSpirvRequirement* spirvReq;
+            glslang::TSpirvInstruction* spirvInst;
+            glslang::TSpirvTypeParameters* spirvTypeParams;
         };
         union {
             glslang::TPublicType type;
@@ -271,6 +274,11 @@ GLSLANG_WEB_EXCLUDE_ON
 %token <lex> SUBPASSINPUT SUBPASSINPUTMS ISUBPASSINPUT ISUBPASSINPUTMS USUBPASSINPUT USUBPASSINPUTMS
 %token <lex> F16SUBPASSINPUT F16SUBPASSINPUTMS
 
+// spirv intrinsics
+%token <lex> SPIRV_INSTRUCTION SPIRV_EXECUTION_MODE SPIRV_EXECUTION_MODE_ID
+%token <lex> SPIRV_DECORATE SPIRV_DECORATE_ID SPIRV_DECORATE_STRING
+%token <lex> SPIRV_TYPE SPIRV_STORAGE_CLASS SPIRV_BY_REFERENCE SPIRV_LITERAL
+
 GLSLANG_WEB_EXCLUDE_OFF
 
 %token <lex> LEFT_OP RIGHT_OP
@@ -362,6 +370,19 @@ GLSLANG_WEB_EXCLUDE_ON
 %type <interm.attributes> attribute attribute_list single_attribute
 %type <interm.intermNode> demote_statement
 %type <interm.intermTypedNode> initializer_list
+%type <interm.spirvReq> spirv_requirements_list spirv_requirements_parameter
+%type <interm.intermNode> spirv_extension_list spirv_capability_list
+%type <interm.intermNode> spirv_execution_mode_qualifier
+%type <interm.intermNode> spirv_execution_mode_parameter_list spirv_execution_mode_parameter spirv_execution_mode_id_parameter_list
+%type <interm.type> spirv_storage_class_qualifier
+%type <interm.type> spirv_decorate_qualifier
+%type <interm.intermNode> spirv_decorate_parameter_list spirv_decorate_parameter
+%type <interm.intermNode> spirv_decorate_id_parameter_list
+%type <interm.intermNode> spirv_decorate_string_parameter_list
+%type <interm.type> spirv_type_specifier
+%type <interm.spirvTypeParams> spirv_type_parameter_list spirv_type_parameter
+%type <interm.spirvInst> spirv_instruction_qualifier
+%type <interm.spirvInst> spirv_instruction_qualifier_list spirv_instruction_qualifier_id
 GLSLANG_WEB_EXCLUDE_OFF
 
 %start translation_unit
@@ -875,6 +896,20 @@ declaration
         $$ = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
+GLSLANG_WEB_EXCLUDE_ON
+    | spirv_instruction_qualifier function_prototype SEMICOLON {
+        parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier");
+        $2.function->setSpirvInstruction(*$1); // Attach SPIR-V intruction qualifier
+        parseContext.handleFunctionDeclarator($2.loc, *$2.function, true /* prototype */);
+        $$ = 0;
+        // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
+    }
+    | spirv_execution_mode_qualifier SEMICOLON {
+        parseContext.globalCheck($2.loc, "SPIR-V execution mode qualifier");
+        parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier");
+        $$ = 0;
+    }
+GLSLANG_WEB_EXCLUDE_OFF
     | init_declarator_list SEMICOLON {
         if ($1.intermNode && $1.intermNode->getAsAggregate())
             $1.intermNode->getAsAggregate()->setOperator(EOpSequence);
@@ -1366,6 +1401,25 @@ GLSLANG_WEB_EXCLUDE_ON
     | non_uniform_qualifier {
         $$ = $1;
     }
+    | spirv_storage_class_qualifier {
+        parseContext.globalCheck($1.loc, "spirv_storage_class");
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier");
+        $$ = $1;
+    }
+    | spirv_decorate_qualifier {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier");
+        $$ = $1;
+    }
+    | SPIRV_BY_REFERENCE {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference");
+        $$.init($1.loc);
+        $$.qualifier.setSpirvByReference();
+    }
+    | SPIRV_LITERAL {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal");
+        $$.init($1.loc);
+        $$.qualifier.setSpirvLiteral();
+    }
 GLSLANG_WEB_EXCLUDE_OFF
     ;
 
@@ -3426,6 +3480,10 @@ GLSLANG_WEB_EXCLUDE_ON
         $$.basicType = EbtUint;
         $$.coopmat = true;
     }
+    | spirv_type_specifier {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
+        $$ = $1;
+    }
 GLSLANG_WEB_EXCLUDE_OFF
     | struct_specifier {
         $$ = $1;
@@ -4068,4 +4126,273 @@ single_attribute
     }
 GLSLANG_WEB_EXCLUDE_OFF
 
+GLSLANG_WEB_EXCLUDE_ON
+spirv_requirements_list
+    : spirv_requirements_parameter {
+        $$ = $1;
+    }
+    | spirv_requirements_list COMMA spirv_requirements_parameter {
+        $$ = parseContext.mergeSpirvRequirements($2.loc, $1, $3);
+    }
+
+spirv_requirements_parameter
+    : IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET {
+        $$ = parseContext.makeSpirvRequirement($2.loc, *$1.string, $4->getAsAggregate(), nullptr);
+    }
+    | IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET {
+        $$ = parseContext.makeSpirvRequirement($2.loc, *$1.string, nullptr, $4->getAsAggregate());
+    }
+
+spirv_extension_list
+    : STRING_LITERAL {
+        $$ = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion($1.string, $1.loc, true));
+    }
+    | spirv_extension_list COMMA STRING_LITERAL {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.string, $3.loc, true));
+    }
+
+spirv_capability_list
+    : INTCONSTANT {
+        $$ = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion($1.i, $1.loc, true));
+    }
+    | spirv_capability_list COMMA INTCONSTANT {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.i, $3.loc, true));
+    }
+
+spirv_execution_mode_qualifier
+    : SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionMode($3.i);
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionMode($5.i);
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionMode($3.i, $5->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionMode($5.i, $7->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionModeId($3.i, $5->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionModeId($5.i, $7->getAsAggregate());
+        $$ = 0;
+    }
+
+spirv_execution_mode_parameter_list
+    : spirv_execution_mode_parameter {
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter {
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_execution_mode_parameter
+    : FLOATCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
+    }
+    | INTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.i, $1.loc, true);
+    }
+    | UINTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
+    }
+    | BOOLCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.b, $1.loc, true);
+    }
+    | STRING_LITERAL {
+        $$ = parseContext.intermediate.addConstantUnion($1.string, $1.loc, true);
+    }
+
+spirv_execution_mode_id_parameter_list
+    : constant_expression {
+        if ($1->getBasicType() != EbtFloat &&
+            $1->getBasicType() != EbtInt &&
+            $1->getBasicType() != EbtUint &&
+            $1->getBasicType() != EbtBool &&
+            $1->getBasicType() != EbtString)
+            parseContext.error($1->getLoc(), "this type not allowed", $1->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_execution_mode_id_parameter_list COMMA constant_expression {
+        if ($3->getBasicType() != EbtFloat &&
+            $3->getBasicType() != EbtInt &&
+            $3->getBasicType() != EbtUint &&
+            $3->getBasicType() != EbtBool &&
+            $3->getBasicType() != EbtString)
+            parseContext.error($3->getLoc(), "this type not allowed", $3->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_storage_class_qualifier
+    : SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.storage = EvqSpirvStorageClass;
+        $$.qualifier.spirvStorageClass = $3.i;
+    }
+    | SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.storage = EvqSpirvStorageClass;
+        $$.qualifier.spirvStorageClass = $5.i;
+    }
+
+spirv_decorate_qualifier
+    : SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN{
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorate($3.i);
+    }
+    | SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN{
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorate($5.i);
+    }
+    | SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorate($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorate($5.i, $7->getAsAggregate());
+    }
+    | SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorateId($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorateId($5.i, $7->getAsAggregate());
+    }
+    | SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorateString($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorateString($5.i, $7->getAsAggregate());
+    }
+
+spirv_decorate_parameter_list
+    : spirv_decorate_parameter {
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_decorate_parameter_list COMMA spirv_decorate_parameter {
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_decorate_parameter
+    : FLOATCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
+    }
+    | INTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.i, $1.loc, true);
+    }
+    | UINTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
+    }
+    | BOOLCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.b, $1.loc, true);
+    }
+
+spirv_decorate_id_parameter_list
+    : constant_expression {
+        if ($1->getBasicType() != EbtFloat &&
+            $1->getBasicType() != EbtInt &&
+            $1->getBasicType() != EbtUint &&
+            $1->getBasicType() != EbtBool)
+            parseContext.error($1->getLoc(), "this type not allowed", $1->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_decorate_id_parameter_list COMMA constant_expression {
+        if ($3->getBasicType() != EbtFloat &&
+            $3->getBasicType() != EbtInt &&
+            $3->getBasicType() != EbtUint &&
+            $3->getBasicType() != EbtBool)
+            parseContext.error($3->getLoc(), "this type not allowed", $3->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_decorate_string_parameter_list
+    : STRING_LITERAL {
+        $$ = parseContext.intermediate.makeAggregate(
+            parseContext.intermediate.addConstantUnion($1.string, $1.loc, true));
+    }
+    | spirv_decorate_string_parameter_list COMMA STRING_LITERAL {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.string, $3.loc, true));
+    }
+
+spirv_type_specifier
+    : SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.setSpirvType(*$3, $5);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.setSpirvType(*$5, $7);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.setSpirvType(*$3);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.setSpirvType(*$5);
+    }
+
+spirv_type_parameter_list
+    : spirv_type_parameter {
+        $$ = $1;
+    }
+    | spirv_type_parameter_list COMMA spirv_type_parameter {
+        $$ = parseContext.mergeSpirvTypeParameters($1, $3);
+    }
+
+spirv_type_parameter
+    : constant_expression {
+        $$ = parseContext.makeSpirvTypeParameters($1->getLoc(), $1->getAsConstantUnion());
+    }
+    | type_specifier {
+        $$ = parseContext.makeSpirvTypeParameters($1);
+    }
+
+spirv_instruction_qualifier
+    : SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$ = $3;
+    }
+    | SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$ = $5;
+    }
+
+spirv_instruction_qualifier_list
+    : spirv_instruction_qualifier_id {
+        $$ = $1;
+    }
+    | spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id {
+        $$ = parseContext.mergeSpirvInstruction($2.loc, $1, $3);
+    }
+
+spirv_instruction_qualifier_id
+    : IDENTIFIER EQUAL STRING_LITERAL {
+        $$ = parseContext.makeSpirvInstruction($2.loc, *$1.string, *$3.string);
+    }
+    | IDENTIFIER EQUAL INTCONSTANT {
+        $$ = parseContext.makeSpirvInstruction($2.loc, *$1.string, $3.i);
+    }
+GLSLANG_WEB_EXCLUDE_OFF
+
 %%

diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
index 1c054c3..b77f461 100644 (file)
--- a/glslang/MachineIndependent/glslang.y
+++ b/glslang/MachineIndependent/glslang.y
@@ -116,6 +116,9 @@ using namespace glslang;
             glslang::TIntermNodePair nodePair;
             glslang::TIntermTyped* intermTypedNode;
             glslang::TAttributes* attributes;
+            glslang::TSpirvRequirement* spirvReq;
+            glslang::TSpirvInstruction* spirvInst;
+            glslang::TSpirvTypeParameters* spirvTypeParams;
         };
         union {
             glslang::TPublicType type;
@@ -271,6 +274,11 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> SUBPASSINPUT SUBPASSINPUTMS ISUBPASSINPUT ISUBPASSINPUTMS USUBPASSINPUT USUBPASSINPUTMS
 %token <lex> F16SUBPASSINPUT F16SUBPASSINPUTMS
 
+// spirv intrinsics
+%token <lex> SPIRV_INSTRUCTION SPIRV_EXECUTION_MODE SPIRV_EXECUTION_MODE_ID
+%token <lex> SPIRV_DECORATE SPIRV_DECORATE_ID SPIRV_DECORATE_STRING
+%token <lex> SPIRV_TYPE SPIRV_STORAGE_CLASS SPIRV_BY_REFERENCE SPIRV_LITERAL
+
 
 
 %token <lex> LEFT_OP RIGHT_OP
@@ -362,6 +370,19 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %type <interm.attributes> attribute attribute_list single_attribute
 %type <interm.intermNode> demote_statement
 %type <interm.intermTypedNode> initializer_list
+%type <interm.spirvReq> spirv_requirements_list spirv_requirements_parameter
+%type <interm.intermNode> spirv_extension_list spirv_capability_list
+%type <interm.intermNode> spirv_execution_mode_qualifier
+%type <interm.intermNode> spirv_execution_mode_parameter_list spirv_execution_mode_parameter spirv_execution_mode_id_parameter_list
+%type <interm.type> spirv_storage_class_qualifier
+%type <interm.type> spirv_decorate_qualifier
+%type <interm.intermNode> spirv_decorate_parameter_list spirv_decorate_parameter
+%type <interm.intermNode> spirv_decorate_id_parameter_list
+%type <interm.intermNode> spirv_decorate_string_parameter_list
+%type <interm.type> spirv_type_specifier
+%type <interm.spirvTypeParams> spirv_type_parameter_list spirv_type_parameter
+%type <interm.spirvInst> spirv_instruction_qualifier
+%type <interm.spirvInst> spirv_instruction_qualifier_list spirv_instruction_qualifier_id
 
 
 %start translation_unit
@@ -875,6 +896,20 @@ declaration
         $$ = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
+
+    | spirv_instruction_qualifier function_prototype SEMICOLON {
+        parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier");
+        $2.function->setSpirvInstruction(*$1); // Attach SPIR-V intruction qualifier
+        parseContext.handleFunctionDeclarator($2.loc, *$2.function, true /* prototype */);
+        $$ = 0;
+        // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
+    }
+    | spirv_execution_mode_qualifier SEMICOLON {
+        parseContext.globalCheck($2.loc, "SPIR-V execution mode qualifier");
+        parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier");
+        $$ = 0;
+    }
+
     | init_declarator_list SEMICOLON {
         if ($1.intermNode && $1.intermNode->getAsAggregate())
             $1.intermNode->getAsAggregate()->setOperator(EOpSequence);
@@ -1366,6 +1401,25 @@ single_type_qualifier
     | non_uniform_qualifier {
         $$ = $1;
     }
+    | spirv_storage_class_qualifier {
+        parseContext.globalCheck($1.loc, "spirv_storage_class");
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier");
+        $$ = $1;
+    }
+    | spirv_decorate_qualifier {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier");
+        $$ = $1;
+    }
+    | SPIRV_BY_REFERENCE {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference");
+        $$.init($1.loc);
+        $$.qualifier.setSpirvByReference();
+    }
+    | SPIRV_LITERAL {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal");
+        $$.init($1.loc);
+        $$.qualifier.setSpirvLiteral();
+    }
 
     ;
 
@@ -3426,6 +3480,10 @@ type_specifier_nonarray
         $$.basicType = EbtUint;
         $$.coopmat = true;
     }
+    | spirv_type_specifier {
+        parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
+        $$ = $1;
+    }
 
     | struct_specifier {
         $$ = $1;
@@ -4068,4 +4126,273 @@ single_attribute
     }
 
 
+
+spirv_requirements_list
+    : spirv_requirements_parameter {
+        $$ = $1;
+    }
+    | spirv_requirements_list COMMA spirv_requirements_parameter {
+        $$ = parseContext.mergeSpirvRequirements($2.loc, $1, $3);
+    }
+
+spirv_requirements_parameter
+    : IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET {
+        $$ = parseContext.makeSpirvRequirement($2.loc, *$1.string, $4->getAsAggregate(), nullptr);
+    }
+    | IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET {
+        $$ = parseContext.makeSpirvRequirement($2.loc, *$1.string, nullptr, $4->getAsAggregate());
+    }
+
+spirv_extension_list
+    : STRING_LITERAL {
+        $$ = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion($1.string, $1.loc, true));
+    }
+    | spirv_extension_list COMMA STRING_LITERAL {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.string, $3.loc, true));
+    }
+
+spirv_capability_list
+    : INTCONSTANT {
+        $$ = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion($1.i, $1.loc, true));
+    }
+    | spirv_capability_list COMMA INTCONSTANT {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.i, $3.loc, true));
+    }
+
+spirv_execution_mode_qualifier
+    : SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionMode($3.i);
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionMode($5.i);
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionMode($3.i, $5->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionMode($5.i, $7->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvExecutionModeId($3.i, $5->getAsAggregate());
+        $$ = 0;
+    }
+    | SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        parseContext.intermediate.insertSpirvExecutionModeId($5.i, $7->getAsAggregate());
+        $$ = 0;
+    }
+
+spirv_execution_mode_parameter_list
+    : spirv_execution_mode_parameter {
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter {
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_execution_mode_parameter
+    : FLOATCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
+    }
+    | INTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.i, $1.loc, true);
+    }
+    | UINTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
+    }
+    | BOOLCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.b, $1.loc, true);
+    }
+    | STRING_LITERAL {
+        $$ = parseContext.intermediate.addConstantUnion($1.string, $1.loc, true);
+    }
+
+spirv_execution_mode_id_parameter_list
+    : constant_expression {
+        if ($1->getBasicType() != EbtFloat &&
+            $1->getBasicType() != EbtInt &&
+            $1->getBasicType() != EbtUint &&
+            $1->getBasicType() != EbtBool &&
+            $1->getBasicType() != EbtString)
+            parseContext.error($1->getLoc(), "this type not allowed", $1->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_execution_mode_id_parameter_list COMMA constant_expression {
+        if ($3->getBasicType() != EbtFloat &&
+            $3->getBasicType() != EbtInt &&
+            $3->getBasicType() != EbtUint &&
+            $3->getBasicType() != EbtBool &&
+            $3->getBasicType() != EbtString)
+            parseContext.error($3->getLoc(), "this type not allowed", $3->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_storage_class_qualifier
+    : SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.storage = EvqSpirvStorageClass;
+        $$.qualifier.spirvStorageClass = $3.i;
+    }
+    | SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.storage = EvqSpirvStorageClass;
+        $$.qualifier.spirvStorageClass = $5.i;
+    }
+
+spirv_decorate_qualifier
+    : SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN{
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorate($3.i);
+    }
+    | SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN{
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorate($5.i);
+    }
+    | SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorate($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorate($5.i, $7->getAsAggregate());
+    }
+    | SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorateId($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorateId($5.i, $7->getAsAggregate());
+    }
+    | SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        $$.qualifier.setSpirvDecorateString($3.i, $5->getAsAggregate());
+    }
+    | SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN {
+        $$.init($1.loc);
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.qualifier.setSpirvDecorateString($5.i, $7->getAsAggregate());
+    }
+
+spirv_decorate_parameter_list
+    : spirv_decorate_parameter {
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_decorate_parameter_list COMMA spirv_decorate_parameter {
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_decorate_parameter
+    : FLOATCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
+    }
+    | INTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.i, $1.loc, true);
+    }
+    | UINTCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
+    }
+    | BOOLCONSTANT {
+        $$ = parseContext.intermediate.addConstantUnion($1.b, $1.loc, true);
+    }
+
+spirv_decorate_id_parameter_list
+    : constant_expression {
+        if ($1->getBasicType() != EbtFloat &&
+            $1->getBasicType() != EbtInt &&
+            $1->getBasicType() != EbtUint &&
+            $1->getBasicType() != EbtBool)
+            parseContext.error($1->getLoc(), "this type not allowed", $1->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.makeAggregate($1);
+    }
+    | spirv_decorate_id_parameter_list COMMA constant_expression {
+        if ($3->getBasicType() != EbtFloat &&
+            $3->getBasicType() != EbtInt &&
+            $3->getBasicType() != EbtUint &&
+            $3->getBasicType() != EbtBool)
+            parseContext.error($3->getLoc(), "this type not allowed", $3->getType().getBasicString(), "");
+        $$ = parseContext.intermediate.growAggregate($1, $3);
+    }
+
+spirv_decorate_string_parameter_list
+    : STRING_LITERAL {
+        $$ = parseContext.intermediate.makeAggregate(
+            parseContext.intermediate.addConstantUnion($1.string, $1.loc, true));
+    }
+    | spirv_decorate_string_parameter_list COMMA STRING_LITERAL {
+        $$ = parseContext.intermediate.growAggregate($1, parseContext.intermediate.addConstantUnion($3.string, $3.loc, true));
+    }
+
+spirv_type_specifier
+    : SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.setSpirvType(*$3, $5);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.setSpirvType(*$5, $7);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.setSpirvType(*$3);
+    }
+    | SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$.setSpirvType(*$5);
+    }
+
+spirv_type_parameter_list
+    : spirv_type_parameter {
+        $$ = $1;
+    }
+    | spirv_type_parameter_list COMMA spirv_type_parameter {
+        $$ = parseContext.mergeSpirvTypeParameters($1, $3);
+    }
+
+spirv_type_parameter
+    : constant_expression {
+        $$ = parseContext.makeSpirvTypeParameters($1->getLoc(), $1->getAsConstantUnion());
+    }
+    | type_specifier {
+        $$ = parseContext.makeSpirvTypeParameters($1);
+    }
+
+spirv_instruction_qualifier
+    : SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN {
+        $$ = $3;
+    }
+    | SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN {
+        parseContext.intermediate.insertSpirvRequirement($3);
+        $$ = $5;
+    }
+
+spirv_instruction_qualifier_list
+    : spirv_instruction_qualifier_id {
+        $$ = $1;
+    }
+    | spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id {
+        $$ = parseContext.mergeSpirvInstruction($2.loc, $1, $3);
+    }
+
+spirv_instruction_qualifier_id
+    : IDENTIFIER EQUAL STRING_LITERAL {
+        $$ = parseContext.makeSpirvInstruction($2.loc, *$1.string, *$3.string);
+    }
+    | IDENTIFIER EQUAL INTCONSTANT {
+        $$ = parseContext.makeSpirvInstruction($2.loc, *$1.string, $3.i);
+    }
+
+
 %%

diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
index 35928eb..dba06ae 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp
+++ b/glslang/MachineIndependent/glslang_tab.cpp
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.7.5.  */
+/* A Bison parser, made by GNU Bison 3.7.4.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
    Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -46,10 +46,10 @@
    USER NAME SPACE" below.  */
 
 /* Identify Bison output, and Bison version.  */
-#define YYBISON 30705
+#define YYBISON 30704
 
 /* Bison version string.  */
-#define YYBISON_VERSION "3.7.5"
+#define YYBISON_VERSION "3.7.4"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -438,251 +438,281 @@ enum yysymbol_kind_t
   YYSYMBOL_USUBPASSINPUTMS = 314,          /* USUBPASSINPUTMS  */
   YYSYMBOL_F16SUBPASSINPUT = 315,          /* F16SUBPASSINPUT  */
   YYSYMBOL_F16SUBPASSINPUTMS = 316,        /* F16SUBPASSINPUTMS  */
-  YYSYMBOL_LEFT_OP = 317,                  /* LEFT_OP  */
-  YYSYMBOL_RIGHT_OP = 318,                 /* RIGHT_OP  */
-  YYSYMBOL_INC_OP = 319,                   /* INC_OP  */
-  YYSYMBOL_DEC_OP = 320,                   /* DEC_OP  */
-  YYSYMBOL_LE_OP = 321,                    /* LE_OP  */
-  YYSYMBOL_GE_OP = 322,                    /* GE_OP  */
-  YYSYMBOL_EQ_OP = 323,                    /* EQ_OP  */
-  YYSYMBOL_NE_OP = 324,                    /* NE_OP  */
-  YYSYMBOL_AND_OP = 325,                   /* AND_OP  */
-  YYSYMBOL_OR_OP = 326,                    /* OR_OP  */
-  YYSYMBOL_XOR_OP = 327,                   /* XOR_OP  */
-  YYSYMBOL_MUL_ASSIGN = 328,               /* MUL_ASSIGN  */
-  YYSYMBOL_DIV_ASSIGN = 329,               /* DIV_ASSIGN  */
-  YYSYMBOL_ADD_ASSIGN = 330,               /* ADD_ASSIGN  */
-  YYSYMBOL_MOD_ASSIGN = 331,               /* MOD_ASSIGN  */
-  YYSYMBOL_LEFT_ASSIGN = 332,              /* LEFT_ASSIGN  */
-  YYSYMBOL_RIGHT_ASSIGN = 333,             /* RIGHT_ASSIGN  */
-  YYSYMBOL_AND_ASSIGN = 334,               /* AND_ASSIGN  */
-  YYSYMBOL_XOR_ASSIGN = 335,               /* XOR_ASSIGN  */
-  YYSYMBOL_OR_ASSIGN = 336,                /* OR_ASSIGN  */
-  YYSYMBOL_SUB_ASSIGN = 337,               /* SUB_ASSIGN  */
-  YYSYMBOL_STRING_LITERAL = 338,           /* STRING_LITERAL  */
-  YYSYMBOL_LEFT_PAREN = 339,               /* LEFT_PAREN  */
-  YYSYMBOL_RIGHT_PAREN = 340,              /* RIGHT_PAREN  */
-  YYSYMBOL_LEFT_BRACKET = 341,             /* LEFT_BRACKET  */
-  YYSYMBOL_RIGHT_BRACKET = 342,            /* RIGHT_BRACKET  */
-  YYSYMBOL_LEFT_BRACE = 343,               /* LEFT_BRACE  */
-  YYSYMBOL_RIGHT_BRACE = 344,              /* RIGHT_BRACE  */
-  YYSYMBOL_DOT = 345,                      /* DOT  */
-  YYSYMBOL_COMMA = 346,                    /* COMMA  */
-  YYSYMBOL_COLON = 347,                    /* COLON  */
-  YYSYMBOL_EQUAL = 348,                    /* EQUAL  */
-  YYSYMBOL_SEMICOLON = 349,                /* SEMICOLON  */
-  YYSYMBOL_BANG = 350,                     /* BANG  */
-  YYSYMBOL_DASH = 351,                     /* DASH  */
-  YYSYMBOL_TILDE = 352,                    /* TILDE  */
-  YYSYMBOL_PLUS = 353,                     /* PLUS  */
-  YYSYMBOL_STAR = 354,                     /* STAR  */
-  YYSYMBOL_SLASH = 355,                    /* SLASH  */
-  YYSYMBOL_PERCENT = 356,                  /* PERCENT  */
-  YYSYMBOL_LEFT_ANGLE = 357,               /* LEFT_ANGLE  */
-  YYSYMBOL_RIGHT_ANGLE = 358,              /* RIGHT_ANGLE  */
-  YYSYMBOL_VERTICAL_BAR = 359,             /* VERTICAL_BAR  */
-  YYSYMBOL_CARET = 360,                    /* CARET  */
-  YYSYMBOL_AMPERSAND = 361,                /* AMPERSAND  */
-  YYSYMBOL_QUESTION = 362,                 /* QUESTION  */
-  YYSYMBOL_INVARIANT = 363,                /* INVARIANT  */
-  YYSYMBOL_HIGH_PRECISION = 364,           /* HIGH_PRECISION  */
-  YYSYMBOL_MEDIUM_PRECISION = 365,         /* MEDIUM_PRECISION  */
-  YYSYMBOL_LOW_PRECISION = 366,            /* LOW_PRECISION  */
-  YYSYMBOL_PRECISION = 367,                /* PRECISION  */
-  YYSYMBOL_PACKED = 368,                   /* PACKED  */
-  YYSYMBOL_RESOURCE = 369,                 /* RESOURCE  */
-  YYSYMBOL_SUPERP = 370,                   /* SUPERP  */
-  YYSYMBOL_FLOATCONSTANT = 371,            /* FLOATCONSTANT  */
-  YYSYMBOL_INTCONSTANT = 372,              /* INTCONSTANT  */
-  YYSYMBOL_UINTCONSTANT = 373,             /* UINTCONSTANT  */
-  YYSYMBOL_BOOLCONSTANT = 374,             /* BOOLCONSTANT  */
-  YYSYMBOL_IDENTIFIER = 375,               /* IDENTIFIER  */
-  YYSYMBOL_TYPE_NAME = 376,                /* TYPE_NAME  */
-  YYSYMBOL_CENTROID = 377,                 /* CENTROID  */
-  YYSYMBOL_IN = 378,                       /* IN  */
-  YYSYMBOL_OUT = 379,                      /* OUT  */
-  YYSYMBOL_INOUT = 380,                    /* INOUT  */
-  YYSYMBOL_STRUCT = 381,                   /* STRUCT  */
-  YYSYMBOL_VOID = 382,                     /* VOID  */
-  YYSYMBOL_WHILE = 383,                    /* WHILE  */
-  YYSYMBOL_BREAK = 384,                    /* BREAK  */
-  YYSYMBOL_CONTINUE = 385,                 /* CONTINUE  */
-  YYSYMBOL_DO = 386,                       /* DO  */
-  YYSYMBOL_ELSE = 387,                     /* ELSE  */
-  YYSYMBOL_FOR = 388,                      /* FOR  */
-  YYSYMBOL_IF = 389,                       /* IF  */
-  YYSYMBOL_DISCARD = 390,                  /* DISCARD  */
-  YYSYMBOL_RETURN = 391,                   /* RETURN  */
-  YYSYMBOL_SWITCH = 392,                   /* SWITCH  */
-  YYSYMBOL_CASE = 393,                     /* CASE  */
-  YYSYMBOL_DEFAULT = 394,                  /* DEFAULT  */
-  YYSYMBOL_TERMINATE_INVOCATION = 395,     /* TERMINATE_INVOCATION  */
-  YYSYMBOL_TERMINATE_RAY = 396,            /* TERMINATE_RAY  */
-  YYSYMBOL_IGNORE_INTERSECTION = 397,      /* IGNORE_INTERSECTION  */
-  YYSYMBOL_UNIFORM = 398,                  /* UNIFORM  */
-  YYSYMBOL_SHARED = 399,                   /* SHARED  */
-  YYSYMBOL_BUFFER = 400,                   /* BUFFER  */
-  YYSYMBOL_FLAT = 401,                     /* FLAT  */
-  YYSYMBOL_SMOOTH = 402,                   /* SMOOTH  */
-  YYSYMBOL_LAYOUT = 403,                   /* LAYOUT  */
-  YYSYMBOL_DOUBLECONSTANT = 404,           /* DOUBLECONSTANT  */
-  YYSYMBOL_INT16CONSTANT = 405,            /* INT16CONSTANT  */
-  YYSYMBOL_UINT16CONSTANT = 406,           /* UINT16CONSTANT  */
-  YYSYMBOL_FLOAT16CONSTANT = 407,          /* FLOAT16CONSTANT  */
-  YYSYMBOL_INT32CONSTANT = 408,            /* INT32CONSTANT  */
-  YYSYMBOL_UINT32CONSTANT = 409,           /* UINT32CONSTANT  */
-  YYSYMBOL_INT64CONSTANT = 410,            /* INT64CONSTANT  */
-  YYSYMBOL_UINT64CONSTANT = 411,           /* UINT64CONSTANT  */
-  YYSYMBOL_SUBROUTINE = 412,               /* SUBROUTINE  */
-  YYSYMBOL_DEMOTE = 413,                   /* DEMOTE  */
-  YYSYMBOL_PAYLOADNV = 414,                /* PAYLOADNV  */
-  YYSYMBOL_PAYLOADINNV = 415,              /* PAYLOADINNV  */
-  YYSYMBOL_HITATTRNV = 416,                /* HITATTRNV  */
-  YYSYMBOL_CALLDATANV = 417,               /* CALLDATANV  */
-  YYSYMBOL_CALLDATAINNV = 418,             /* CALLDATAINNV  */
-  YYSYMBOL_PAYLOADEXT = 419,               /* PAYLOADEXT  */
-  YYSYMBOL_PAYLOADINEXT = 420,             /* PAYLOADINEXT  */
-  YYSYMBOL_HITATTREXT = 421,               /* HITATTREXT  */
-  YYSYMBOL_CALLDATAEXT = 422,              /* CALLDATAEXT  */
-  YYSYMBOL_CALLDATAINEXT = 423,            /* CALLDATAINEXT  */
-  YYSYMBOL_PATCH = 424,                    /* PATCH  */
-  YYSYMBOL_SAMPLE = 425,                   /* SAMPLE  */
-  YYSYMBOL_NONUNIFORM = 426,               /* NONUNIFORM  */
-  YYSYMBOL_COHERENT = 427,                 /* COHERENT  */
-  YYSYMBOL_VOLATILE = 428,                 /* VOLATILE  */
-  YYSYMBOL_RESTRICT = 429,                 /* RESTRICT  */
-  YYSYMBOL_READONLY = 430,                 /* READONLY  */
-  YYSYMBOL_WRITEONLY = 431,                /* WRITEONLY  */
-  YYSYMBOL_DEVICECOHERENT = 432,           /* DEVICECOHERENT  */
-  YYSYMBOL_QUEUEFAMILYCOHERENT = 433,      /* QUEUEFAMILYCOHERENT  */
-  YYSYMBOL_WORKGROUPCOHERENT = 434,        /* WORKGROUPCOHERENT  */
-  YYSYMBOL_SUBGROUPCOHERENT = 435,         /* SUBGROUPCOHERENT  */
-  YYSYMBOL_NONPRIVATE = 436,               /* NONPRIVATE  */
-  YYSYMBOL_SHADERCALLCOHERENT = 437,       /* SHADERCALLCOHERENT  */
-  YYSYMBOL_NOPERSPECTIVE = 438,            /* NOPERSPECTIVE  */
-  YYSYMBOL_EXPLICITINTERPAMD = 439,        /* EXPLICITINTERPAMD  */
-  YYSYMBOL_PERVERTEXNV = 440,              /* PERVERTEXNV  */
-  YYSYMBOL_PERPRIMITIVENV = 441,           /* PERPRIMITIVENV  */
-  YYSYMBOL_PERVIEWNV = 442,                /* PERVIEWNV  */
-  YYSYMBOL_PERTASKNV = 443,                /* PERTASKNV  */
-  YYSYMBOL_PRECISE = 444,                  /* PRECISE  */
-  YYSYMBOL_YYACCEPT = 445,                 /* $accept  */
-  YYSYMBOL_variable_identifier = 446,      /* variable_identifier  */
-  YYSYMBOL_primary_expression = 447,       /* primary_expression  */
-  YYSYMBOL_postfix_expression = 448,       /* postfix_expression  */
-  YYSYMBOL_integer_expression = 449,       /* integer_expression  */
-  YYSYMBOL_function_call = 450,            /* function_call  */
-  YYSYMBOL_function_call_or_method = 451,  /* function_call_or_method  */
-  YYSYMBOL_function_call_generic = 452,    /* function_call_generic  */
-  YYSYMBOL_function_call_header_no_parameters = 453, /* function_call_header_no_parameters  */
-  YYSYMBOL_function_call_header_with_parameters = 454, /* function_call_header_with_parameters  */
-  YYSYMBOL_function_call_header = 455,     /* function_call_header  */
-  YYSYMBOL_function_identifier = 456,      /* function_identifier  */
-  YYSYMBOL_unary_expression = 457,         /* unary_expression  */
-  YYSYMBOL_unary_operator = 458,           /* unary_operator  */
-  YYSYMBOL_multiplicative_expression = 459, /* multiplicative_expression  */
-  YYSYMBOL_additive_expression = 460,      /* additive_expression  */
-  YYSYMBOL_shift_expression = 461,         /* shift_expression  */
-  YYSYMBOL_relational_expression = 462,    /* relational_expression  */
-  YYSYMBOL_equality_expression = 463,      /* equality_expression  */
-  YYSYMBOL_and_expression = 464,           /* and_expression  */
-  YYSYMBOL_exclusive_or_expression = 465,  /* exclusive_or_expression  */
-  YYSYMBOL_inclusive_or_expression = 466,  /* inclusive_or_expression  */
-  YYSYMBOL_logical_and_expression = 467,   /* logical_and_expression  */
-  YYSYMBOL_logical_xor_expression = 468,   /* logical_xor_expression  */
-  YYSYMBOL_logical_or_expression = 469,    /* logical_or_expression  */
-  YYSYMBOL_conditional_expression = 470,   /* conditional_expression  */
-  YYSYMBOL_471_1 = 471,                    /* $@1  */
-  YYSYMBOL_assignment_expression = 472,    /* assignment_expression  */
-  YYSYMBOL_assignment_operator = 473,      /* assignment_operator  */
-  YYSYMBOL_expression = 474,               /* expression  */
-  YYSYMBOL_constant_expression = 475,      /* constant_expression  */
-  YYSYMBOL_declaration = 476,              /* declaration  */
-  YYSYMBOL_block_structure = 477,          /* block_structure  */
-  YYSYMBOL_478_2 = 478,                    /* $@2  */
-  YYSYMBOL_identifier_list = 479,          /* identifier_list  */
-  YYSYMBOL_function_prototype = 480,       /* function_prototype  */
-  YYSYMBOL_function_declarator = 481,      /* function_declarator  */
-  YYSYMBOL_function_header_with_parameters = 482, /* function_header_with_parameters  */
-  YYSYMBOL_function_header = 483,          /* function_header  */
-  YYSYMBOL_parameter_declarator = 484,     /* parameter_declarator  */
-  YYSYMBOL_parameter_declaration = 485,    /* parameter_declaration  */
-  YYSYMBOL_parameter_type_specifier = 486, /* parameter_type_specifier  */
-  YYSYMBOL_init_declarator_list = 487,     /* init_declarator_list  */
-  YYSYMBOL_single_declaration = 488,       /* single_declaration  */
-  YYSYMBOL_fully_specified_type = 489,     /* fully_specified_type  */
-  YYSYMBOL_invariant_qualifier = 490,      /* invariant_qualifier  */
-  YYSYMBOL_interpolation_qualifier = 491,  /* interpolation_qualifier  */
-  YYSYMBOL_layout_qualifier = 492,         /* layout_qualifier  */
-  YYSYMBOL_layout_qualifier_id_list = 493, /* layout_qualifier_id_list  */
-  YYSYMBOL_layout_qualifier_id = 494,      /* layout_qualifier_id  */
-  YYSYMBOL_precise_qualifier = 495,        /* precise_qualifier  */
-  YYSYMBOL_type_qualifier = 496,           /* type_qualifier  */
-  YYSYMBOL_single_type_qualifier = 497,    /* single_type_qualifier  */
-  YYSYMBOL_storage_qualifier = 498,        /* storage_qualifier  */
-  YYSYMBOL_non_uniform_qualifier = 499,    /* non_uniform_qualifier  */
-  YYSYMBOL_type_name_list = 500,           /* type_name_list  */
-  YYSYMBOL_type_specifier = 501,           /* type_specifier  */
-  YYSYMBOL_array_specifier = 502,          /* array_specifier  */
-  YYSYMBOL_type_parameter_specifier_opt = 503, /* type_parameter_specifier_opt  */
-  YYSYMBOL_type_parameter_specifier = 504, /* type_parameter_specifier  */
-  YYSYMBOL_type_parameter_specifier_list = 505, /* type_parameter_specifier_list  */
-  YYSYMBOL_type_specifier_nonarray = 506,  /* type_specifier_nonarray  */
-  YYSYMBOL_precision_qualifier = 507,      /* precision_qualifier  */
-  YYSYMBOL_struct_specifier = 508,         /* struct_specifier  */
-  YYSYMBOL_509_3 = 509,                    /* $@3  */
-  YYSYMBOL_510_4 = 510,                    /* $@4  */
-  YYSYMBOL_struct_declaration_list = 511,  /* struct_declaration_list  */
-  YYSYMBOL_struct_declaration = 512,       /* struct_declaration  */
-  YYSYMBOL_struct_declarator_list = 513,   /* struct_declarator_list  */
-  YYSYMBOL_struct_declarator = 514,        /* struct_declarator  */
-  YYSYMBOL_initializer = 515,              /* initializer  */
-  YYSYMBOL_initializer_list = 516,         /* initializer_list  */
-  YYSYMBOL_declaration_statement = 517,    /* declaration_statement  */
-  YYSYMBOL_statement = 518,                /* statement  */
-  YYSYMBOL_simple_statement = 519,         /* simple_statement  */
-  YYSYMBOL_demote_statement = 520,         /* demote_statement  */
-  YYSYMBOL_compound_statement = 521,       /* compound_statement  */
-  YYSYMBOL_522_5 = 522,                    /* $@5  */
-  YYSYMBOL_523_6 = 523,                    /* $@6  */
-  YYSYMBOL_statement_no_new_scope = 524,   /* statement_no_new_scope  */
-  YYSYMBOL_statement_scoped = 525,         /* statement_scoped  */
-  YYSYMBOL_526_7 = 526,                    /* $@7  */
-  YYSYMBOL_527_8 = 527,                    /* $@8  */
-  YYSYMBOL_compound_statement_no_new_scope = 528, /* compound_statement_no_new_scope  */
-  YYSYMBOL_statement_list = 529,           /* statement_list  */
-  YYSYMBOL_expression_statement = 530,     /* expression_statement  */
-  YYSYMBOL_selection_statement = 531,      /* selection_statement  */
-  YYSYMBOL_selection_statement_nonattributed = 532, /* selection_statement_nonattributed  */
-  YYSYMBOL_selection_rest_statement = 533, /* selection_rest_statement  */
-  YYSYMBOL_condition = 534,                /* condition  */
-  YYSYMBOL_switch_statement = 535,         /* switch_statement  */
-  YYSYMBOL_switch_statement_nonattributed = 536, /* switch_statement_nonattributed  */
-  YYSYMBOL_537_9 = 537,                    /* $@9  */
-  YYSYMBOL_switch_statement_list = 538,    /* switch_statement_list  */
-  YYSYMBOL_case_label = 539,               /* case_label  */
-  YYSYMBOL_iteration_statement = 540,      /* iteration_statement  */
-  YYSYMBOL_iteration_statement_nonattributed = 541, /* iteration_statement_nonattributed  */
-  YYSYMBOL_542_10 = 542,                   /* $@10  */
-  YYSYMBOL_543_11 = 543,                   /* $@11  */
-  YYSYMBOL_544_12 = 544,                   /* $@12  */
-  YYSYMBOL_for_init_statement = 545,       /* for_init_statement  */
-  YYSYMBOL_conditionopt = 546,             /* conditionopt  */
-  YYSYMBOL_for_rest_statement = 547,       /* for_rest_statement  */
-  YYSYMBOL_jump_statement = 548,           /* jump_statement  */
-  YYSYMBOL_translation_unit = 549,         /* translation_unit  */
-  YYSYMBOL_external_declaration = 550,     /* external_declaration  */
-  YYSYMBOL_function_definition = 551,      /* function_definition  */
-  YYSYMBOL_552_13 = 552,                   /* $@13  */
-  YYSYMBOL_attribute = 553,                /* attribute  */
-  YYSYMBOL_attribute_list = 554,           /* attribute_list  */
-  YYSYMBOL_single_attribute = 555          /* single_attribute  */
+  YYSYMBOL_SPIRV_INSTRUCTION = 317,        /* SPIRV_INSTRUCTION  */
+  YYSYMBOL_SPIRV_EXECUTION_MODE = 318,     /* SPIRV_EXECUTION_MODE  */
+  YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 319,  /* SPIRV_EXECUTION_MODE_ID  */
+  YYSYMBOL_SPIRV_DECORATE = 320,           /* SPIRV_DECORATE  */
+  YYSYMBOL_SPIRV_DECORATE_ID = 321,        /* SPIRV_DECORATE_ID  */
+  YYSYMBOL_SPIRV_DECORATE_STRING = 322,    /* SPIRV_DECORATE_STRING  */
+  YYSYMBOL_SPIRV_TYPE = 323,               /* SPIRV_TYPE  */
+  YYSYMBOL_SPIRV_STORAGE_CLASS = 324,      /* SPIRV_STORAGE_CLASS  */
+  YYSYMBOL_SPIRV_BY_REFERENCE = 325,       /* SPIRV_BY_REFERENCE  */
+  YYSYMBOL_SPIRV_LITERAL = 326,            /* SPIRV_LITERAL  */
+  YYSYMBOL_LEFT_OP = 327,                  /* LEFT_OP  */
+  YYSYMBOL_RIGHT_OP = 328,                 /* RIGHT_OP  */
+  YYSYMBOL_INC_OP = 329,                   /* INC_OP  */
+  YYSYMBOL_DEC_OP = 330,                   /* DEC_OP  */
+  YYSYMBOL_LE_OP = 331,                    /* LE_OP  */
+  YYSYMBOL_GE_OP = 332,                    /* GE_OP  */
+  YYSYMBOL_EQ_OP = 333,                    /* EQ_OP  */
+  YYSYMBOL_NE_OP = 334,                    /* NE_OP  */
+  YYSYMBOL_AND_OP = 335,                   /* AND_OP  */
+  YYSYMBOL_OR_OP = 336,                    /* OR_OP  */
+  YYSYMBOL_XOR_OP = 337,                   /* XOR_OP  */
+  YYSYMBOL_MUL_ASSIGN = 338,               /* MUL_ASSIGN  */
+  YYSYMBOL_DIV_ASSIGN = 339,               /* DIV_ASSIGN  */
+  YYSYMBOL_ADD_ASSIGN = 340,               /* ADD_ASSIGN  */
+  YYSYMBOL_MOD_ASSIGN = 341,               /* MOD_ASSIGN  */
+  YYSYMBOL_LEFT_ASSIGN = 342,              /* LEFT_ASSIGN  */
+  YYSYMBOL_RIGHT_ASSIGN = 343,             /* RIGHT_ASSIGN  */
+  YYSYMBOL_AND_ASSIGN = 344,               /* AND_ASSIGN  */
+  YYSYMBOL_XOR_ASSIGN = 345,               /* XOR_ASSIGN  */
+  YYSYMBOL_OR_ASSIGN = 346,                /* OR_ASSIGN  */
+  YYSYMBOL_SUB_ASSIGN = 347,               /* SUB_ASSIGN  */
+  YYSYMBOL_STRING_LITERAL = 348,           /* STRING_LITERAL  */
+  YYSYMBOL_LEFT_PAREN = 349,               /* LEFT_PAREN  */
+  YYSYMBOL_RIGHT_PAREN = 350,              /* RIGHT_PAREN  */
+  YYSYMBOL_LEFT_BRACKET = 351,             /* LEFT_BRACKET  */
+  YYSYMBOL_RIGHT_BRACKET = 352,            /* RIGHT_BRACKET  */
+  YYSYMBOL_LEFT_BRACE = 353,               /* LEFT_BRACE  */
+  YYSYMBOL_RIGHT_BRACE = 354,              /* RIGHT_BRACE  */
+  YYSYMBOL_DOT = 355,                      /* DOT  */
+  YYSYMBOL_COMMA = 356,                    /* COMMA  */
+  YYSYMBOL_COLON = 357,                    /* COLON  */
+  YYSYMBOL_EQUAL = 358,                    /* EQUAL  */
+  YYSYMBOL_SEMICOLON = 359,                /* SEMICOLON  */
+  YYSYMBOL_BANG = 360,                     /* BANG  */
+  YYSYMBOL_DASH = 361,                     /* DASH  */
+  YYSYMBOL_TILDE = 362,                    /* TILDE  */
+  YYSYMBOL_PLUS = 363,                     /* PLUS  */
+  YYSYMBOL_STAR = 364,                     /* STAR  */
+  YYSYMBOL_SLASH = 365,                    /* SLASH  */
+  YYSYMBOL_PERCENT = 366,                  /* PERCENT  */
+  YYSYMBOL_LEFT_ANGLE = 367,               /* LEFT_ANGLE  */
+  YYSYMBOL_RIGHT_ANGLE = 368,              /* RIGHT_ANGLE  */
+  YYSYMBOL_VERTICAL_BAR = 369,             /* VERTICAL_BAR  */
+  YYSYMBOL_CARET = 370,                    /* CARET  */
+  YYSYMBOL_AMPERSAND = 371,                /* AMPERSAND  */
+  YYSYMBOL_QUESTION = 372,                 /* QUESTION  */
+  YYSYMBOL_INVARIANT = 373,                /* INVARIANT  */
+  YYSYMBOL_HIGH_PRECISION = 374,           /* HIGH_PRECISION  */
+  YYSYMBOL_MEDIUM_PRECISION = 375,         /* MEDIUM_PRECISION  */
+  YYSYMBOL_LOW_PRECISION = 376,            /* LOW_PRECISION  */
+  YYSYMBOL_PRECISION = 377,                /* PRECISION  */
+  YYSYMBOL_PACKED = 378,                   /* PACKED  */
+  YYSYMBOL_RESOURCE = 379,                 /* RESOURCE  */
+  YYSYMBOL_SUPERP = 380,                   /* SUPERP  */
+  YYSYMBOL_FLOATCONSTANT = 381,            /* FLOATCONSTANT  */
+  YYSYMBOL_INTCONSTANT = 382,              /* INTCONSTANT  */
+  YYSYMBOL_UINTCONSTANT = 383,             /* UINTCONSTANT  */
+  YYSYMBOL_BOOLCONSTANT = 384,             /* BOOLCONSTANT  */
+  YYSYMBOL_IDENTIFIER = 385,               /* IDENTIFIER  */
+  YYSYMBOL_TYPE_NAME = 386,                /* TYPE_NAME  */
+  YYSYMBOL_CENTROID = 387,                 /* CENTROID  */
+  YYSYMBOL_IN = 388,                       /* IN  */
+  YYSYMBOL_OUT = 389,                      /* OUT  */
+  YYSYMBOL_INOUT = 390,                    /* INOUT  */
+  YYSYMBOL_STRUCT = 391,                   /* STRUCT  */
+  YYSYMBOL_VOID = 392,                     /* VOID  */
+  YYSYMBOL_WHILE = 393,                    /* WHILE  */
+  YYSYMBOL_BREAK = 394,                    /* BREAK  */
+  YYSYMBOL_CONTINUE = 395,                 /* CONTINUE  */
+  YYSYMBOL_DO = 396,                       /* DO  */
+  YYSYMBOL_ELSE = 397,                     /* ELSE  */
+  YYSYMBOL_FOR = 398,                      /* FOR  */
+  YYSYMBOL_IF = 399,                       /* IF  */
+  YYSYMBOL_DISCARD = 400,                  /* DISCARD  */
+  YYSYMBOL_RETURN = 401,                   /* RETURN  */
+  YYSYMBOL_SWITCH = 402,                   /* SWITCH  */
+  YYSYMBOL_CASE = 403,                     /* CASE  */
+  YYSYMBOL_DEFAULT = 404,                  /* DEFAULT  */
+  YYSYMBOL_TERMINATE_INVOCATION = 405,     /* TERMINATE_INVOCATION  */
+  YYSYMBOL_TERMINATE_RAY = 406,            /* TERMINATE_RAY  */
+  YYSYMBOL_IGNORE_INTERSECTION = 407,      /* IGNORE_INTERSECTION  */
+  YYSYMBOL_UNIFORM = 408,                  /* UNIFORM  */
+  YYSYMBOL_SHARED = 409,                   /* SHARED  */
+  YYSYMBOL_BUFFER = 410,                   /* BUFFER  */
+  YYSYMBOL_FLAT = 411,                     /* FLAT  */
+  YYSYMBOL_SMOOTH = 412,                   /* SMOOTH  */
+  YYSYMBOL_LAYOUT = 413,                   /* LAYOUT  */
+  YYSYMBOL_DOUBLECONSTANT = 414,           /* DOUBLECONSTANT  */
+  YYSYMBOL_INT16CONSTANT = 415,            /* INT16CONSTANT  */
+  YYSYMBOL_UINT16CONSTANT = 416,           /* UINT16CONSTANT  */
+  YYSYMBOL_FLOAT16CONSTANT = 417,          /* FLOAT16CONSTANT  */
+  YYSYMBOL_INT32CONSTANT = 418,            /* INT32CONSTANT  */
+  YYSYMBOL_UINT32CONSTANT = 419,           /* UINT32CONSTANT  */
+  YYSYMBOL_INT64CONSTANT = 420,            /* INT64CONSTANT  */
+  YYSYMBOL_UINT64CONSTANT = 421,           /* UINT64CONSTANT  */
+  YYSYMBOL_SUBROUTINE = 422,               /* SUBROUTINE  */
+  YYSYMBOL_DEMOTE = 423,                   /* DEMOTE  */
+  YYSYMBOL_PAYLOADNV = 424,                /* PAYLOADNV  */
+  YYSYMBOL_PAYLOADINNV = 425,              /* PAYLOADINNV  */
+  YYSYMBOL_HITATTRNV = 426,                /* HITATTRNV  */
+  YYSYMBOL_CALLDATANV = 427,               /* CALLDATANV  */
+  YYSYMBOL_CALLDATAINNV = 428,             /* CALLDATAINNV  */
+  YYSYMBOL_PAYLOADEXT = 429,               /* PAYLOADEXT  */
+  YYSYMBOL_PAYLOADINEXT = 430,             /* PAYLOADINEXT  */
+  YYSYMBOL_HITATTREXT = 431,               /* HITATTREXT  */
+  YYSYMBOL_CALLDATAEXT = 432,              /* CALLDATAEXT  */
+  YYSYMBOL_CALLDATAINEXT = 433,            /* CALLDATAINEXT  */
+  YYSYMBOL_PATCH = 434,                    /* PATCH  */
+  YYSYMBOL_SAMPLE = 435,                   /* SAMPLE  */
+  YYSYMBOL_NONUNIFORM = 436,               /* NONUNIFORM  */
+  YYSYMBOL_COHERENT = 437,                 /* COHERENT  */
+  YYSYMBOL_VOLATILE = 438,                 /* VOLATILE  */
+  YYSYMBOL_RESTRICT = 439,                 /* RESTRICT  */
+  YYSYMBOL_READONLY = 440,                 /* READONLY  */
+  YYSYMBOL_WRITEONLY = 441,                /* WRITEONLY  */
+  YYSYMBOL_DEVICECOHERENT = 442,           /* DEVICECOHERENT  */
+  YYSYMBOL_QUEUEFAMILYCOHERENT = 443,      /* QUEUEFAMILYCOHERENT  */
+  YYSYMBOL_WORKGROUPCOHERENT = 444,        /* WORKGROUPCOHERENT  */
+  YYSYMBOL_SUBGROUPCOHERENT = 445,         /* SUBGROUPCOHERENT  */
+  YYSYMBOL_NONPRIVATE = 446,               /* NONPRIVATE  */
+  YYSYMBOL_SHADERCALLCOHERENT = 447,       /* SHADERCALLCOHERENT  */
+  YYSYMBOL_NOPERSPECTIVE = 448,            /* NOPERSPECTIVE  */
+  YYSYMBOL_EXPLICITINTERPAMD = 449,        /* EXPLICITINTERPAMD  */
+  YYSYMBOL_PERVERTEXNV = 450,              /* PERVERTEXNV  */
+  YYSYMBOL_PERPRIMITIVENV = 451,           /* PERPRIMITIVENV  */
+  YYSYMBOL_PERVIEWNV = 452,                /* PERVIEWNV  */
+  YYSYMBOL_PERTASKNV = 453,                /* PERTASKNV  */
+  YYSYMBOL_PRECISE = 454,                  /* PRECISE  */
+  YYSYMBOL_YYACCEPT = 455,                 /* $accept  */
+  YYSYMBOL_variable_identifier = 456,      /* variable_identifier  */
+  YYSYMBOL_primary_expression = 457,       /* primary_expression  */
+  YYSYMBOL_postfix_expression = 458,       /* postfix_expression  */
+  YYSYMBOL_integer_expression = 459,       /* integer_expression  */
+  YYSYMBOL_function_call = 460,            /* function_call  */
+  YYSYMBOL_function_call_or_method = 461,  /* function_call_or_method  */
+  YYSYMBOL_function_call_generic = 462,    /* function_call_generic  */
+  YYSYMBOL_function_call_header_no_parameters = 463, /* function_call_header_no_parameters  */
+  YYSYMBOL_function_call_header_with_parameters = 464, /* function_call_header_with_parameters  */
+  YYSYMBOL_function_call_header = 465,     /* function_call_header  */
+  YYSYMBOL_function_identifier = 466,      /* function_identifier  */
+  YYSYMBOL_unary_expression = 467,         /* unary_expression  */
+  YYSYMBOL_unary_operator = 468,           /* unary_operator  */
+  YYSYMBOL_multiplicative_expression = 469, /* multiplicative_expression  */
+  YYSYMBOL_additive_expression = 470,      /* additive_expression  */
+  YYSYMBOL_shift_expression = 471,         /* shift_expression  */
+  YYSYMBOL_relational_expression = 472,    /* relational_expression  */
+  YYSYMBOL_equality_expression = 473,      /* equality_expression  */
+  YYSYMBOL_and_expression = 474,           /* and_expression  */
+  YYSYMBOL_exclusive_or_expression = 475,  /* exclusive_or_expression  */
+  YYSYMBOL_inclusive_or_expression = 476,  /* inclusive_or_expression  */
+  YYSYMBOL_logical_and_expression = 477,   /* logical_and_expression  */
+  YYSYMBOL_logical_xor_expression = 478,   /* logical_xor_expression  */
+  YYSYMBOL_logical_or_expression = 479,    /* logical_or_expression  */
+  YYSYMBOL_conditional_expression = 480,   /* conditional_expression  */
+  YYSYMBOL_481_1 = 481,                    /* $@1  */
+  YYSYMBOL_assignment_expression = 482,    /* assignment_expression  */
+  YYSYMBOL_assignment_operator = 483,      /* assignment_operator  */
+  YYSYMBOL_expression = 484,               /* expression  */
+  YYSYMBOL_constant_expression = 485,      /* constant_expression  */
+  YYSYMBOL_declaration = 486,              /* declaration  */
+  YYSYMBOL_block_structure = 487,          /* block_structure  */
+  YYSYMBOL_488_2 = 488,                    /* $@2  */
+  YYSYMBOL_identifier_list = 489,          /* identifier_list  */
+  YYSYMBOL_function_prototype = 490,       /* function_prototype  */
+  YYSYMBOL_function_declarator = 491,      /* function_declarator  */
+  YYSYMBOL_function_header_with_parameters = 492, /* function_header_with_parameters  */
+  YYSYMBOL_function_header = 493,          /* function_header  */
+  YYSYMBOL_parameter_declarator = 494,     /* parameter_declarator  */
+  YYSYMBOL_parameter_declaration = 495,    /* parameter_declaration  */
+  YYSYMBOL_parameter_type_specifier = 496, /* parameter_type_specifier  */
+  YYSYMBOL_init_declarator_list = 497,     /* init_declarator_list  */
+  YYSYMBOL_single_declaration = 498,       /* single_declaration  */
+  YYSYMBOL_fully_specified_type = 499,     /* fully_specified_type  */
+  YYSYMBOL_invariant_qualifier = 500,      /* invariant_qualifier  */
+  YYSYMBOL_interpolation_qualifier = 501,  /* interpolation_qualifier  */
+  YYSYMBOL_layout_qualifier = 502,         /* layout_qualifier  */
+  YYSYMBOL_layout_qualifier_id_list = 503, /* layout_qualifier_id_list  */
+  YYSYMBOL_layout_qualifier_id = 504,      /* layout_qualifier_id  */
+  YYSYMBOL_precise_qualifier = 505,        /* precise_qualifier  */
+  YYSYMBOL_type_qualifier = 506,           /* type_qualifier  */
+  YYSYMBOL_single_type_qualifier = 507,    /* single_type_qualifier  */
+  YYSYMBOL_storage_qualifier = 508,        /* storage_qualifier  */
+  YYSYMBOL_non_uniform_qualifier = 509,    /* non_uniform_qualifier  */
+  YYSYMBOL_type_name_list = 510,           /* type_name_list  */
+  YYSYMBOL_type_specifier = 511,           /* type_specifier  */
+  YYSYMBOL_array_specifier = 512,          /* array_specifier  */
+  YYSYMBOL_type_parameter_specifier_opt = 513, /* type_parameter_specifier_opt  */
+  YYSYMBOL_type_parameter_specifier = 514, /* type_parameter_specifier  */
+  YYSYMBOL_type_parameter_specifier_list = 515, /* type_parameter_specifier_list  */
+  YYSYMBOL_type_specifier_nonarray = 516,  /* type_specifier_nonarray  */
+  YYSYMBOL_precision_qualifier = 517,      /* precision_qualifier  */
+  YYSYMBOL_struct_specifier = 518,         /* struct_specifier  */
+  YYSYMBOL_519_3 = 519,                    /* $@3  */
+  YYSYMBOL_520_4 = 520,                    /* $@4  */
+  YYSYMBOL_struct_declaration_list = 521,  /* struct_declaration_list  */
+  YYSYMBOL_struct_declaration = 522,       /* struct_declaration  */
+  YYSYMBOL_struct_declarator_list = 523,   /* struct_declarator_list  */
+  YYSYMBOL_struct_declarator = 524,        /* struct_declarator  */
+  YYSYMBOL_initializer = 525,              /* initializer  */
+  YYSYMBOL_initializer_list = 526,         /* initializer_list  */
+  YYSYMBOL_declaration_statement = 527,    /* declaration_statement  */
+  YYSYMBOL_statement = 528,                /* statement  */
+  YYSYMBOL_simple_statement = 529,         /* simple_statement  */
+  YYSYMBOL_demote_statement = 530,         /* demote_statement  */
+  YYSYMBOL_compound_statement = 531,       /* compound_statement  */
+  YYSYMBOL_532_5 = 532,                    /* $@5  */
+  YYSYMBOL_533_6 = 533,                    /* $@6  */
+  YYSYMBOL_statement_no_new_scope = 534,   /* statement_no_new_scope  */
+  YYSYMBOL_statement_scoped = 535,         /* statement_scoped  */
+  YYSYMBOL_536_7 = 536,                    /* $@7  */
+  YYSYMBOL_537_8 = 537,                    /* $@8  */
+  YYSYMBOL_compound_statement_no_new_scope = 538, /* compound_statement_no_new_scope  */
+  YYSYMBOL_statement_list = 539,           /* statement_list  */
+  YYSYMBOL_expression_statement = 540,     /* expression_statement  */
+  YYSYMBOL_selection_statement = 541,      /* selection_statement  */
+  YYSYMBOL_selection_statement_nonattributed = 542, /* selection_statement_nonattributed  */
+  YYSYMBOL_selection_rest_statement = 543, /* selection_rest_statement  */
+  YYSYMBOL_condition = 544,                /* condition  */
+  YYSYMBOL_switch_statement = 545,         /* switch_statement  */
+  YYSYMBOL_switch_statement_nonattributed = 546, /* switch_statement_nonattributed  */
+  YYSYMBOL_547_9 = 547,                    /* $@9  */
+  YYSYMBOL_switch_statement_list = 548,    /* switch_statement_list  */
+  YYSYMBOL_case_label = 549,               /* case_label  */
+  YYSYMBOL_iteration_statement = 550,      /* iteration_statement  */
+  YYSYMBOL_iteration_statement_nonattributed = 551, /* iteration_statement_nonattributed  */
+  YYSYMBOL_552_10 = 552,                   /* $@10  */
+  YYSYMBOL_553_11 = 553,                   /* $@11  */
+  YYSYMBOL_554_12 = 554,                   /* $@12  */
+  YYSYMBOL_for_init_statement = 555,       /* for_init_statement  */
+  YYSYMBOL_conditionopt = 556,             /* conditionopt  */
+  YYSYMBOL_for_rest_statement = 557,       /* for_rest_statement  */
+  YYSYMBOL_jump_statement = 558,           /* jump_statement  */
+  YYSYMBOL_translation_unit = 559,         /* translation_unit  */
+  YYSYMBOL_external_declaration = 560,     /* external_declaration  */
+  YYSYMBOL_function_definition = 561,      /* function_definition  */
+  YYSYMBOL_562_13 = 562,                   /* $@13  */
+  YYSYMBOL_attribute = 563,                /* attribute  */
+  YYSYMBOL_attribute_list = 564,           /* attribute_list  */
+  YYSYMBOL_single_attribute = 565,         /* single_attribute  */
+  YYSYMBOL_spirv_requirements_list = 566,  /* spirv_requirements_list  */
+  YYSYMBOL_spirv_requirements_parameter = 567, /* spirv_requirements_parameter  */
+  YYSYMBOL_spirv_extension_list = 568,     /* spirv_extension_list  */
+  YYSYMBOL_spirv_capability_list = 569,    /* spirv_capability_list  */
+  YYSYMBOL_spirv_execution_mode_qualifier = 570, /* spirv_execution_mode_qualifier  */
+  YYSYMBOL_spirv_execution_mode_parameter_list = 571, /* spirv_execution_mode_parameter_list  */
+  YYSYMBOL_spirv_execution_mode_parameter = 572, /* spirv_execution_mode_parameter  */
+  YYSYMBOL_spirv_execution_mode_id_parameter_list = 573, /* spirv_execution_mode_id_parameter_list  */
+  YYSYMBOL_spirv_storage_class_qualifier = 574, /* spirv_storage_class_qualifier  */
+  YYSYMBOL_spirv_decorate_qualifier = 575, /* spirv_decorate_qualifier  */
+  YYSYMBOL_spirv_decorate_parameter_list = 576, /* spirv_decorate_parameter_list  */
+  YYSYMBOL_spirv_decorate_parameter = 577, /* spirv_decorate_parameter  */
+  YYSYMBOL_spirv_decorate_id_parameter_list = 578, /* spirv_decorate_id_parameter_list  */
+  YYSYMBOL_spirv_decorate_string_parameter_list = 579, /* spirv_decorate_string_parameter_list  */
+  YYSYMBOL_spirv_type_specifier = 580,     /* spirv_type_specifier  */
+  YYSYMBOL_spirv_type_parameter_list = 581, /* spirv_type_parameter_list  */
+  YYSYMBOL_spirv_type_parameter = 582,     /* spirv_type_parameter  */
+  YYSYMBOL_spirv_instruction_qualifier = 583, /* spirv_instruction_qualifier  */
+  YYSYMBOL_spirv_instruction_qualifier_list = 584, /* spirv_instruction_qualifier_list  */
+  YYSYMBOL_spirv_instruction_qualifier_id = 585 /* spirv_instruction_qualifier_id  */
 };
 typedef enum yysymbol_kind_t yysymbol_kind_t;
 
 
 /* Second part of user prologue.  */
-#line 133 "MachineIndependent/glslang.y"
+#line 136 "MachineIndependent/glslang.y"
 
 
 /* windows only pragma */
@@ -698,7 +728,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t;
 extern int yylex(YYSTYPE*, TParseContext&);
 
 
-#line 702 "MachineIndependent/glslang_tab.cpp"
+#line 732 "MachineIndependent/glslang_tab.cpp"
 
 
 #ifdef short
@@ -738,18 +768,6 @@ typedef int_least16_t yytype_int16;
 typedef short yytype_int16;
 #endif
 
-/* Work around bug in HP-UX 11.23, which defines these macros
-   incorrectly for preprocessor constants.  This workaround can likely
-   be removed in 2023, as HPE has promised support for HP-UX 11.23
-   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
-   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
-#ifdef __hpux
-# undef UINT_LEAST8_MAX
-# undef UINT_LEAST16_MAX
-# define UINT_LEAST8_MAX 255
-# define UINT_LEAST16_MAX 65535
-#endif
-
 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
@@ -847,9 +865,9 @@ typedef int yy_state_fast_t;
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YY_USE(E) ((void) (E))
+# define YYUSE(E) ((void) (E))
 #else
-# define YY_USE(E) /* empty */
+# define YYUSE(E) /* empty */
 #endif
 
 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
@@ -1014,21 +1032,21 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  419
+#define YYFINAL  442
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   10891
+#define YYLAST   12453
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  445
+#define YYNTOKENS  455
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  111
+#define YYNNTS  131
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  620
+#define YYNRULES  684
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  772
+#define YYNSTATES  930
 
 /* YYMAXUTOK -- Last valid token kind.  */
-#define YYMAXUTOK   699
+#define YYMAXUTOK   709
 
 
 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
@@ -1111,76 +1129,83 @@ static const yytype_int16 yytranslate[] =
      405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
      415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
      425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444
+     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
+     445,   446,   447,   448,   449,   450,   451,   452,   453,   454
 };
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
-       0,   371,   371,   377,   380,   385,   388,   391,   395,   399,
-     402,   406,   410,   414,   418,   422,   426,   432,   440,   443,
-     446,   449,   452,   457,   465,   472,   479,   485,   489,   496,
-     499,   505,   512,   522,   530,   535,   563,   572,   578,   582,
-     586,   606,   607,   608,   609,   615,   616,   621,   626,   635,
-     636,   641,   649,   650,   656,   665,   666,   671,   676,   681,
-     689,   690,   699,   711,   712,   721,   722,   731,   732,   741,
-     742,   750,   751,   759,   760,   768,   769,   769,   787,   788,
-     804,   808,   812,   816,   821,   825,   829,   833,   837,   841,
-     845,   852,   855,   866,   873,   878,   883,   890,   894,   898,
-     902,   907,   912,   921,   921,   932,   936,   943,   947,   953,
-     959,   969,   972,   979,   987,  1007,  1030,  1045,  1070,  1081,
-    1091,  1101,  1111,  1120,  1123,  1127,  1131,  1136,  1144,  1151,
-    1156,  1161,  1166,  1175,  1185,  1212,  1221,  1228,  1236,  1243,
-    1250,  1258,  1268,  1275,  1286,  1292,  1295,  1302,  1306,  1310,
-    1319,  1329,  1332,  1343,  1346,  1349,  1353,  1357,  1362,  1366,
-    1373,  1377,  1382,  1388,  1394,  1401,  1406,  1414,  1420,  1432,
-    1446,  1452,  1457,  1465,  1473,  1481,  1489,  1497,  1505,  1513,
-    1521,  1528,  1535,  1539,  1544,  1549,  1554,  1559,  1564,  1569,
-    1573,  1577,  1581,  1585,  1591,  1602,  1609,  1612,  1621,  1626,
-    1636,  1641,  1649,  1653,  1663,  1666,  1672,  1678,  1685,  1695,
-    1699,  1703,  1707,  1712,  1716,  1721,  1726,  1731,  1736,  1741,
-    1746,  1751,  1756,  1761,  1767,  1773,  1779,  1784,  1789,  1794,
-    1799,  1804,  1809,  1814,  1819,  1824,  1829,  1834,  1840,  1847,
-    1852,  1857,  1862,  1867,  1872,  1877,  1882,  1887,  1892,  1897,
-    1902,  1910,  1918,  1926,  1932,  1938,  1944,  1950,  1956,  1962,
-    1968,  1974,  1980,  1986,  1992,  1998,  2004,  2010,  2016,  2022,
-    2028,  2034,  2040,  2046,  2052,  2058,  2064,  2070,  2076,  2082,
-    2088,  2094,  2100,  2106,  2112,  2118,  2124,  2132,  2140,  2148,
-    2156,  2164,  2172,  2180,  2188,  2196,  2204,  2212,  2220,  2226,
-    2232,  2238,  2244,  2250,  2256,  2262,  2268,  2274,  2280,  2286,
-    2292,  2298,  2304,  2310,  2316,  2322,  2328,  2334,  2340,  2346,
-    2352,  2358,  2364,  2370,  2376,  2382,  2388,  2394,  2400,  2406,
-    2412,  2418,  2424,  2430,  2436,  2440,  2444,  2448,  2453,  2459,
-    2464,  2469,  2474,  2479,  2484,  2489,  2495,  2500,  2505,  2510,
-    2515,  2520,  2526,  2532,  2538,  2544,  2550,  2556,  2562,  2568,
-    2574,  2580,  2586,  2592,  2598,  2604,  2609,  2614,  2619,  2624,
-    2629,  2634,  2640,  2645,  2650,  2655,  2660,  2665,  2670,  2675,
-    2681,  2686,  2691,  2696,  2701,  2706,  2711,  2716,  2721,  2726,
-    2731,  2736,  2741,  2746,  2751,  2757,  2762,  2767,  2773,  2779,
-    2784,  2789,  2794,  2800,  2805,  2810,  2815,  2821,  2826,  2831,
-    2836,  2842,  2847,  2852,  2857,  2863,  2869,  2875,  2881,  2886,
-    2892,  2898,  2904,  2909,  2914,  2919,  2924,  2929,  2935,  2940,
-    2945,  2950,  2956,  2961,  2966,  2971,  2977,  2982,  2987,  2992,
-    2998,  3003,  3008,  3013,  3019,  3024,  3029,  3034,  3040,  3045,
-    3050,  3055,  3061,  3066,  3071,  3076,  3082,  3087,  3092,  3097,
-    3103,  3108,  3113,  3118,  3124,  3129,  3134,  3139,  3145,  3150,
-    3155,  3160,  3166,  3171,  3176,  3181,  3187,  3192,  3197,  3202,
-    3208,  3213,  3218,  3223,  3229,  3234,  3239,  3244,  3249,  3254,
-    3259,  3264,  3269,  3274,  3279,  3284,  3289,  3294,  3299,  3304,
-    3309,  3314,  3319,  3324,  3329,  3334,  3339,  3344,  3349,  3355,
-    3361,  3367,  3373,  3380,  3387,  3393,  3399,  3405,  3411,  3417,
-    3423,  3430,  3435,  3451,  3456,  3461,  3469,  3469,  3480,  3480,
-    3490,  3493,  3506,  3528,  3555,  3559,  3565,  3570,  3581,  3585,
-    3591,  3597,  3608,  3611,  3618,  3622,  3623,  3629,  3630,  3631,
-    3632,  3633,  3634,  3635,  3637,  3643,  3652,  3653,  3657,  3653,
-    3669,  3670,  3674,  3674,  3681,  3681,  3695,  3698,  3706,  3714,
-    3725,  3726,  3730,  3734,  3742,  3749,  3753,  3761,  3765,  3778,
-    3782,  3790,  3790,  3810,  3813,  3819,  3831,  3843,  3847,  3855,
-    3855,  3870,  3870,  3886,  3886,  3907,  3910,  3916,  3919,  3925,
-    3929,  3936,  3941,  3946,  3953,  3956,  3960,  3965,  3969,  3979,
-    3983,  3992,  3995,  3999,  4008,  4008,  4050,  4055,  4058,  4063,
-    4066
+       0,   392,   392,   398,   401,   406,   409,   412,   416,   420,
+     423,   427,   431,   435,   439,   443,   447,   453,   461,   464,
+     467,   470,   473,   478,   486,   493,   500,   506,   510,   517,
+     520,   526,   533,   543,   551,   556,   584,   593,   599,   603,
+     607,   627,   628,   629,   630,   636,   637,   642,   647,   656,
+     657,   662,   670,   671,   677,   686,   687,   692,   697,   702,
+     710,   711,   720,   732,   733,   742,   743,   752,   753,   762,
+     763,   771,   772,   780,   781,   789,   790,   790,   808,   809,
+     825,   829,   833,   837,   842,   846,   850,   854,   858,   862,
+     866,   873,   876,   887,   894,   900,   907,   913,   918,   925,
+     929,   933,   937,   942,   947,   956,   956,   967,   971,   978,
+     982,   988,   994,  1004,  1007,  1014,  1022,  1042,  1065,  1080,
+    1105,  1116,  1126,  1136,  1146,  1155,  1158,  1162,  1166,  1171,
+    1179,  1186,  1191,  1196,  1201,  1210,  1220,  1247,  1256,  1263,
+    1271,  1278,  1285,  1293,  1303,  1310,  1321,  1327,  1330,  1337,
+    1341,  1345,  1354,  1364,  1367,  1378,  1381,  1384,  1388,  1392,
+    1397,  1401,  1404,  1409,  1413,  1418,  1427,  1431,  1436,  1442,
+    1448,  1455,  1460,  1468,  1474,  1486,  1500,  1506,  1511,  1519,
+    1527,  1535,  1543,  1551,  1559,  1567,  1575,  1582,  1589,  1593,
+    1598,  1603,  1608,  1613,  1618,  1623,  1627,  1631,  1635,  1639,
+    1645,  1656,  1663,  1666,  1675,  1680,  1690,  1695,  1703,  1707,
+    1717,  1720,  1726,  1732,  1739,  1749,  1753,  1757,  1761,  1766,
+    1770,  1775,  1780,  1785,  1790,  1795,  1800,  1805,  1810,  1815,
+    1821,  1827,  1833,  1838,  1843,  1848,  1853,  1858,  1863,  1868,
+    1873,  1878,  1883,  1888,  1894,  1901,  1906,  1911,  1916,  1921,
+    1926,  1931,  1936,  1941,  1946,  1951,  1956,  1964,  1972,  1980,
+    1986,  1992,  1998,  2004,  2010,  2016,  2022,  2028,  2034,  2040,
+    2046,  2052,  2058,  2064,  2070,  2076,  2082,  2088,  2094,  2100,
+    2106,  2112,  2118,  2124,  2130,  2136,  2142,  2148,  2154,  2160,
+    2166,  2172,  2178,  2186,  2194,  2202,  2210,  2218,  2226,  2234,
+    2242,  2250,  2258,  2266,  2274,  2280,  2286,  2292,  2298,  2304,
+    2310,  2316,  2322,  2328,  2334,  2340,  2346,  2352,  2358,  2364,
+    2370,  2376,  2382,  2388,  2394,  2400,  2406,  2412,  2418,  2424,
+    2430,  2436,  2442,  2448,  2454,  2460,  2466,  2472,  2478,  2484,
+    2490,  2494,  2498,  2502,  2507,  2513,  2518,  2523,  2528,  2533,
+    2538,  2543,  2549,  2554,  2559,  2564,  2569,  2574,  2580,  2586,
+    2592,  2598,  2604,  2610,  2616,  2622,  2628,  2634,  2640,  2646,
+    2652,  2658,  2663,  2668,  2673,  2678,  2683,  2688,  2694,  2699,
+    2704,  2709,  2714,  2719,  2724,  2729,  2735,  2740,  2745,  2750,
+    2755,  2760,  2765,  2770,  2775,  2780,  2785,  2790,  2795,  2800,
+    2805,  2811,  2816,  2821,  2827,  2833,  2838,  2843,  2848,  2854,
+    2859,  2864,  2869,  2875,  2880,  2885,  2890,  2896,  2901,  2906,
+    2911,  2917,  2923,  2929,  2935,  2940,  2946,  2952,  2958,  2963,
+    2968,  2973,  2978,  2983,  2989,  2994,  2999,  3004,  3010,  3015,
+    3020,  3025,  3031,  3036,  3041,  3046,  3052,  3057,  3062,  3067,
+    3073,  3078,  3083,  3088,  3094,  3099,  3104,  3109,  3115,  3120,
+    3125,  3130,  3136,  3141,  3146,  3151,  3157,  3162,  3167,  3172,
+    3178,  3183,  3188,  3193,  3199,  3204,  3209,  3214,  3220,  3225,
+    3230,  3235,  3241,  3246,  3251,  3256,  3262,  3267,  3272,  3277,
+    3283,  3288,  3293,  3298,  3303,  3308,  3313,  3318,  3323,  3328,
+    3333,  3338,  3343,  3348,  3353,  3358,  3363,  3368,  3373,  3378,
+    3383,  3388,  3393,  3398,  3403,  3409,  3415,  3421,  3427,  3434,
+    3441,  3447,  3453,  3459,  3465,  3471,  3477,  3483,  3488,  3493,
+    3509,  3514,  3519,  3527,  3527,  3538,  3538,  3548,  3551,  3564,
+    3586,  3613,  3617,  3623,  3628,  3639,  3643,  3649,  3655,  3666,
+    3669,  3676,  3680,  3681,  3687,  3688,  3689,  3690,  3691,  3692,
+    3693,  3695,  3701,  3710,  3711,  3715,  3711,  3727,  3728,  3732,
+    3732,  3739,  3739,  3753,  3756,  3764,  3772,  3783,  3784,  3788,
+    3792,  3800,  3807,  3811,  3819,  3823,  3836,  3840,  3848,  3848,
+    3868,  3871,  3877,  3889,  3901,  3905,  3913,  3913,  3928,  3928,
+    3944,  3944,  3965,  3968,  3974,  3977,  3983,  3987,  3994,  3999,
+    4004,  4011,  4014,  4018,  4023,  4027,  4037,  4041,  4050,  4053,
+    4057,  4066,  4066,  4108,  4113,  4116,  4121,  4124,  4131,  4134,
+    4139,  4142,  4147,  4150,  4155,  4158,  4163,  4167,  4172,  4176,
+    4181,  4185,  4192,  4195,  4200,  4203,  4206,  4209,  4212,  4217,
+    4226,  4237,  4242,  4250,  4254,  4259,  4263,  4268,  4272,  4277,
+    4281,  4288,  4291,  4296,  4299,  4302,  4305,  4310,  4318,  4328,
+    4332,  4337,  4341,  4346,  4350,  4357,  4360,  4365,  4368,  4373,
+    4376,  4382,  4385,  4390,  4393
 };
 #endif
 
@@ -1267,17 +1292,20 @@ static const char *const yytname[] =
   "F16TEXTURECUBEARRAY", "F16TEXTUREBUFFER", "F16TEXTURE2DMS",
   "F16TEXTURE2DMSARRAY", "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT",
   "ISUBPASSINPUTMS", "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT",
-  "F16SUBPASSINPUTMS", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP",
-  "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN",
-  "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
-  "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "STRING_LITERAL",
-  "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET",
-  "LEFT_BRACE", "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL",
-  "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT",
-  "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND",
-  "QUESTION", "INVARIANT", "HIGH_PRECISION", "MEDIUM_PRECISION",
-  "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP",
-  "FLOATCONSTANT", "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT",
+  "F16SUBPASSINPUTMS", "SPIRV_INSTRUCTION", "SPIRV_EXECUTION_MODE",
+  "SPIRV_EXECUTION_MODE_ID", "SPIRV_DECORATE", "SPIRV_DECORATE_ID",
+  "SPIRV_DECORATE_STRING", "SPIRV_TYPE", "SPIRV_STORAGE_CLASS",
+  "SPIRV_BY_REFERENCE", "SPIRV_LITERAL", "LEFT_OP", "RIGHT_OP", "INC_OP",
+  "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP",
+  "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN",
+  "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN",
+  "SUB_ASSIGN", "STRING_LITERAL", "LEFT_PAREN", "RIGHT_PAREN",
+  "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "DOT",
+  "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS",
+  "STAR", "SLASH", "PERCENT", "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR",
+  "CARET", "AMPERSAND", "QUESTION", "INVARIANT", "HIGH_PRECISION",
+  "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE",
+  "SUPERP", "FLOATCONSTANT", "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT",
   "IDENTIFIER", "TYPE_NAME", "CENTROID", "IN", "OUT", "INOUT", "STRUCT",
   "VOID", "WHILE", "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF",
   "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", "TERMINATE_INVOCATION",
@@ -1330,7 +1358,18 @@ static const char *const yytname[] =
   "for_init_statement", "conditionopt", "for_rest_statement",
   "jump_statement", "translation_unit", "external_declaration",
   "function_definition", "$@13", "attribute", "attribute_list",
-  "single_attribute", YY_NULLPTR
+  "single_attribute", "spirv_requirements_list",
+  "spirv_requirements_parameter", "spirv_extension_list",
+  "spirv_capability_list", "spirv_execution_mode_qualifier",
+  "spirv_execution_mode_parameter_list", "spirv_execution_mode_parameter",
+  "spirv_execution_mode_id_parameter_list",
+  "spirv_storage_class_qualifier", "spirv_decorate_qualifier",
+  "spirv_decorate_parameter_list", "spirv_decorate_parameter",
+  "spirv_decorate_id_parameter_list",
+  "spirv_decorate_string_parameter_list", "spirv_type_specifier",
+  "spirv_type_parameter_list", "spirv_type_parameter",
+  "spirv_instruction_qualifier", "spirv_instruction_qualifier_list",
+  "spirv_instruction_qualifier_id", YY_NULLPTR
 };
 
 static const char *
@@ -1389,16 +1428,17 @@ static const yytype_int16 yytoknum[] =
      665,   666,   667,   668,   669,   670,   671,   672,   673,   674,
      675,   676,   677,   678,   679,   680,   681,   682,   683,   684,
      685,   686,   687,   688,   689,   690,   691,   692,   693,   694,
-     695,   696,   697,   698,   699
+     695,   696,   697,   698,   699,   700,   701,   702,   703,   704,
+     705,   706,   707,   708,   709
 };
 #endif
 
-#define YYPACT_NINF (-741)
+#define YYPACT_NINF (-863)
 
 #define yypact_value_is_default(Yyn) \
   ((Yyn) == YYPACT_NINF)
 
-#define YYTABLE_NINF (-563)
+#define YYTABLE_NINF (-570)
 
 #define yytable_value_is_error(Yyn) \
   0
@@ -1407,84 +1447,99 @@ static const yytype_int16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    4753,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -328,  -741,  -741,  -741,  -741,
-    -741,   102,  -741,  -741,  -741,  -741,  -741,     7,  -741,  -741,
-    -741,  -741,  -741,  -741,  -322,  -257,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,    10,     8,
-      47,    64,  6963,    87,  -741,    46,  -741,  -741,  -741,  -741,
-    5195,  -741,  -741,  -741,  -741,    77,  -741,  -741,   775,  -741,
-    -741,  6963,    63,    20,  -741,   104,   -24,   106,  -741,  -330,
-    -741,   121,   142,  6963,  -741,  -741,  -741,  6963,   112,   115,
-    -741,  -334,  -741,    22,  -741,  -741,  9942,   151,  -741,  -741,
-    -741,   154,   125,  6963,   163,    24,  -741,   155,  6963,  -741,
-     157,  -741,    18,  -741,  -741,    38,  8250,  -741,  -329,  1217,
-    -741,  -741,  -741,  -741,  -741,   151,  -325,  -741,  8673,    12,
-    -741,   128,  -741,    94,  9942,  9942,  -741,  9942,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,    86,  -741,  -741,
-    -741,   167,    68, 10365,   170,  -741,  9942,  -741,  -741,  -343,
-     172,   142,   176,  9942,   169,    63,  -741,  6963,   143,  5637,
-    -741,  6963,  9942,  -741,   -24,  -741,   144,  -741,  -741,   116,
-      16,  -296,    41,   150,   156,   160,   164,   197,   199,    21,
-     182,  9096,  -741,   183,  -741,  -741,   189,   193,   194,  -741,
-     192,   205,   196,  9519,   207,  9942,   201,   208,   210,   211,
-     212,   204,  -741,  -741,    96,  -741,     8,   214,   217,  -741,
-    -741,  -741,  -741,  -741,  1659,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  4311,   172,  8673,    13,  7404,  -741,
-    -741,  8673,  6963,  -741,   187,  -741,  -741,  -741,    69,  -741,
-    -741,  9942,   190,  -741,  -741,  9942,   226,  -741,  -741,  -741,
-    9942,  -741,  -741,  -741,   227,  -741,  -741,   143,   151,   108,
-    -741,  -741,  -741,  6079,  -741,  -741,  -741,  9942,  9942,  9942,
-    9942,  9942,  9942,  9942,  9942,  9942,  9942,  9942,  9942,  9942,
-    9942,  9942,  9942,  9942,  9942,  9942,  -741,  -741,  -741,   228,
-    -741,  2101,  -741,  -741,  -741,  2101,  -741,  9942,  -741,  -741,
-     113,  9942,   131,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  9942,
-    9942,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  8673,  -741,
-    -741,   109,  -741,  6521,  -741,  -741,   229,   222,  -741,  -741,
-    -741,  -741,   114,   172,   143,  -741,  -741,  -741,  -741,  -741,
-     116,   116,    16,    16,  -296,  -296,  -296,  -296,    41,    41,
-     150,   156,   160,   164,   197,   199,  9942,  -741,  2101,  3869,
-     186,  3427,    80,  -741,    84,  -741,  -741,  -741,  -741,  -741,
-    7827,  -741,  -741,  -741,  -741,   133,   230,   222,   200,   236,
-     238,  -741,  -741,  3869,   235,  -741,  -741,  -741,  9942,  -741,
-     231,  2543,  9942,  -741,   233,   240,   198,   241,  2985,  -741,
-     244,  -741,  8673,  -741,  -741,  -741,    89,  9942,  2543,   235,
-    -741,  -741,  2101,  -741,   234,   222,  -741,  -741,  2101,   245,
-    -741,  -741
+    4549,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -260,  -182,  -177,  -163,  -130,
+    -115,  -100,   -89,  -863,  -863,  -196,  -863,  -863,  -863,  -863,
+    -863,  -324,  -863,  -863,  -863,  -863,  -863,  -306,  -863,  -863,
+    -863,  -863,  -863,  -863,   -77,   -66,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -332,  -175,
+    -153,  -161,  7713,  -266,  -863,   -71,  -863,  -863,  -863,  -863,
+    5453,  -863,  -863,  -863,  -863,  -116,  -863,  -863,   933,  -863,
+    -863,  7713,   -35,  -863,  -863,  -863,  5905,   -54,  -139,  -138,
+    -137,  -128,  -124,   -54,  -123,   -51, 12061,  -863,   -15,  -347,
+     -44,  -863,  -295,  -863,    -9,    -6,  7713,  -863,  -863,  -863,
+    7713,   -39,   -38,  -863,  -303,  -863,  -226,  -863,  -863, 10762,
+      -3,  -863,  -863,  -863,     1,   -32,  7713,  -863,    -5,    -8,
+      -1,  -863,  -230,  -863,  -219,    -2,     3,     4,     5,  -215,
+       6,     8,    10,    11,    12,    15,  -214,    13,    16,    21,
+    -134,  -863,    17,  7713,  -863,    19,  -863,  -212,  -863,  -863,
+    -211,  9030,  -863,  -273,  1385,  -863,  -863,  -863,  -863,  -863,
+      -3,  -263,  -863,  9463,  -236,  -863,   -28,  -863,  -106, 10762,
+   10762,  -863, 10762,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -264,  -863,  -863,  -863,    23,  -203, 11195,    25,
+    -863, 10762,  -863,  -863,  -311,    24,    -6,    29,  -863,  -309,
+     -54,  -863,   -20,  -863,  -323,    28,  -118, 10762,  -112,  -863,
+    -155,  -111, 10762,  -103,    35,   -98,   -54,  -863, 11628,  -863,
+     -94, 10762,    32,   -51,  -863,  7713,    18,  6357,  -863,  7713,
+   10762,  -863,  -347,  -863,    33,  -863,  -863,   -72,  -254,   -86,
+    -297,   -68,   -13,    26,    20,    50,    49,  -300,    42,  9896,
+    -863,    43,  -863,  -863,    55,    58,    60,  -863,    65,    71,
+      62, 10329,    73, 10762,    66,    69,    70,    72,    74,  -241,
+    -863,  -863,   -41,  -863,  -175,    83,    85,  -863,  -863,  -863,
+    -863,  -863,  1837,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  5001,    24,  9463,  -233,  8164,  -863,  -863,  9463,
+    7713,  -863,    51,  -863,  -863,  -863,  -194,  -863,  -863, 10762,
+      52,  -863,  -863, 10762,    88,  -863,  -863,  -863, 10762,  -863,
+    -863,  -863,  -315,  -863,  -863,  -191,    82,  -863,  -863,  -863,
+    -863,  -863,  -863,  -190,  -863,  -187,  -863,  -863,  -186,    86,
+    -863,  -863,  -863,  -863,  -169,  -863,  -168,  -863,  -167,    89,
+    -863,  -165,    91,  -157,    82,  -863,    85,  -156,  -863,    94,
+      98,  -863,  -863,    18,    -3,   -40,  -863,  -863,  -863,  6809,
+    -863,  -863,  -863, 10762, 10762, 10762, 10762, 10762, 10762, 10762,
+   10762, 10762, 10762, 10762, 10762, 10762, 10762, 10762, 10762, 10762,
+   10762, 10762,  -863,  -863,  -863,    97,  -863,  2289,  -863,  -863,
+    -863,  2289,  -863, 10762,  -863,  -863,   -34, 10762,   -79,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863, 10762, 10762,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  9463,  -863,  -863,  -208,  -863,  7261,
+    -863,  -863,    99,    96,  -863,  -863,  -863,  -863,  -863,  -132,
+    -131,  -863,  -307,  -863,  -323,  -863,  -323,  -863, 10762, 10762,
+    -863,  -155,  -863,  -155,  -863, 10762, 10762,  -863,    93,    35,
+    -863, 11628,  -863, 10762,  -863,  -863,   -33,    24,    18,  -863,
+    -863,  -863,  -863,  -863,   -72,   -72,  -254,  -254,   -86,   -86,
+     -86,   -86,  -297,  -297,   -68,   -13,    26,    20,    50,    49,
+   10762,  -863,  2289,  4097,    57,  3645,  -154,  -863,  -152,  -863,
+    -863,  -863,  -863,  -863,  8597,  -863,  -863,  -863,   105,  -863,
+      75,  -863,  -145,  -863,  -144,  -863,  -143,  -863,  -142,  -863,
+    -141,  -140,  -863,  -863,  -863,   -27,   100,    96,    76,   106,
+     109,  -863,  -863,  4097,   107,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,  -863, 10762,  -863,   101,  2741,
+   10762,  -863,   103,   113,    67,   112,  3193,  -863,   114,  -863,
+    9463,  -863,  -863,  -863,  -133, 10762,  2741,   107,  -863,  -863,
+    2289,  -863,   110,    96,  -863,  -863,  2289,   116,  -863,  -863
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1492,118 +1547,137 @@ static const yytype_int16 yypact[] =
      means the default is an error.  */
 static const yytype_int16 yydefact[] =
 {
-       0,   160,   213,   211,   212,   210,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   214,   215,   216,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
-     339,   340,   341,   342,   343,   344,   345,   365,   366,   367,
-     368,   369,   370,   371,   380,   393,   394,   381,   382,   384,
-     383,   385,   386,   387,   388,   389,   390,   391,   392,   168,
-     169,   239,   240,   238,   241,   248,   249,   246,   247,   244,
-     245,   242,   243,   271,   272,   273,   283,   284,   285,   268,
-     269,   270,   280,   281,   282,   265,   266,   267,   277,   278,
-     279,   262,   263,   264,   274,   275,   276,   250,   251,   252,
-     286,   287,   288,   253,   254,   255,   298,   299,   300,   256,
-     257,   258,   310,   311,   312,   259,   260,   261,   322,   323,
-     324,   289,   290,   291,   292,   293,   294,   295,   296,   297,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   337,   334,   335,
-     336,   518,   519,   520,   349,   350,   373,   376,   338,   347,
-     348,   364,   346,   395,   396,   399,   400,   401,   403,   404,
-     405,   407,   408,   409,   411,   412,   508,   509,   372,   374,
-     375,   351,   352,   353,   397,   354,   358,   359,   362,   402,
-     406,   410,   355,   356,   360,   361,   398,   357,   363,   442,
-     444,   445,   446,   448,   449,   450,   452,   453,   454,   456,
-     457,   458,   460,   461,   462,   464,   465,   466,   468,   469,
-     470,   472,   473,   474,   476,   477,   478,   480,   481,   482,
-     484,   485,   443,   447,   451,   455,   459,   467,   471,   475,
-     463,   479,   483,   486,   487,   488,   489,   490,   491,   492,
-     493,   494,   495,   496,   497,   498,   499,   500,   501,   502,
-     503,   504,   505,   506,   507,   377,   378,   379,   413,   422,
-     424,   418,   423,   425,   426,   428,   429,   430,   432,   433,
-     434,   436,   437,   438,   440,   441,   414,   415,   416,   427,
-     417,   419,   420,   421,   431,   435,   439,   510,   511,   514,
-     515,   516,   517,   512,   513,     0,   613,   135,   523,   524,
-     525,     0,   522,   164,   162,   163,   161,     0,   209,   165,
-     166,   167,   137,   136,     0,   193,   174,   176,   172,   178,
-     180,   175,   177,   173,   179,   181,   170,   171,   195,   182,
-     189,   190,   191,   192,   183,   184,   185,   186,   187,   188,
-     138,   139,   140,   141,   142,   143,   150,   612,     0,   614,
-       0,   112,   111,     0,   123,   128,   157,   156,   154,   158,
-       0,   151,   153,   159,   133,   205,   155,   521,     0,   609,
-     611,     0,     0,     0,   528,     0,     0,     0,    97,     0,
-      94,     0,   107,     0,   119,   113,   121,     0,   122,     0,
-      95,   129,   100,     0,   152,   134,     0,   198,   204,     1,
-     610,     0,     0,     0,   619,     0,   617,     0,     0,   526,
-     147,   149,     0,   145,   196,     0,     0,    98,     0,     0,
-     615,   108,   114,   118,   120,   116,   124,   115,     0,   130,
-     103,     0,   101,     0,     0,     0,     9,     0,    43,    42,
-      44,    41,     5,     6,     7,     8,     2,    16,    14,    15,
-      17,    10,    11,    12,    13,     3,    18,    37,    20,    25,
-      26,     0,     0,    30,     0,   207,     0,    36,    34,     0,
-     199,   109,     0,     0,     0,     0,    96,     0,     0,     0,
-     530,     0,     0,   144,     0,   194,     0,   200,    45,    49,
-      52,    55,    60,    63,    65,    67,    69,    71,    73,    75,
-       0,     0,    99,   557,   566,   570,     0,     0,     0,   591,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    45,    78,    91,     0,   544,     0,   159,   133,   547,
-     568,   546,   554,   545,     0,   548,   549,   572,   550,   579,
-     551,   552,   587,   553,     0,   117,     0,   125,     0,   538,
-     132,     0,     0,   105,     0,   102,    38,    39,     0,    22,
-      23,     0,     0,    28,    27,     0,   209,    31,    33,    40,
-       0,   206,   110,    93,     0,   616,   618,     0,   536,     0,
-     534,   529,   531,     0,   148,   146,   197,     0,     0,     0,
+       0,   166,   219,   217,   218,   216,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   220,   221,   222,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     345,   346,   347,   348,   349,   350,   351,   371,   372,   373,
+     374,   375,   376,   377,   386,   399,   400,   387,   388,   390,
+     389,   391,   392,   393,   394,   395,   396,   397,   398,   174,
+     175,   245,   246,   244,   247,   254,   255,   252,   253,   250,
+     251,   248,   249,   277,   278,   279,   289,   290,   291,   274,
+     275,   276,   286,   287,   288,   271,   272,   273,   283,   284,
+     285,   268,   269,   270,   280,   281,   282,   256,   257,   258,
+     292,   293,   294,   259,   260,   261,   304,   305,   306,   262,
+     263,   264,   316,   317,   318,   265,   266,   267,   328,   329,
+     330,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   331,   332,
+     333,   334,   335,   336,   337,   338,   339,   343,   340,   341,
+     342,   524,   525,   526,   355,   356,   379,   382,   344,   353,
+     354,   370,   352,   401,   402,   405,   406,   407,   409,   410,
+     411,   413,   414,   415,   417,   418,   514,   515,   378,   380,
+     381,   357,   358,   359,   403,   360,   364,   365,   368,   408,
+     412,   416,   361,   362,   366,   367,   404,   363,   369,   448,
+     450,   451,   452,   454,   455,   456,   458,   459,   460,   462,
+     463,   464,   466,   467,   468,   470,   471,   472,   474,   475,
+     476,   478,   479,   480,   482,   483,   484,   486,   487,   488,
+     490,   491,   449,   453,   457,   461,   465,   473,   477,   481,
+     469,   485,   489,   492,   493,   494,   495,   496,   497,   498,
+     499,   500,   501,   502,   503,   504,   505,   506,   507,   508,
+     509,   510,   511,   512,   513,   383,   384,   385,   419,   428,
+     430,   424,   429,   431,   432,   434,   435,   436,   438,   439,
+     440,   442,   443,   444,   446,   447,   420,   421,   422,   433,
+     423,   425,   426,   427,   437,   441,   445,   516,   517,   520,
+     521,   522,   523,   518,   519,     0,     0,     0,     0,     0,
+       0,     0,     0,   164,   165,     0,   620,   137,   530,   531,
+     532,     0,   529,   170,   168,   169,   167,     0,   215,   171,
+     172,   173,   139,   138,     0,   199,   180,   182,   178,   184,
+     186,   181,   183,   179,   185,   187,   176,   177,   201,   188,
+     195,   196,   197,   198,   189,   190,   191,   192,   193,   194,
+     140,   141,   142,   143,   144,   145,   152,   619,     0,   621,
+       0,   114,   113,     0,   125,   130,   159,   158,   156,   160,
+       0,   153,   155,   161,   135,   211,   157,   528,     0,   616,
+     618,     0,     0,   162,   163,   527,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   535,     0,     0,
+       0,    99,     0,    94,     0,   109,     0,   121,   115,   123,
+       0,   124,     0,    97,   131,   102,     0,   154,   136,     0,
+     204,   210,     1,   617,     0,     0,     0,    96,     0,     0,
+       0,   628,     0,   681,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   626,
+       0,   624,     0,     0,   533,   149,   151,     0,   147,   202,
+       0,     0,   100,     0,     0,   622,   110,   116,   120,   122,
+     118,   126,   117,     0,   132,   105,     0,   103,     0,     0,
+       0,     9,     0,    43,    42,    44,    41,     5,     6,     7,
+       8,     2,    16,    14,    15,    17,    10,    11,    12,    13,
+       3,    18,    37,    20,    25,    26,     0,     0,    30,     0,
+     213,     0,    36,    34,     0,   205,   111,     0,    95,     0,
+       0,   679,     0,   636,     0,     0,     0,     0,     0,   653,
+       0,     0,     0,     0,     0,     0,     0,   673,     0,   651,
+       0,     0,     0,     0,    98,     0,     0,     0,   537,     0,
+       0,   146,     0,   200,     0,   206,    45,    49,    52,    55,
+      60,    63,    65,    67,    69,    71,    73,    75,     0,     0,
+     101,   564,   573,   577,     0,     0,     0,   598,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    45,
+      78,    91,     0,   551,     0,   161,   135,   554,   575,   553,
+     561,   552,     0,   555,   556,   579,   557,   586,   558,   559,
+     594,   560,     0,   119,     0,   127,     0,   545,   134,     0,
+       0,   107,     0,   104,    38,    39,     0,    22,    23,     0,
+       0,    28,    27,     0,   215,    31,    33,    40,     0,   212,
+     112,   683,     0,   684,   629,     0,     0,   682,   648,   644,
+     645,   646,   647,     0,   642,     0,    93,   649,     0,     0,
+     663,   664,   665,   666,     0,   661,     0,   667,     0,     0,
+     669,     0,     0,     0,     2,   677,   678,     0,   675,     0,
+       0,   623,   625,     0,   543,     0,   541,   536,   538,     0,
+     150,   148,   203,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    76,   201,   202,     0,
-     556,     0,   589,   602,   601,     0,   593,     0,   605,   603,
-       0,     0,     0,   586,   606,   607,   608,   555,    81,    82,
-      84,    83,    86,    87,    88,    89,    90,    85,    80,     0,
-       0,   571,   567,   569,   573,   580,   588,   127,     0,   541,
-     542,     0,   131,     0,   106,     4,     0,    24,    21,    32,
-     208,   620,     0,   537,     0,   532,   527,    46,    47,    48,
-      51,    50,    53,    54,    58,    59,    56,    57,    61,    62,
-      64,    66,    68,    70,    72,    74,     0,   203,   558,     0,
-       0,     0,     0,   604,     0,   585,    79,    92,   126,   539,
-       0,   104,    19,   533,   535,     0,     0,   577,     0,     0,
-       0,   596,   595,   598,   564,   581,   540,   543,     0,   559,
-       0,     0,     0,   597,     0,     0,   576,     0,     0,   574,
-       0,    77,     0,   561,   590,   560,     0,   599,     0,   564,
-     563,   565,   583,   578,     0,   600,   594,   575,   584,     0,
-     592,   582
+       0,     0,    76,   207,   208,     0,   563,     0,   596,   609,
+     608,     0,   600,     0,   612,   610,     0,     0,     0,   593,
+     613,   614,   615,   562,    81,    82,    84,    83,    86,    87,
+      88,    89,    90,    85,    80,     0,     0,   578,   574,   576,
+     580,   587,   595,   129,     0,   548,   549,     0,   133,     0,
+     108,     4,     0,    24,    21,    32,   214,   632,   634,     0,
+       0,   680,     0,   638,     0,   637,     0,   640,     0,     0,
+     655,     0,   654,     0,   657,     0,     0,   659,     0,     0,
+     674,     0,   671,     0,   652,   627,     0,   544,     0,   539,
+     534,    46,    47,    48,    51,    50,    53,    54,    58,    59,
+      56,    57,    61,    62,    64,    66,    68,    70,    72,    74,
+       0,   209,   565,     0,     0,     0,     0,   611,     0,   592,
+      79,    92,   128,   546,     0,   106,    19,   630,     0,   631,
+       0,   643,     0,   650,     0,   662,     0,   668,     0,   670,
+       0,     0,   676,   540,   542,     0,     0,   584,     0,     0,
+       0,   603,   602,   605,   571,   588,   547,   550,   633,   635,
+     639,   641,   656,   658,   660,   672,     0,   566,     0,     0,
+       0,   604,     0,     0,   583,     0,     0,   581,     0,    77,
+       0,   568,   597,   567,     0,   606,     0,   571,   570,   572,
+     590,   585,     0,   607,   601,   582,   591,     0,   599,   589
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,  -741,
-    -741,  -741, 10266,  -741,  -125,  -124,  -165,  -123,   -32,   -30,
-     -27,   -31,   -26,   -29,  -741,   -80,  -741,  -110,  -741,  -116,
-      92,     4,  -741,  -741,  -741,     6,   -48,  -741,  -741,   195,
-     202,   206,  -741,  -741,   -52,  -741,  -741,  -741,  -741,    93,
-    -741,   -17,   -28,  -741,     9,  -741,     0,   -69,  -741,  -741,
-    -741,  -741,   278,  -741,  -741,  -741,  -491,  -159,     3,   -83,
-    -222,  -741,  -107,  -217,  -740,  -741,  -141,  -741,  -741,  -151,
-    -150,  -741,  -741,   213,  -286,  -103,  -741,    51,  -741,  -122,
-    -741,    52,  -741,  -741,  -741,  -741,    54,  -741,  -741,  -741,
-    -741,  -741,  -741,  -741,  -741,   232,  -741,  -741,     2,  -741,
-     124
+    -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,  -863,
+    -863,  -863,  -418,  -863,  -380,  -379,  -484,  -382,  -258,  -256,
+    -253,  -257,  -252,  -255,  -863,  -478,  -863,  -485,  -863,  -491,
+    -530,    14,  -863,  -863,  -863,     7,  -397,  -863,  -863,    44,
+      53,    47,  -863,  -863,  -400,  -863,  -863,  -863,  -863,   -92,
+    -863,  -377,  -362,  -863,     9,  -863,     0,  -414,  -863,  -863,
+    -863,  -863,   150,  -863,  -863,  -863,  -546,  -548,  -218,  -331,
+    -624,  -863,  -359,  -609,  -862,  -863,  -417,  -863,  -863,  -427,
+    -426,  -863,  -863,    68,  -719,  -355,  -863,  -136,  -863,  -389,
+    -863,  -135,  -863,  -863,  -863,  -863,  -129,  -863,  -863,  -863,
+    -863,  -863,  -863,  -863,  -863,   102,  -863,  -863,     2,  -863,
+     -65,  -234,  -432,  -863,  -863,  -863,  -301,  -293,  -294,  -863,
+    -863,  -304,  -299,  -302,  -298,  -863,  -296,  -305,  -863,  -383,
+    -526
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-       0,   475,   476,   477,   676,   478,   479,   480,   481,   482,
-     483,   484,   541,   486,   509,   510,   511,   512,   513,   514,
-     515,   516,   517,   518,   519,   542,   706,   543,   659,   544,
-     594,   545,   368,   572,   453,   546,   370,   371,   372,   404,
-     405,   406,   373,   374,   375,   376,   377,   378,   432,   433,
-     379,   380,   381,   382,   487,   435,   488,   438,   417,   418,
-     489,   385,   386,   387,   501,   428,   499,   500,   599,   600,
-     570,   671,   549,   550,   551,   552,   553,   631,   726,   754,
-     746,   747,   748,   755,   554,   555,   556,   557,   749,   729,
-     558,   559,   750,   769,   560,   561,   562,   709,   635,   711,
-     733,   744,   745,   563,   388,   389,   390,   401,   564,   425,
-     426
+      -1,   520,   521,   522,   782,   523,   524,   525,   526,   527,
+     528,   529,   609,   531,   577,   578,   579,   580,   581,   582,
+     583,   584,   585,   586,   587,   610,   840,   611,   765,   612,
+     695,   613,   378,   640,   498,   614,   380,   381,   382,   427,
+     428,   429,   383,   384,   385,   386,   387,   388,   477,   478,
+     389,   390,   391,   392,   532,   480,   533,   483,   440,   441,
+     534,   395,   396,   397,   569,   473,   567,   568,   705,   706,
+     638,   777,   617,   618,   619,   620,   621,   737,   876,   912,
+     904,   905,   906,   913,   622,   623,   624,   625,   907,   879,
+     626,   627,   908,   927,   628,   629,   630,   843,   741,   845,
+     883,   902,   903,   631,   398,   399,   400,   424,   632,   470,
+     471,   450,   451,   789,   790,   402,   673,   674,   678,   403,
+     404,   684,   685,   688,   691,   405,   697,   698,   406,   452,
+     453
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1611,84 +1685,145 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     384,   753,   391,   590,   367,   447,   369,   436,   761,   383,
-     603,   436,   521,   392,   448,   591,   436,   396,   753,   437,
-     522,   612,   613,   566,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,   673,   397,    61,    62,    63,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
-     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
-     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
-     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
-     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
-     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
-     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
-     288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
-     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,   663,   569,   422,
-     602,   578,   449,   421,   667,   708,   670,   625,   490,   672,
-     394,   430,   414,   521,   521,   407,   520,   400,   503,   398,
-     571,   668,   614,   615,   504,   450,   494,   610,   451,   611,
-     495,   452,   408,   587,   423,   431,   565,   567,   505,   414,
-     415,   383,   395,   626,   506,   399,   407,   402,   384,   383,
-     391,   384,   367,   427,   369,   414,   322,   383,   616,   617,
-     383,   327,   328,   408,   441,   579,   580,   408,   584,   675,
-     403,   497,   383,   593,   585,   660,   383,   640,   710,   642,
-     734,   411,   593,   415,   735,   -35,   660,   581,   498,   764,
-     660,   582,   383,   409,   416,   660,   410,   383,   424,   548,
-     574,   629,   660,   575,   602,   661,   718,   429,   547,   694,
-     695,   696,   697,   719,   684,   720,   569,   685,   569,   660,
-     684,   569,   713,   723,   439,   677,   318,   319,   320,   414,
-     607,   608,   609,   618,   619,   679,   768,   660,   715,   660,
-     738,   434,   497,   315,   497,   690,   691,   445,   692,   693,
-     446,   663,   436,   592,   491,   698,   699,   597,   737,   498,
-     492,   498,   493,   573,   496,   502,   383,   583,   383,   588,
-     383,   595,   422,   521,   602,   447,   421,   620,   598,   606,
-     621,   712,   623,   622,   627,   714,   624,   630,   632,   683,
-     763,   636,   648,   649,   650,   651,   652,   653,   654,   655,
-     656,   657,   633,   634,   637,   638,   641,   423,   643,   716,
-     717,   663,   658,   -36,   548,   497,   -34,   644,   569,   645,
-     646,   647,   674,   547,   384,   678,   -29,   681,   660,   730,
-     707,   722,   498,   383,   739,   740,   741,   742,  -562,   752,
-     758,   383,   757,   770,   523,   759,   497,   762,   700,   771,
-     725,   701,   703,   727,   604,   702,   705,   605,   704,   393,
-     682,   724,   443,   498,   731,   442,   760,   766,   732,   767,
-     569,   743,   383,   444,   440,   664,   665,   727,   666,   596,
-     420,     0,     0,     0,     0,     0,   756,     0,   751,     0,
-       0,   548,     0,     0,     0,   548,     0,     0,     0,     0,
-     547,   765,   569,     0,   547,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   497,   728,     0,     0,
+     394,   445,   401,   588,   444,   430,   445,   379,   637,   393,
+     773,   646,   776,   769,   377,   778,   667,   677,   842,   708,
+     494,   530,   687,   709,   446,   668,   535,   421,   437,   446,
+     466,   700,   667,   787,   720,   721,   731,   911,   475,   661,
+     710,   661,   662,   655,   919,   658,   492,   417,   481,   430,
+     328,   329,   330,   422,   911,   493,   481,   659,   669,   670,
+     671,   672,   476,   576,   482,   647,   648,   788,   437,   676,
+     722,   723,   732,   663,   676,   663,   633,   635,   589,   418,
+     676,   644,   645,   676,   437,   -35,   590,   649,   481,   407,
+     432,   650,   676,   433,   779,   634,   565,   754,   755,   756,
+     757,   758,   759,   760,   761,   762,   763,   716,   664,   717,
+     746,   735,   748,   657,   664,   589,   664,   764,   589,   664,
+     541,   664,   639,   664,   664,   774,   542,   495,   664,   576,
+     496,   543,   844,   497,   576,   549,   557,   544,   571,   573,
+     576,   550,   558,   576,   572,   574,   853,   652,   854,   637,
+     852,   637,   576,   653,   637,   415,   781,   665,   783,   791,
+     793,   708,   766,   795,   797,   542,   794,   408,   785,   796,
+     798,   576,   409,   693,   456,   458,   460,   462,   464,   465,
+     468,   800,   802,   804,   423,   807,   410,   801,   803,   805,
+     565,   808,   565,   810,   812,   426,   884,   425,   885,   811,
+     813,   926,   766,   437,   766,   890,   891,   892,   893,   894,
+     895,   794,   798,   801,   805,   808,   813,   922,   562,   411,
+     857,   859,   563,   766,   858,   860,   680,   681,   682,   683,
+     887,   708,   445,   769,   412,   444,   828,   829,   830,   831,
+     786,   718,   719,   454,   457,   459,   455,   455,   455,   413,
+     642,   439,   846,   643,   461,   446,   848,   455,   463,   467,
+     414,   455,   455,   565,   675,   724,   725,   455,   863,   677,
+     679,   686,   419,   455,   455,   867,   687,   766,   849,   689,
+     850,   851,   455,   420,   692,   667,   921,   455,   699,   637,
+     817,   455,   713,   714,   715,   821,   822,   823,   576,   576,
+     576,   576,   576,   576,   576,   576,   576,   576,   576,   576,
+     576,   576,   576,   576,   434,   766,   818,   769,   767,   819,
+     676,   676,   766,   818,   447,   847,   873,   676,   676,   766,
+     896,   449,   565,   676,   469,   676,   824,   825,   474,   826,
+     827,   479,   832,   833,   484,   325,   490,   491,   481,   875,
+     539,   536,   877,   537,   538,   540,   545,   641,   726,   546,
+     547,   548,   551,   559,   552,   666,   553,   554,   555,   637,
+     561,   556,   560,   651,   656,   589,   564,   570,   492,   662,
+     576,   576,   431,   690,   701,   729,   730,   576,   576,   728,
+     438,   393,   877,   576,   733,   576,   727,   736,   394,   393,
+     401,   394,   565,   704,   738,   379,   394,   393,   401,   914,
+     393,   909,   377,   448,   742,   393,   472,   739,   712,   740,
+     743,   744,   747,   749,   923,   637,   431,   486,   750,   751,
+     431,   752,   -36,   753,   -34,   393,   780,   784,   -29,   393,
+     792,   869,   799,   878,   814,   806,   438,   809,   815,   841,
+     880,   856,   766,   888,   897,   393,   899,   889,   900,   910,
+    -569,   898,   915,   916,   917,   591,   446,   920,   834,   928,
+     929,   835,   837,   566,   488,   836,   839,   489,   838,   487,
+     711,   416,   393,   878,   616,   816,   881,   874,   918,   924,
+     882,   925,   485,   615,   901,   862,   770,   771,   702,   866,
+     443,   861,   865,   772,   868,   864,   446,     0,   872,     0,
+       0,   870,     0,     0,     0,   871,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   660,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   696,     0,
+       0,     0,     0,     0,     0,   703,     0,   566,     0,   566,
+       0,     0,     0,     0,   393,     0,   393,     0,   393,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   616,     0,     0,     0,     0,     0,     0,     0,
+       0,   615,   394,     0,     0,     0,     0,     0,     0,     0,
+     566,   393,     0,     0,     0,     0,     0,     0,     0,   393,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   566,
+       0,     0,     0,     0,     0,     0,     0,     0,   393,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   616,     0,     0,
+       0,   616,     0,     0,     0,     0,   615,     0,     0,     0,
+     615,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   566,
+       0,     0,     0,     0,     0,     0,     0,     0,   393,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   696,     0,   696,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   616,   616,     0,   616,     0,   401,     0,     0,
+       0,   615,   615,     0,   615,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   616,     0,     0,     0,     0,     0,     0,
+       0,     0,   615,     0,     0,     0,     0,     0,     0,   616,
+       0,     0,     0,     0,     0,     0,   616,     0,   615,     0,
+       0,     0,     0,     0,     0,   615,   616,     0,     0,     0,
+     616,     0,     0,     0,     0,   615,   616,     0,     0,   615,
+       0,     0,     0,   442,     0,   615,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
+     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
+     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
+     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
+     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
+     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
+     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
+     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
+     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
+     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
+     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
+     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   325,     0,     0,     0,     0,     0,
+       0,     0,   326,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   327,   328,   329,   330,
+     331,     0,     0,     0,     0,     0,     0,     0,     0,   332,
+     333,   334,   335,   336,   337,   338,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   498,     0,     0,     0,     0,     0,     0,
-       0,   728,   383,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   423,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   548,   548,
-       0,   548,     0,   391,     0,     0,   423,   547,   547,     0,
-     547,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   548,     0,     0,     0,     0,     0,     0,
-       0,   548,   547,     0,     0,     0,     0,     0,   548,     0,
-     547,     0,     0,     0,     0,     0,     0,   547,   548,     0,
-       0,     0,   548,     0,     0,     0,     0,   547,   548,     0,
-       0,   547,     0,     0,     0,   419,     0,   547,     1,     2,
+       0,   339,   340,   341,   342,   343,   344,     0,     0,     0,
+       0,     0,     0,     0,     0,   345,     0,   346,   347,   348,
+     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
+     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
+     369,   370,   371,   372,   373,   374,   375,   376,     1,     2,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -1720,19 +1855,20 @@ static const yytype_int16 yytable[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   315,     0,     0,     0,
-       0,     0,     0,     0,   316,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   317,   318,
-     319,   320,   321,     0,     0,     0,     0,     0,     0,     0,
-       0,   322,   323,   324,   325,   326,   327,   328,     0,     0,
+     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
+     323,   324,     0,     0,   499,   500,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   329,   330,   331,   332,   333,   334,     0,
-       0,     0,     0,     0,     0,     0,     0,   335,     0,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+       0,     0,     0,   501,   502,     0,   325,     0,   591,   592,
+       0,     0,     0,     0,   593,   503,   504,   505,   506,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
+     329,   330,   331,     0,     0,     0,   507,   508,   509,   510,
+     511,   332,   333,   334,   335,   336,   337,   338,   594,   595,
+     596,   597,     0,   598,   599,   600,   601,   602,   603,   604,
+     605,   606,   607,   339,   340,   341,   342,   343,   344,   512,
+     513,   514,   515,   516,   517,   518,   519,   345,   608,   346,
      347,   348,   349,   350,   351,   352,   353,   354,   355,   356,
      357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
+     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
@@ -1764,20 +1900,21 @@ static const yytype_int16 yytable[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,     0,     0,   454,   455,     0,     0,
+     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
+     321,   322,   323,   324,     0,     0,   499,   500,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   456,   457,     0,   315,     0,
-     523,   524,     0,     0,     0,     0,   525,   458,   459,   460,
-     461,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     317,   318,   319,   320,   321,     0,     0,     0,   462,   463,
-     464,   465,   466,   322,   323,   324,   325,   326,   327,   328,
-     526,   527,   528,   529,     0,   530,   531,   532,   533,   534,
-     535,   536,   537,   538,   539,   329,   330,   331,   332,   333,
-     334,   467,   468,   469,   470,   471,   472,   473,   474,   335,
-     540,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+       0,     0,     0,     0,     0,   501,   502,     0,   325,     0,
+     591,   768,     0,     0,     0,     0,   593,   503,   504,   505,
+     506,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     327,   328,   329,   330,   331,     0,     0,     0,   507,   508,
+     509,   510,   511,   332,   333,   334,   335,   336,   337,   338,
+     594,   595,   596,   597,     0,   598,   599,   600,   601,   602,
+     603,   604,   605,   606,   607,   339,   340,   341,   342,   343,
+     344,   512,   513,   514,   515,   516,   517,   518,   519,   345,
+     608,   346,   347,   348,   349,   350,   351,   352,   353,   354,
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,     1,     2,     3,     4,     5,     6,     7,     8,
+     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
+     375,   376,     1,     2,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -1808,20 +1945,21 @@ static const yytype_int16 yytable[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,     0,     0,   454,   455,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,     0,     0,   499,   500,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   456,   457,     0,
-     315,     0,   523,   662,     0,     0,     0,     0,   525,   458,
-     459,   460,   461,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   317,   318,   319,   320,   321,     0,     0,     0,
-     462,   463,   464,   465,   466,   322,   323,   324,   325,   326,
-     327,   328,   526,   527,   528,   529,     0,   530,   531,   532,
-     533,   534,   535,   536,   537,   538,   539,   329,   330,   331,
-     332,   333,   334,   467,   468,   469,   470,   471,   472,   473,
-     474,   335,   540,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+       0,     0,     0,     0,     0,     0,     0,   501,   502,     0,
+     325,     0,   591,     0,     0,     0,     0,     0,   593,   503,
+     504,   505,   506,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   327,   328,   329,   330,   331,     0,     0,     0,
+     507,   508,   509,   510,   511,   332,   333,   334,   335,   336,
+     337,   338,   594,   595,   596,   597,     0,   598,   599,   600,
+     601,   602,   603,   604,   605,   606,   607,   339,   340,   341,
+     342,   343,   344,   512,   513,   514,   515,   516,   517,   518,
+     519,   345,   608,   346,   347,   348,   349,   350,   351,   352,
      353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,     1,     2,     3,     4,     5,     6,
+     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
+     373,   374,   375,   376,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -1852,20 +1990,21 @@ static const yytype_int16 yytable[] =
      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,     0,     0,
-     454,   455,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   456,
-     457,     0,   315,     0,   523,     0,     0,     0,     0,     0,
-     525,   458,   459,   460,   461,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   317,   318,   319,   320,   321,     0,
-       0,     0,   462,   463,   464,   465,   466,   322,   323,   324,
-     325,   326,   327,   328,   526,   527,   528,   529,     0,   530,
-     531,   532,   533,   534,   535,   536,   537,   538,   539,   329,
-     330,   331,   332,   333,   334,   467,   468,   469,   470,   471,
-     472,   473,   474,   335,   540,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,     0,     0,
+     499,   500,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   501,
+     502,     0,   325,     0,   484,     0,     0,     0,     0,     0,
+     593,   503,   504,   505,   506,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   327,   328,   329,   330,   331,     0,
+       0,     0,   507,   508,   509,   510,   511,   332,   333,   334,
+     335,   336,   337,   338,   594,   595,   596,   597,     0,   598,
+     599,   600,   601,   602,   603,   604,   605,   606,   607,   339,
+     340,   341,   342,   343,   344,   512,   513,   514,   515,   516,
+     517,   518,   519,   345,   608,   346,   347,   348,   349,   350,
      351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,     1,     2,     3,     4,
+     361,   362,   363,   364,   365,   366,   367,   368,   369,   370,
+     371,   372,   373,   374,   375,   376,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -1897,19 +2036,20 @@ static const yytype_int16 yytable[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-       0,     0,   454,   455,     0,     0,     0,     0,     0,     0,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+       0,     0,   499,   500,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   456,   457,     0,   315,     0,   439,     0,     0,     0,
-       0,     0,   525,   458,   459,   460,   461,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   317,   318,   319,   320,
-     321,     0,     0,     0,   462,   463,   464,   465,   466,   322,
-     323,   324,   325,   326,   327,   328,   526,   527,   528,   529,
-       0,   530,   531,   532,   533,   534,   535,   536,   537,   538,
-     539,   329,   330,   331,   332,   333,   334,   467,   468,   469,
-     470,   471,   472,   473,   474,   335,   540,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+       0,   501,   502,     0,   325,     0,     0,     0,     0,     0,
+       0,     0,   593,   503,   504,   505,   506,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   327,   328,   329,   330,
+     331,     0,     0,     0,   507,   508,   509,   510,   511,   332,
+     333,   334,   335,   336,   337,   338,   594,   595,   596,   597,
+       0,   598,   599,   600,   601,   602,   603,   604,   605,   606,
+     607,   339,   340,   341,   342,   343,   344,   512,   513,   514,
+     515,   516,   517,   518,   519,   345,   608,   346,   347,   348,
      349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,     1,     2,
+     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
+     369,   370,   371,   372,   373,   374,   375,   376,     1,     2,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -1941,19 +2081,20 @@ static const yytype_int16 yytable[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,     0,     0,   454,   455,     0,     0,     0,     0,
+     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
+     323,   324,     0,     0,   499,   500,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   501,   502,     0,   325,     0,     0,     0,
+       0,     0,     0,     0,   593,   503,   504,   505,   506,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
+     329,   330,   331,     0,     0,     0,   507,   508,   509,   510,
+     511,   332,   333,   334,   335,   336,   337,   338,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   456,   457,     0,   315,     0,     0,     0,
-       0,     0,     0,     0,   525,   458,   459,   460,   461,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   317,   318,
-     319,   320,   321,     0,     0,     0,   462,   463,   464,   465,
-     466,   322,   323,   324,   325,   326,   327,   328,   526,   527,
-     528,   529,     0,   530,   531,   532,   533,   534,   535,   536,
-     537,   538,   539,   329,   330,   331,   332,   333,   334,   467,
-     468,   469,   470,   471,   472,   473,   474,   335,   540,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+       0,     0,     0,   339,   340,   341,   342,   343,   344,   512,
+     513,   514,   515,   516,   517,   518,   519,   345,     0,   346,
      347,   348,   349,   350,   351,   352,   353,   354,   355,   356,
      357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
+     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
@@ -1985,20 +2126,21 @@ static const yytype_int16 yytable[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,     0,     0,   454,   455,     0,     0,
+     311,   312,   313,   314,     0,     0,     0,   318,   319,   320,
+     321,   322,   323,   324,     0,     0,   499,   500,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   456,   457,     0,   315,     0,
-       0,     0,     0,     0,     0,     0,   525,   458,   459,   460,
-     461,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     317,   318,   319,   320,   321,     0,     0,     0,   462,   463,
-     464,   465,   466,   322,   323,   324,   325,   326,   327,   328,
+       0,     0,     0,     0,     0,   501,   502,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   503,   504,   505,
+     506,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     327,   328,   329,   330,     0,     0,     0,     0,   507,   508,
+     509,   510,   511,   332,   333,   334,   335,   336,   337,   338,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   329,   330,   331,   332,   333,
-     334,   467,   468,   469,   470,   471,   472,   473,   474,   335,
-       0,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+       0,     0,     0,     0,     0,   339,   340,   341,   342,   343,
+     344,   512,   513,   514,   515,   516,   517,   518,   519,   345,
+       0,   346,   347,   348,   349,   350,   351,   352,   353,   354,
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,     1,     2,     3,     4,     5,     6,     7,     8,
+     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
+     375,   376,     1,     2,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -2029,20 +2171,21 @@ static const yytype_int16 yytable[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,     0,     0,   454,   455,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     325,     0,     0,     0,     0,     0,     0,     0,   326,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   456,   457,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   458,
-     459,   460,   461,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   317,   318,   319,   320,     0,     0,     0,     0,
-     462,   463,   464,   465,   466,   322,   323,   324,   325,   326,
-     327,   328,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   329,   330,   331,
-     332,   333,   334,   467,   468,   469,   470,   471,   472,   473,
-     474,   335,     0,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+       0,     0,   327,   328,   329,   330,   331,     0,     0,     0,
+       0,     0,     0,     0,     0,   332,   333,   334,   335,   336,
+     337,   338,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   339,   340,   341,
+     342,   343,   344,     0,     0,     0,     0,     0,     0,     0,
+       0,   345,     0,   346,   347,   348,   349,   350,   351,   352,
      353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,     1,     2,     3,     4,     5,     6,
+     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
+     373,   374,   375,   376,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2074,19 +2217,20 @@ static const yytype_int16 yytable[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,     0,     0,
+       0,   318,   319,   320,   321,   322,   323,   324,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   317,   318,   319,   320,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   322,   323,   324,
-     325,   326,   327,   328,   526,     0,     0,   529,     0,   530,
-     531,     0,     0,   534,     0,     0,     0,     0,     0,   329,
-     330,   331,   332,   333,   334,     0,     0,     0,     0,     0,
-       0,     0,     0,   335,     0,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
+       0,     0,     0,     0,   327,   328,   329,   330,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   332,   333,   334,
+     335,   336,   337,   338,   594,     0,     0,   597,     0,   598,
+     599,     0,     0,   602,     0,     0,     0,     0,     0,   339,
+     340,   341,   342,   343,   344,     0,     0,     0,     0,     0,
+       0,     0,     0,   345,     0,   346,   347,   348,   349,   350,
      351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,     1,     2,     3,     4,
+     361,   362,   363,   364,   365,   366,   367,   368,   369,   370,
+     371,   372,   373,   374,   375,   376,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -2118,19 +2262,20 @@ static const yytype_int16 yytable[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+       0,     0,     0,   318,   319,   320,   321,   322,   323,   324,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   315,     0,     0,     0,     0,     0,
-       0,     0,   316,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   317,   318,   319,   320,
-     321,     0,     0,     0,     0,     0,     0,     0,     0,   322,
-     323,   324,   325,   326,   327,   328,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   329,   330,   331,   332,   333,   334,     0,     0,     0,
-       0,     0,     0,     0,     0,   335,     0,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+       0,     0,   435,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   327,   328,   329,   330,
+       0,     0,     0,     0,     0,     0,     0,     0,   436,   332,
+     333,   334,   335,   336,   337,   338,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   339,   340,   341,   342,   343,   344,     0,     0,     0,
+       0,     0,     0,     0,     0,   345,     0,   346,   347,   348,
      349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,     1,     2,
+     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
+     369,   370,   371,   372,   373,   374,   375,   376,     1,     2,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -2162,19 +2307,20 @@ static const yytype_int16 yytable[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,     0,     0,     0,     0,     0,     0,     0,     0,
+     313,   314,     0,     0,     0,   318,   319,   320,   321,   322,
+     323,   324,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   325,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   412,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   317,   318,
-     319,   320,     0,     0,     0,     0,     0,     0,     0,     0,
-     413,   322,   323,   324,   325,   326,   327,   328,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
+     329,   330,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   332,   333,   334,   335,   336,   337,   338,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   329,   330,   331,   332,   333,   334,     0,
-       0,     0,     0,     0,     0,     0,     0,   335,     0,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+       0,     0,     0,   339,   340,   341,   342,   343,   344,     0,
+       0,     0,     0,     0,     0,     0,     0,   345,     0,   346,
      347,   348,   349,   350,   351,   352,   353,   354,   355,   356,
      357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
+     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
@@ -2206,20 +2352,21 @@ static const yytype_int16 yytable[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,     0,     0,     0,     0,     0,     0,
+     311,   312,   313,   314,     0,     0,     0,   318,   319,   320,
+     321,   322,   323,   324,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   601,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   707,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     317,   318,   319,   320,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   322,   323,   324,   325,   326,   327,   328,
+     327,   328,   329,   330,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   332,   333,   334,   335,   336,   337,   338,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   329,   330,   331,   332,   333,
-     334,     0,     0,     0,     0,     0,     0,     0,     0,   335,
-       0,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+       0,     0,     0,     0,     0,   339,   340,   341,   342,   343,
+     344,     0,     0,     0,     0,     0,     0,     0,     0,   345,
+       0,   346,   347,   348,   349,   350,   351,   352,   353,   354,
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
-     365,   366,     1,     2,     3,     4,     5,     6,     7,     8,
+     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
+     375,   376,     1,     2,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -2250,20 +2397,21 @@ static const yytype_int16 yytable[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,     0,     0,     0,     0,
+     309,   310,   311,   312,   313,   314,     0,     0,     0,   318,
+     319,   320,   321,   322,   323,   324,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   686,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   820,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   317,   318,   319,   320,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   322,   323,   324,   325,   326,
-     327,   328,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   329,   330,   331,
-     332,   333,   334,     0,     0,     0,     0,     0,     0,     0,
-       0,   335,     0,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+       0,     0,   327,   328,   329,   330,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   332,   333,   334,   335,   336,
+     337,   338,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   339,   340,   341,
+     342,   343,   344,     0,     0,     0,     0,     0,     0,     0,
+       0,   345,     0,   346,   347,   348,   349,   350,   351,   352,
      353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,   366,     1,     2,     3,     4,     5,     6,
+     363,   364,   365,   366,   367,   368,   369,   370,   371,   372,
+     373,   374,   375,   376,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2295,19 +2443,20 @@ static const yytype_int16 yytable[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,     0,     0,
+       0,   318,   319,   320,   321,   322,   323,   324,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   721,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   855,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   317,   318,   319,   320,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   322,   323,   324,
-     325,   326,   327,   328,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   329,
-     330,   331,   332,   333,   334,     0,     0,     0,     0,     0,
-       0,     0,     0,   335,     0,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
+       0,     0,     0,     0,   327,   328,   329,   330,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   332,   333,   334,
+     335,   336,   337,   338,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   339,
+     340,   341,   342,   343,   344,     0,     0,     0,     0,     0,
+       0,     0,     0,   345,     0,   346,   347,   348,   349,   350,
      351,   352,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,   366,     1,     2,     3,     4,
+     361,   362,   363,   364,   365,   366,   367,   368,   369,   370,
+     371,   372,   373,   374,   375,   376,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -2339,19 +2488,20 @@ static const yytype_int16 yytable[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+       0,     0,     0,   318,   319,   320,   321,   322,   323,   324,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   317,   318,   319,   320,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   322,
-     323,   324,   325,   326,   327,   328,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   327,   328,   329,   330,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   332,
+     333,   334,   335,   336,   337,   338,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   329,   330,   331,   332,   333,   334,     0,     0,     0,
-       0,     0,     0,     0,     0,   335,     0,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+       0,   339,   340,   341,   342,   343,   344,     0,     0,     0,
+       0,     0,     0,     0,     0,   345,     0,   346,   347,   348,
      349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,   366,     2,     3,
+     359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
+     369,   370,   371,   372,   373,   374,   375,   376,     2,     3,
        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
@@ -2383,18 +2533,19 @@ static const yytype_int16 yytable[] =
      284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
      294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
      304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,     0,     0,   454,   455,     0,     0,     0,     0,     0,
+     314,     0,     0,     0,     0,     0,     0,   321,     0,     0,
+       0,     0,     0,   499,   500,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   456,   457,     0,     0,     0,   568,   669,     0,
-       0,     0,     0,     0,   458,   459,   460,   461,     0,     0,
+       0,     0,   501,   502,     0,     0,     0,   636,   775,     0,
+       0,     0,     0,     0,   503,   504,   505,   506,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   462,   463,   464,   465,   466,
-     322,     0,     0,     0,     0,   327,   328,     0,     0,     0,
+       0,     0,     0,     0,     0,   507,   508,   509,   510,   511,
+     332,     0,     0,     0,     0,   337,   338,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   467,   468,
-     469,   470,   471,   472,   473,   474,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   512,   513,
+     514,   515,   516,   517,   518,   519,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     348,     2,     3,     4,     5,     6,     7,     8,     9,    10,
+     358,     2,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -2425,18 +2576,19 @@ static const yytype_int16 yytable[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,     0,     0,   454,   455,     0,     0,
+     311,   312,   313,   314,     0,     0,     0,     0,     0,     0,
+     321,     0,     0,     0,     0,     0,   499,   500,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   456,   457,     0,     0,     0,
-     568,   736,     0,     0,     0,     0,     0,   458,   459,   460,
-     461,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   462,   463,
-     464,   465,   466,   322,     0,     0,     0,     0,   327,   328,
+       0,     0,     0,     0,     0,   501,   502,     0,     0,     0,
+     636,   886,     0,     0,     0,     0,     0,   503,   504,   505,
+     506,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   507,   508,
+     509,   510,   511,   332,     0,     0,     0,     0,   337,   338,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   467,   468,   469,   470,   471,   472,   473,   474,     0,
+       0,   512,   513,   514,   515,   516,   517,   518,   519,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   348,     2,     3,     4,     5,     6,     7,
+       0,     0,     0,   358,     2,     3,     4,     5,     6,     7,
        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
@@ -2467,18 +2619,19 @@ static const yytype_int16 yytable[] =
      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
      288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
      298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,   309,   310,   311,   312,   313,   314,     0,     0,   454,
-     455,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   456,   457,
-       0,     0,   507,     0,     0,     0,     0,     0,     0,     0,
-     458,   459,   460,   461,     0,     0,     0,     0,     0,     0,
+     308,   309,   310,   311,   312,   313,   314,     0,     0,     0,
+       0,     0,     0,   321,     0,     0,     0,     0,     0,   499,
+     500,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   501,   502,
+       0,     0,   575,     0,     0,     0,     0,     0,     0,     0,
+     503,   504,   505,   506,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   462,   463,   464,   465,   466,   322,     0,     0,     0,
-       0,   327,   328,     0,     0,     0,     0,     0,     0,     0,
+       0,   507,   508,   509,   510,   511,   332,     0,     0,     0,
+       0,   337,   338,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   467,   468,   469,   470,   471,   472,
-     473,   474,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   348,     2,     3,     4,
+       0,     0,     0,     0,   512,   513,   514,   515,   516,   517,
+     518,   519,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   358,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -2510,17 +2663,18 @@ static const yytype_int16 yytable[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-       0,     0,   454,   455,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   321,     0,     0,     0,
+       0,     0,   499,   500,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   456,   457,     0,     0,     0,   568,     0,     0,     0,
-       0,     0,     0,   458,   459,   460,   461,     0,     0,     0,
+       0,   501,   502,     0,     0,     0,   636,     0,     0,     0,
+       0,     0,     0,   503,   504,   505,   506,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   462,   463,   464,   465,   466,   322,
-       0,     0,     0,     0,   327,   328,     0,     0,     0,     0,
+       0,     0,     0,     0,   507,   508,   509,   510,   511,   332,
+       0,     0,     0,     0,   337,   338,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   467,   468,   469,
-     470,   471,   472,   473,   474,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   348,
+       0,     0,     0,     0,     0,     0,     0,   512,   513,   514,
+     515,   516,   517,   518,   519,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   358,
        2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
@@ -2552,18 +2706,19 @@ static const yytype_int16 yytable[] =
      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
      292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
      302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,     0,     0,   454,   455,     0,     0,     0,
+     312,   313,   314,     0,     0,     0,     0,     0,     0,   321,
+       0,     0,     0,     0,     0,   499,   500,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   456,   457,     0,     0,   628,     0,
-       0,     0,     0,     0,     0,     0,   458,   459,   460,   461,
+       0,     0,     0,     0,   501,   502,     0,     0,   734,     0,
+       0,     0,     0,     0,     0,     0,   503,   504,   505,   506,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   462,   463,   464,
-     465,   466,   322,     0,     0,     0,     0,   327,   328,     0,
+       0,     0,     0,     0,     0,     0,     0,   507,   508,   509,
+     510,   511,   332,     0,     0,     0,     0,   337,   338,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     467,   468,   469,   470,   471,   472,   473,   474,     0,     0,
+     512,   513,   514,   515,   516,   517,   518,   519,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   348,     2,     3,     4,     5,     6,     7,     8,
+       0,     0,   358,     2,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -2594,18 +2749,19 @@ static const yytype_int16 yytable[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,     0,     0,   454,   455,
+     309,   310,   311,   312,   313,   314,     0,     0,     0,     0,
+       0,     0,   321,     0,     0,     0,     0,     0,   499,   500,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   456,   457,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   639,   458,
-     459,   460,   461,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   501,   502,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   745,   503,
+     504,   505,   506,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     462,   463,   464,   465,   466,   322,     0,     0,     0,     0,
-     327,   328,     0,     0,     0,     0,     0,     0,     0,     0,
+     507,   508,   509,   510,   511,   332,     0,     0,     0,     0,
+     337,   338,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   467,   468,   469,   470,   471,   472,   473,
-     474,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   348,     2,     3,     4,     5,
+       0,     0,     0,   512,   513,   514,   515,   516,   517,   518,
+     519,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   358,     2,     3,     4,     5,
        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
@@ -2637,17 +2793,18 @@ static const yytype_int16 yytable[] =
      286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
      296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
      306,   307,   308,   309,   310,   311,   312,   313,   314,     0,
-       0,   454,   455,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   321,     0,     0,     0,     0,
+       0,   499,   500,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     456,   457,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   458,   459,   460,   461,     0,     0,     0,     0,
+     501,   502,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   503,   504,   505,   506,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   462,   463,   464,   465,   466,   322,     0,
-       0,     0,     0,   327,   328,     0,     0,     0,     0,     0,
+       0,     0,     0,   507,   508,   509,   510,   511,   332,     0,
+       0,     0,     0,   337,   338,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   467,   468,   469,   470,
-     471,   472,   473,   474,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   348,     2,
+       0,     0,     0,     0,     0,     0,   512,   513,   514,   515,
+     516,   517,   518,   519,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   358,     2,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -2679,41 +2836,25 @@ static const yytype_int16 yytable[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   485,     0,   454,   455,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   508,   456,   457,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   458,   459,   460,   461,     0,
-     576,   577,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   462,   463,   464,   465,
-     466,   322,     0,     0,     0,     0,   327,   586,     0,     0,
-       0,     0,   589,     0,     0,     0,     0,     0,     0,   508,
-       0,     0,     0,     0,     0,     0,     0,     0,   508,   467,
-     468,   469,   470,   471,   472,   473,   474,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   508,     0,     0,
-       0,   348,     0,     0,     0,     0,     0,     0,     0,     0,
+     313,   314,     0,     0,     0,     0,     0,     0,   321,     0,
+       0,     0,     0,     0,   499,   500,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   501,   502,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   503,   504,   505,   506,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   507,   508,   509,   510,
+     511,   332,     0,     0,     0,     0,   337,   654,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   512,
+     513,   514,   515,   516,   517,   518,   519,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   680,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   687,   688,   689,   508,   508,   508,   508,
-     508,   508,   508,   508,   508,   508,   508,   508,   508,   508,
-     508,   508
-};
-
-static const yytype_int16 yycheck[] =
-{
-       0,   741,     0,   346,     0,   339,     0,   341,   748,     0,
-     501,   341,   341,   341,   348,   358,   341,   339,   758,   349,
-     349,   317,   318,   348,     4,     5,     6,     7,     8,     9,
+       0,   358,     2,     3,     4,     5,     6,     7,     8,     9,
       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
-      60,   572,   339,    63,    64,    65,    66,    67,    68,    69,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,     0,
+       0,    61,    62,    63,    64,    65,    66,    67,    68,    69,
       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
@@ -2738,51 +2879,201 @@ static const yytype_int16 yycheck[] =
      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
      290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
      300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   554,   448,   391,
-     499,   457,   411,   391,   566,   631,   568,   326,   417,   571,
-     343,   375,   380,   341,   341,   372,   436,   349,   340,   349,
-     348,   348,   321,   322,   346,   343,   342,   351,   346,   353,
-     346,   349,   372,   483,   391,   399,   445,   446,   340,   407,
-     380,   372,   375,   362,   346,   375,   403,   340,   388,   380,
-     388,   391,   388,   393,   388,   423,   376,   388,   357,   358,
-     391,   381,   382,   403,   402,   319,   320,   407,   340,   340,
-     346,   428,   403,   493,   346,   346,   407,   533,   635,   535,
-     340,   375,   502,   423,   340,   339,   346,   341,   428,   340,
-     346,   345,   423,   346,   357,   346,   349,   428,   375,   439,
-     346,   521,   346,   349,   603,   349,   668,   343,   439,   614,
-     615,   616,   617,   344,   346,   346,   566,   349,   568,   346,
-     346,   571,   349,   349,   343,   581,   364,   365,   366,   497,
-     354,   355,   356,   323,   324,   585,   762,   346,   347,   346,
-     347,   375,   499,   341,   501,   610,   611,   375,   612,   613,
-     375,   708,   341,   491,   340,   618,   619,   497,   720,   499,
-     375,   501,   339,   375,   349,   348,   497,   340,   499,   339,
-     501,   342,   564,   341,   673,   339,   564,   361,   375,   375,
-     360,   637,   325,   359,   342,   641,   327,   344,   339,   598,
-     752,   339,   328,   329,   330,   331,   332,   333,   334,   335,
-     336,   337,   349,   349,   339,   349,   339,   564,   347,   659,
-     660,   768,   348,   339,   554,   572,   339,   349,   668,   349,
-     349,   349,   375,   554,   564,   375,   340,   340,   346,   383,
-     342,   342,   572,   564,   344,   375,   340,   339,   343,   348,
-     340,   572,   349,   349,   343,   387,   603,   343,   620,   344,
-     706,   621,   623,   709,   502,   622,   625,   504,   624,   321,
-     597,   684,   407,   603,   711,   403,   747,   758,   711,   759,
-     720,   733,   603,   407,   401,   564,   564,   733,   564,   495,
-     388,    -1,    -1,    -1,    -1,    -1,   742,    -1,   738,    -1,
-      -1,   631,    -1,    -1,    -1,   635,    -1,    -1,    -1,    -1,
-     631,   757,   752,    -1,   635,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   673,   709,    -1,    -1,
+     310,   311,   312,   313,   314,     0,     0,     0,     0,     0,
+       0,   321,     0,     0,     0,     0,     0,   499,   500,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   501,   502,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   503,   504,
+     505,   506,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   507,
+     508,   509,   510,   694,   332,     0,     0,     0,     0,   337,
+     338,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   512,   513,   514,   515,   516,   517,   518,   519,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   358,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,     0,     0,
+       0,     0,     0,     0,   321,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   332,     0,     0,
+       0,     0,   337,   338
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,   401,     0,   481,   401,   382,   406,     0,   493,     0,
+     634,   502,   636,   622,     0,   639,   542,   547,   737,   567,
+     434,   439,   552,   569,   401,   348,   440,   359,   390,   406,
+     413,   561,   558,   348,   331,   332,   336,   899,   385,   348,
+     570,   348,   351,   528,   906,   356,   349,   353,   351,   426,
+     374,   375,   376,   385,   916,   358,   351,   368,   381,   382,
+     383,   384,   409,   481,   359,   329,   330,   382,   430,   547,
+     367,   368,   372,   382,   552,   382,   490,   491,   351,   385,
+     558,   499,   500,   561,   446,   349,   359,   351,   351,   349,
+     356,   355,   570,   359,   640,   358,   473,   338,   339,   340,
+     341,   342,   343,   344,   345,   346,   347,   361,   540,   363,
+     601,   589,   603,   531,   546,   351,   548,   358,   351,   551,
+     350,   553,   358,   555,   556,   358,   356,   353,   560,   547,
+     356,   350,   741,   359,   552,   350,   350,   356,   350,   350,
+     558,   356,   356,   561,   356,   356,   354,   350,   356,   634,
+     774,   636,   570,   356,   639,   351,   350,   540,   649,   350,
+     350,   709,   356,   350,   350,   356,   356,   349,   653,   356,
+     356,   589,   349,   556,   408,   409,   410,   411,   412,   413,
+     414,   350,   350,   350,   359,   350,   349,   356,   356,   356,
+     567,   356,   569,   350,   350,   356,   350,   350,   350,   356,
+     356,   920,   356,   565,   356,   350,   350,   350,   350,   350,
+     350,   356,   356,   356,   356,   356,   356,   350,   352,   349,
+     352,   352,   356,   356,   356,   356,   381,   382,   383,   384,
+     854,   779,   632,   842,   349,   632,   720,   721,   722,   723,
+     658,   327,   328,   382,   382,   382,   385,   385,   385,   349,
+     356,   367,   743,   359,   382,   632,   747,   385,   382,   382,
+     349,   385,   385,   640,   382,   333,   334,   385,   798,   799,
+     382,   382,   349,   385,   385,   805,   806,   356,   357,   382,
+     765,   766,   385,   349,   382,   811,   910,   385,   382,   774,
+     704,   385,   364,   365,   366,   713,   714,   715,   716,   717,
+     718,   719,   720,   721,   722,   723,   724,   725,   726,   727,
+     728,   729,   730,   731,   385,   356,   356,   926,   359,   359,
+     798,   799,   356,   356,   359,   359,   359,   805,   806,   356,
+     357,   385,   709,   811,   385,   813,   716,   717,   353,   718,
+     719,   385,   724,   725,   353,   351,   385,   385,   351,   840,
+     358,   350,   843,   385,   359,   356,   358,   385,   371,   356,
+     356,   356,   356,   350,   356,   385,   356,   356,   356,   854,
+     349,   356,   356,   350,   349,   351,   359,   358,   349,   351,
+     798,   799,   382,   348,   352,   335,   337,   805,   806,   369,
+     390,   382,   883,   811,   352,   813,   370,   354,   398,   390,
+     398,   401,   779,   385,   349,   398,   406,   398,   406,   900,
+     401,   896,   398,   406,   349,   406,   416,   359,   385,   359,
+     349,   359,   349,   357,   915,   910,   426,   425,   359,   359,
+     430,   359,   349,   359,   349,   426,   385,   385,   350,   430,
+     358,   348,   356,   843,   350,   356,   446,   356,   350,   352,
+     393,   352,   356,   348,   354,   446,   350,   382,   349,   358,
+     353,   385,   359,   350,   397,   353,   843,   353,   726,   359,
+     354,   727,   729,   473,   430,   728,   731,   430,   730,   426,
+     572,   331,   473,   883,   484,   703,   845,   818,   905,   916,
+     845,   917,   424,   484,   883,   796,   632,   632,   563,   803,
+     398,   794,   801,   632,   806,   799,   883,    -1,   813,    -1,
+      -1,   809,    -1,    -1,    -1,   811,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   536,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   558,    -1,
+      -1,    -1,    -1,    -1,    -1,   565,    -1,   567,    -1,   569,
+      -1,    -1,    -1,    -1,   565,    -1,   567,    -1,   569,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   622,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   622,   632,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     640,   632,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   640,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   709,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   709,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   737,    -1,    -1,
+      -1,   741,    -1,    -1,    -1,    -1,   737,    -1,    -1,    -1,
+     741,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   779,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   779,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   811,    -1,   813,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   842,   843,    -1,   845,    -1,   845,    -1,    -1,
+      -1,   842,   843,    -1,   845,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   883,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   883,    -1,    -1,    -1,    -1,    -1,    -1,   899,
+      -1,    -1,    -1,    -1,    -1,    -1,   906,    -1,   899,    -1,
+      -1,    -1,    -1,    -1,    -1,   906,   916,    -1,    -1,    -1,
+     920,    -1,    -1,    -1,    -1,   916,   926,    -1,    -1,   920,
+      -1,    -1,    -1,     0,    -1,   926,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   673,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   733,   673,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   709,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   708,   709,
-      -1,   711,    -1,   711,    -1,    -1,   733,   708,   709,    -1,
-     711,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   733,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   741,   733,    -1,    -1,    -1,    -1,    -1,   748,    -1,
-     741,    -1,    -1,    -1,    -1,    -1,    -1,   748,   758,    -1,
-      -1,    -1,   762,    -1,    -1,    -1,    -1,   758,   768,    -1,
-      -1,   762,    -1,    -1,    -1,     0,    -1,   768,     3,     4,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   351,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,
+     377,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,
+     387,   388,   389,   390,   391,   392,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   408,   409,   410,   411,   412,   413,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   422,    -1,   424,   425,   426,
+     427,   428,   429,   430,   431,   432,   433,   434,   435,   436,
+     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
+     447,   448,   449,   450,   451,   452,   453,   454,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -2814,19 +3105,20 @@ static const yytype_int16 yycheck[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   341,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   349,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,   364,
-     365,   366,   367,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   376,   377,   378,   379,   380,   381,   382,    -1,    -1,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,    -1,    -1,   329,   330,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   398,   399,   400,   401,   402,   403,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   412,    -1,   414,
+      -1,    -1,    -1,   348,   349,    -1,   351,    -1,   353,   354,
+      -1,    -1,    -1,    -1,   359,   360,   361,   362,   363,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,   374,
+     375,   376,   377,    -1,    -1,    -1,   381,   382,   383,   384,
+     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
+     395,   396,    -1,   398,   399,   400,   401,   402,   403,   404,
+     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
      415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
      425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
      435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
+     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -2858,20 +3150,21 @@ static const yytype_int16 yycheck[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,    -1,    -1,   319,   320,    -1,    -1,
+     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
+     323,   324,   325,   326,    -1,    -1,   329,   330,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   338,   339,    -1,   341,    -1,
-     343,   344,    -1,    -1,    -1,    -1,   349,   350,   351,   352,
-     353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     363,   364,   365,   366,   367,    -1,    -1,    -1,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,    -1,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
+      -1,    -1,    -1,    -1,    -1,   348,   349,    -1,   351,    -1,
+     353,   354,    -1,    -1,    -1,    -1,   359,   360,   361,   362,
+     363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     373,   374,   375,   376,   377,    -1,    -1,    -1,   381,   382,
+     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
+     393,   394,   395,   396,    -1,   398,   399,   400,   401,   402,
      403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
      413,   414,   415,   416,   417,   418,   419,   420,   421,   422,
      423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
      433,   434,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,     3,     4,     5,     6,     7,     8,     9,    10,
+     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
+     453,   454,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -2902,20 +3195,21 @@ static const yytype_int16 yycheck[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,    -1,    -1,   319,   320,
+     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
+     321,   322,   323,   324,   325,   326,    -1,    -1,   329,   330,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,    -1,
-     341,    -1,   343,   344,    -1,    -1,    -1,    -1,   349,   350,
-     351,   352,   353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   363,   364,   365,   366,   367,    -1,    -1,    -1,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,   383,   384,   385,   386,    -1,   388,   389,   390,
-     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,   349,    -1,
+     351,    -1,   353,    -1,    -1,    -1,    -1,    -1,   359,   360,
+     361,   362,   363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   373,   374,   375,   376,   377,    -1,    -1,    -1,
+     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
+     391,   392,   393,   394,   395,   396,    -1,   398,   399,   400,
      401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
      411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
      421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
      431,   432,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,     3,     4,     5,     6,     7,     8,
+     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
+     451,   452,   453,   454,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -2946,20 +3240,21 @@ static const yytype_int16 yycheck[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,    -1,    -1,
-     319,   320,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,
-     339,    -1,   341,    -1,   343,    -1,    -1,    -1,    -1,    -1,
-     349,   350,   351,   352,   353,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   363,   364,   365,   366,   367,    -1,
-      -1,    -1,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,    -1,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,    -1,    -1,
+     329,   330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,
+     349,    -1,   351,    -1,   353,    -1,    -1,    -1,    -1,    -1,
+     359,   360,   361,   362,   363,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,   381,   382,   383,   384,   385,   386,   387,   388,
+     389,   390,   391,   392,   393,   394,   395,   396,    -1,   398,
      399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
      409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
      419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
      429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,     3,     4,     5,     6,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2991,19 +3286,20 @@ static const yytype_int16 yycheck[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-      -1,    -1,   319,   320,    -1,    -1,    -1,    -1,    -1,    -1,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+      -1,    -1,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   338,   339,    -1,   341,    -1,   343,    -1,    -1,    -1,
-      -1,    -1,   349,   350,   351,   352,   353,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   363,   364,   365,   366,
-     367,    -1,    -1,    -1,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-      -1,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+      -1,   348,   349,    -1,   351,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   359,   360,   361,   362,   363,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,
+     377,    -1,    -1,    -1,   381,   382,   383,   384,   385,   386,
+     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
+      -1,   398,   399,   400,   401,   402,   403,   404,   405,   406,
      407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
      417,   418,   419,   420,   421,   422,   423,   424,   425,   426,
      427,   428,   429,   430,   431,   432,   433,   434,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,     3,     4,
+     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
+     447,   448,   449,   450,   451,   452,   453,   454,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -3035,19 +3331,20 @@ static const yytype_int16 yycheck[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,    -1,    -1,   319,   320,    -1,    -1,    -1,    -1,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,    -1,    -1,   329,   330,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   338,   339,    -1,   341,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   349,   350,   351,   352,   353,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,   364,
-     365,   366,   367,    -1,    -1,    -1,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,    -1,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
+      -1,    -1,    -1,   348,   349,    -1,   351,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   359,   360,   361,   362,   363,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,   374,
+     375,   376,   377,    -1,    -1,    -1,   381,   382,   383,   384,
+     385,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   408,   409,   410,   411,   412,   413,   414,
+     415,   416,   417,   418,   419,   420,   421,   422,    -1,   424,
      425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
      435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
+     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -3079,20 +3376,21 @@ static const yytype_int16 yycheck[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,    -1,    -1,   319,   320,    -1,    -1,
+     313,   314,   315,   316,    -1,    -1,    -1,   320,   321,   322,
+     323,   324,   325,   326,    -1,    -1,   329,   330,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   338,   339,    -1,   341,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   349,   350,   351,   352,
-     353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     363,   364,   365,   366,   367,    -1,    -1,    -1,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
+      -1,    -1,    -1,    -1,    -1,   348,   349,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   360,   361,   362,
+     363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     373,   374,   375,   376,    -1,    -1,    -1,    -1,   381,   382,
+     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
-      -1,   414,   415,   416,   417,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
+      -1,    -1,    -1,    -1,    -1,   408,   409,   410,   411,   412,
+     413,   414,   415,   416,   417,   418,   419,   420,   421,   422,
+      -1,   424,   425,   426,   427,   428,   429,   430,   431,   432,
      433,   434,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,     3,     4,     5,     6,     7,     8,     9,    10,
+     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
+     453,   454,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -3123,20 +3421,21 @@ static const yytype_int16 yycheck[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,    -1,    -1,   319,   320,
+     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
+     321,   322,   323,   324,   325,   326,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   350,
-     351,   352,   353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   363,   364,   365,   366,    -1,    -1,    -1,    -1,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
-     381,   382,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
-     411,   412,    -1,   414,   415,   416,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   359,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   373,   374,   375,   376,   377,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   386,   387,   388,   389,   390,
+     391,   392,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   408,   409,   410,
+     411,   412,   413,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
      431,   432,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,     3,     4,     5,     6,     7,     8,
+     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
+     451,   452,   453,   454,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -3168,19 +3467,20 @@ static const yytype_int16 yycheck[] =
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
      309,   310,   311,   312,   313,   314,   315,   316,    -1,    -1,
+      -1,   320,   321,   322,   323,   324,   325,   326,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   363,   364,   365,   366,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
-     379,   380,   381,   382,   383,    -1,    -1,   386,    -1,   388,
-     389,    -1,    -1,   392,    -1,    -1,    -1,    -1,    -1,   398,
-     399,   400,   401,   402,   403,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   412,    -1,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,   387,   388,
+     389,   390,   391,   392,   393,    -1,    -1,   396,    -1,   398,
+     399,    -1,    -1,   402,    -1,    -1,    -1,    -1,    -1,   408,
+     409,   410,   411,   412,   413,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   422,    -1,   424,   425,   426,   427,   428,
      429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,     3,     4,     5,     6,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -3212,19 +3512,20 @@ static const yytype_int16 yycheck[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+      -1,    -1,    -1,   320,   321,   322,   323,   324,   325,   326,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   341,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   349,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   363,   364,   365,   366,
-     367,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,
-     377,   378,   379,   380,   381,   382,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   398,   399,   400,   401,   402,   403,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   412,    -1,   414,   415,   416,
-     417,   418,   419,   420,   421,   422,   423,   424,   425,   426,
+      -1,    -1,   359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   385,   386,
+     387,   388,   389,   390,   391,   392,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   408,   409,   410,   411,   412,   413,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   422,    -1,   424,   425,   426,
      427,   428,   429,   430,   431,   432,   433,   434,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,     3,     4,
+     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
+     447,   448,   449,   450,   451,   452,   453,   454,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -3256,19 +3557,20 @@ static const yytype_int16 yycheck[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     315,   316,    -1,    -1,    -1,   320,   321,   322,   323,   324,
+     325,   326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   351,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   349,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,   364,
-     365,   366,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     375,   376,   377,   378,   379,   380,   381,   382,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,   374,
+     375,   376,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   386,   387,   388,   389,   390,   391,   392,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   398,   399,   400,   401,   402,   403,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   412,    -1,   414,
-     415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
+      -1,    -1,    -1,   408,   409,   410,   411,   412,   413,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   422,    -1,   424,
      425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
      435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
+     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
@@ -3300,20 +3602,21 @@ static const yytype_int16 yycheck[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,    -1,    -1,    -1,    -1,    -1,    -1,
+     313,   314,   315,   316,    -1,    -1,    -1,   320,   321,   322,
+     323,   324,   325,   326,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   344,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   354,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     363,   364,   365,   366,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   376,   377,   378,   379,   380,   381,   382,
+     373,   374,   375,   376,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,   390,   391,   392,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,
-     403,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   412,
-      -1,   414,   415,   416,   417,   418,   419,   420,   421,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
+      -1,    -1,    -1,    -1,    -1,   408,   409,   410,   411,   412,
+     413,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   422,
+      -1,   424,   425,   426,   427,   428,   429,   430,   431,   432,
      433,   434,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,     3,     4,     5,     6,     7,     8,     9,    10,
+     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
+     453,   454,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -3344,20 +3647,21 @@ static const yytype_int16 yycheck[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,    -1,    -1,    -1,    -1,
+     311,   312,   313,   314,   315,   316,    -1,    -1,    -1,   320,
+     321,   322,   323,   324,   325,   326,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   344,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   354,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   363,   364,   365,   366,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   376,   377,   378,   379,   380,
-     381,   382,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,   400,
-     401,   402,   403,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   412,    -1,   414,   415,   416,   417,   418,   419,   420,
-     421,   422,   423,   424,   425,   426,   427,   428,   429,   430,
+      -1,    -1,   373,   374,   375,   376,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   386,   387,   388,   389,   390,
+     391,   392,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   408,   409,   410,
+     411,   412,   413,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   422,    -1,   424,   425,   426,   427,   428,   429,   430,
      431,   432,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,     3,     4,     5,     6,     7,     8,
+     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
+     451,   452,   453,   454,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
@@ -3389,19 +3693,20 @@ static const yytype_int16 yycheck[] =
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
      309,   310,   311,   312,   313,   314,   315,   316,    -1,    -1,
+      -1,   320,   321,   322,   323,   324,   325,   326,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   344,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   354,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   363,   364,   365,   366,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
-     379,   380,   381,   382,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
-     399,   400,   401,   402,   403,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   412,    -1,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,   387,   388,
+     389,   390,   391,   392,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   408,
+     409,   410,   411,   412,   413,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   422,    -1,   424,   425,   426,   427,   428,
      429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,     3,     4,     5,     6,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -3433,19 +3738,20 @@ static const yytype_int16 yycheck[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+      -1,    -1,    -1,   320,   321,   322,   323,   324,   325,   326,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   363,   364,   365,   366,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,
-     377,   378,   379,   380,   381,   382,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,
+     387,   388,   389,   390,   391,   392,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   398,   399,   400,   401,   402,   403,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   412,    -1,   414,   415,   416,
-     417,   418,   419,   420,   421,   422,   423,   424,   425,   426,
+      -1,   408,   409,   410,   411,   412,   413,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   422,    -1,   424,   425,   426,
      427,   428,   429,   430,   431,   432,   433,   434,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,     4,     5,
+     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
+     447,   448,   449,   450,   451,   452,   453,   454,     4,     5,
        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
@@ -3477,18 +3783,19 @@ static const yytype_int16 yycheck[] =
      286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
      296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
      306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,    -1,    -1,   319,   320,    -1,    -1,    -1,    -1,    -1,
+     316,    -1,    -1,    -1,    -1,    -1,    -1,   323,    -1,    -1,
+      -1,    -1,    -1,   329,   330,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   338,   339,    -1,    -1,    -1,   343,   344,    -1,
-      -1,    -1,    -1,    -1,   350,   351,   352,   353,    -1,    -1,
+      -1,    -1,   348,   349,    -1,    -1,    -1,   353,   354,    -1,
+      -1,    -1,    -1,    -1,   360,   361,   362,   363,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   371,   372,   373,   374,   375,
-     376,    -1,    -1,    -1,    -1,   381,   382,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   381,   382,   383,   384,   385,
+     386,    -1,    -1,    -1,    -1,   391,   392,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   404,   405,
-     406,   407,   408,   409,   410,   411,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   414,   415,
+     416,   417,   418,   419,   420,   421,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     426,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+     436,     4,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
@@ -3519,18 +3826,19 @@ static const yytype_int16 yycheck[] =
      283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
      293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,    -1,    -1,   319,   320,    -1,    -1,
+     313,   314,   315,   316,    -1,    -1,    -1,    -1,    -1,    -1,
+     323,    -1,    -1,    -1,    -1,    -1,   329,   330,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   338,   339,    -1,    -1,    -1,
-     343,   344,    -1,    -1,    -1,    -1,    -1,   350,   351,   352,
-     353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   371,   372,
-     373,   374,   375,   376,    -1,    -1,    -1,    -1,   381,   382,
+      -1,    -1,    -1,    -1,    -1,   348,   349,    -1,    -1,    -1,
+     353,   354,    -1,    -1,    -1,    -1,    -1,   360,   361,   362,
+     363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   381,   382,
+     383,   384,   385,   386,    -1,    -1,    -1,    -1,   391,   392,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   404,   405,   406,   407,   408,   409,   410,   411,    -1,
+      -1,   414,   415,   416,   417,   418,   419,   420,   421,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   426,     4,     5,     6,     7,     8,     9,
+      -1,    -1,    -1,   436,     4,     5,     6,     7,     8,     9,
       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
@@ -3561,18 +3869,19 @@ static const yytype_int16 yycheck[] =
      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
      290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
      300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,    -1,    -1,   319,
-     320,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
-      -1,    -1,   342,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     350,   351,   352,   353,    -1,    -1,    -1,    -1,    -1,    -1,
+     310,   311,   312,   313,   314,   315,   316,    -1,    -1,    -1,
+      -1,    -1,    -1,   323,    -1,    -1,    -1,    -1,    -1,   329,
+     330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,   349,
+      -1,    -1,   352,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     360,   361,   362,   363,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   371,   372,   373,   374,   375,   376,    -1,    -1,    -1,
-      -1,   381,   382,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   381,   382,   383,   384,   385,   386,    -1,    -1,    -1,
+      -1,   391,   392,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   404,   405,   406,   407,   408,   409,
-     410,   411,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   426,     4,     5,     6,
+      -1,    -1,    -1,    -1,   414,   415,   416,   417,   418,   419,
+     420,   421,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   436,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -3604,17 +3913,18 @@ static const yytype_int16 yycheck[] =
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-      -1,    -1,   319,   320,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   323,    -1,    -1,    -1,
+      -1,    -1,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   338,   339,    -1,    -1,    -1,   343,    -1,    -1,    -1,
-      -1,    -1,    -1,   350,   351,   352,   353,    -1,    -1,    -1,
+      -1,   348,   349,    -1,    -1,    -1,   353,    -1,    -1,    -1,
+      -1,    -1,    -1,   360,   361,   362,   363,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   371,   372,   373,   374,   375,   376,
-      -1,    -1,    -1,    -1,   381,   382,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   381,   382,   383,   384,   385,   386,
+      -1,    -1,    -1,    -1,   391,   392,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   404,   405,   406,
-     407,   408,   409,   410,   411,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   426,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   414,   415,   416,
+     417,   418,   419,   420,   421,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   436,
        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
@@ -3646,18 +3956,19 @@ static const yytype_int16 yycheck[] =
      284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
      294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
      304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,    -1,    -1,   319,   320,    -1,    -1,    -1,
+     314,   315,   316,    -1,    -1,    -1,    -1,    -1,    -1,   323,
+      -1,    -1,    -1,    -1,    -1,   329,   330,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   338,   339,    -1,    -1,   342,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   350,   351,   352,   353,
+      -1,    -1,    -1,    -1,   348,   349,    -1,    -1,   352,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   360,   361,   362,   363,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   371,   372,   373,
-     374,   375,   376,    -1,    -1,    -1,    -1,   381,   382,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   381,   382,   383,
+     384,   385,   386,    -1,    -1,    -1,    -1,   391,   392,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     404,   405,   406,   407,   408,   409,   410,   411,    -1,    -1,
+     414,   415,   416,   417,   418,   419,   420,   421,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   426,     4,     5,     6,     7,     8,     9,    10,
+      -1,    -1,   436,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -3688,18 +3999,19 @@ static const yytype_int16 yycheck[] =
      281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
      291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
      301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,    -1,    -1,   319,   320,
+     311,   312,   313,   314,   315,   316,    -1,    -1,    -1,    -1,
+      -1,    -1,   323,    -1,    -1,    -1,    -1,    -1,   329,   330,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   349,   350,
-     351,   352,   353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,   349,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   359,   360,
+     361,   362,   363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     371,   372,   373,   374,   375,   376,    -1,    -1,    -1,    -1,
-     381,   382,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     381,   382,   383,   384,   385,   386,    -1,    -1,    -1,    -1,
+     391,   392,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   404,   405,   406,   407,   408,   409,   410,
-     411,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   426,     4,     5,     6,     7,
+      -1,    -1,    -1,   414,   415,   416,   417,   418,   419,   420,
+     421,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   436,     4,     5,     6,     7,
        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
@@ -3731,17 +4043,18 @@ static const yytype_int16 yycheck[] =
      288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
      298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
      308,   309,   310,   311,   312,   313,   314,   315,   316,    -1,
-      -1,   319,   320,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   323,    -1,    -1,    -1,    -1,
+      -1,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     338,   339,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   350,   351,   352,   353,    -1,    -1,    -1,    -1,
+     348,   349,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   360,   361,   362,   363,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   371,   372,   373,   374,   375,   376,    -1,
-      -1,    -1,    -1,   381,   382,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   381,   382,   383,   384,   385,   386,    -1,
+      -1,    -1,    -1,   391,   392,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   404,   405,   406,   407,
-     408,   409,   410,   411,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   426,     4,
+      -1,    -1,    -1,    -1,    -1,    -1,   414,   415,   416,   417,
+     418,   419,   420,   421,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   436,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
@@ -3773,35 +4086,108 @@ static const yytype_int16 yycheck[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   416,    -1,   319,   320,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   436,   338,   339,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   350,   351,   352,   353,    -1,
-     454,   455,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   371,   372,   373,   374,
-     375,   376,    -1,    -1,    -1,    -1,   381,   382,    -1,    -1,
-      -1,    -1,   486,    -1,    -1,    -1,    -1,    -1,    -1,   493,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   502,   404,
-     405,   406,   407,   408,   409,   410,   411,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   521,    -1,    -1,
-      -1,   426,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     315,   316,    -1,    -1,    -1,    -1,    -1,    -1,   323,    -1,
+      -1,    -1,    -1,    -1,   329,   330,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   348,   349,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   360,   361,   362,   363,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   381,   382,   383,   384,
+     385,   386,    -1,    -1,    -1,    -1,   391,   392,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   414,
+     415,   416,   417,   418,   419,   420,   421,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   590,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   607,   608,   609,   610,   611,   612,   613,
-     614,   615,   616,   617,   618,   619,   620,   621,   622,   623,
-     624,   625
-};
-
-  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-     symbol of state STATE-NUM.  */
-static const yytype_int16 yystos[] =
-{
-       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      -1,   436,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
+      -1,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,    -1,    -1,    -1,    -1,    -1,
+      -1,   323,    -1,    -1,    -1,    -1,    -1,   329,   330,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   348,   349,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   360,   361,
+     362,   363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   381,
+     382,   383,   384,   385,   386,    -1,    -1,    -1,    -1,   391,
+     392,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   414,   415,   416,   417,   418,   419,   420,   421,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   436,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,    -1,    -1,
+      -1,    -1,    -1,    -1,   323,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,    -1,    -1,
+      -1,    -1,   391,   392
+};
+
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+     symbol of state STATE-NUM.  */
+static const yytype_int16 yystos[] =
+{
+       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
@@ -3832,121 +4218,142 @@ static const yytype_int16 yystos[] =
      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
      292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
      302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   341,   349,   363,   364,   365,
-     366,   367,   376,   377,   378,   379,   380,   381,   382,   398,
-     399,   400,   401,   402,   403,   412,   414,   415,   416,   417,
-     418,   419,   420,   421,   422,   423,   424,   425,   426,   427,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   351,   359,   373,   374,   375,
+     376,   377,   386,   387,   388,   389,   390,   391,   392,   408,
+     409,   410,   411,   412,   413,   422,   424,   425,   426,   427,
      428,   429,   430,   431,   432,   433,   434,   435,   436,   437,
-     438,   439,   440,   441,   442,   443,   444,   476,   477,   480,
-     481,   482,   483,   487,   488,   489,   490,   491,   492,   495,
-     496,   497,   498,   499,   501,   506,   507,   508,   549,   550,
-     551,   553,   341,   507,   343,   375,   339,   339,   349,   375,
-     349,   552,   340,   346,   484,   485,   486,   496,   501,   346,
-     349,   375,   349,   375,   497,   501,   357,   503,   504,     0,
-     550,   481,   489,   496,   375,   554,   555,   501,   510,   343,
-     375,   399,   493,   494,   375,   500,   341,   349,   502,   343,
-     528,   553,   485,   484,   486,   375,   375,   339,   348,   502,
-     343,   346,   349,   479,   319,   320,   338,   339,   350,   351,
-     352,   353,   371,   372,   373,   374,   375,   404,   405,   406,
-     407,   408,   409,   410,   411,   446,   447,   448,   450,   451,
-     452,   453,   454,   455,   456,   457,   458,   499,   501,   505,
-     502,   340,   375,   339,   342,   346,   349,   496,   501,   511,
-     512,   509,   348,   340,   346,   340,   346,   342,   457,   459,
-     460,   461,   462,   463,   464,   465,   466,   467,   468,   469,
-     470,   341,   349,   343,   344,   349,   383,   384,   385,   386,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     413,   457,   470,   472,   474,   476,   480,   499,   501,   517,
-     518,   519,   520,   521,   529,   530,   531,   532,   535,   536,
-     539,   540,   541,   548,   553,   502,   348,   502,   343,   472,
-     515,   348,   478,   375,   346,   349,   457,   457,   474,   319,
-     320,   341,   345,   340,   340,   346,   382,   472,   339,   457,
-     346,   358,   553,   470,   475,   342,   555,   501,   375,   513,
-     514,   344,   512,   511,   475,   494,   375,   354,   355,   356,
-     351,   353,   317,   318,   321,   322,   357,   358,   323,   324,
-     361,   360,   359,   325,   327,   326,   362,   342,   342,   470,
-     344,   522,   339,   349,   349,   543,   339,   339,   349,   349,
-     474,   339,   474,   347,   349,   349,   349,   349,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,   348,   473,
-     346,   349,   344,   518,   532,   536,   541,   515,   348,   344,
-     515,   516,   515,   511,   375,   340,   449,   474,   375,   472,
-     457,   340,   513,   502,   346,   349,   344,   457,   457,   457,
-     459,   459,   460,   460,   461,   461,   461,   461,   462,   462,
-     463,   464,   465,   466,   467,   468,   471,   342,   529,   542,
-     518,   544,   474,   349,   474,   347,   472,   472,   515,   344,
-     346,   344,   342,   349,   514,   474,   523,   474,   489,   534,
-     383,   517,   530,   545,   340,   340,   344,   515,   347,   344,
-     375,   340,   339,   534,   546,   547,   525,   526,   527,   533,
-     537,   472,   348,   519,   524,   528,   474,   349,   340,   387,
-     521,   519,   343,   515,   340,   474,   524,   525,   529,   538,
-     349,   344
+     438,   439,   440,   441,   442,   443,   444,   445,   446,   447,
+     448,   449,   450,   451,   452,   453,   454,   486,   487,   490,
+     491,   492,   493,   497,   498,   499,   500,   501,   502,   505,
+     506,   507,   508,   509,   511,   516,   517,   518,   559,   560,
+     561,   563,   570,   574,   575,   580,   583,   349,   349,   349,
+     349,   349,   349,   349,   349,   351,   517,   353,   385,   349,
+     349,   359,   385,   359,   562,   350,   356,   494,   495,   496,
+     506,   511,   356,   359,   385,   359,   385,   507,   511,   367,
+     513,   514,     0,   560,   491,   499,   506,   359,   490,   385,
+     566,   567,   584,   585,   382,   385,   566,   382,   566,   382,
+     566,   382,   566,   382,   566,   566,   584,   382,   566,   385,
+     564,   565,   511,   520,   353,   385,   409,   503,   504,   385,
+     510,   351,   359,   512,   353,   538,   563,   495,   494,   496,
+     385,   385,   349,   358,   512,   353,   356,   359,   489,   329,
+     330,   348,   349,   360,   361,   362,   363,   381,   382,   383,
+     384,   385,   414,   415,   416,   417,   418,   419,   420,   421,
+     456,   457,   458,   460,   461,   462,   463,   464,   465,   466,
+     467,   468,   509,   511,   515,   512,   350,   385,   359,   358,
+     356,   350,   356,   350,   356,   358,   356,   356,   356,   350,
+     356,   356,   356,   356,   356,   356,   356,   350,   356,   350,
+     356,   349,   352,   356,   359,   506,   511,   521,   522,   519,
+     358,   350,   356,   350,   356,   352,   467,   469,   470,   471,
+     472,   473,   474,   475,   476,   477,   478,   479,   480,   351,
+     359,   353,   354,   359,   393,   394,   395,   396,   398,   399,
+     400,   401,   402,   403,   404,   405,   406,   407,   423,   467,
+     480,   482,   484,   486,   490,   509,   511,   527,   528,   529,
+     530,   531,   539,   540,   541,   542,   545,   546,   549,   550,
+     551,   558,   563,   512,   358,   512,   353,   482,   525,   358,
+     488,   385,   356,   359,   467,   467,   484,   329,   330,   351,
+     355,   350,   350,   356,   392,   482,   349,   467,   356,   368,
+     563,   348,   351,   382,   567,   584,   385,   585,   348,   381,
+     382,   383,   384,   571,   572,   382,   480,   485,   573,   382,
+     381,   382,   383,   384,   576,   577,   382,   485,   578,   382,
+     348,   579,   382,   584,   385,   485,   511,   581,   582,   382,
+     485,   352,   565,   511,   385,   523,   524,   354,   522,   521,
+     485,   504,   385,   364,   365,   366,   361,   363,   327,   328,
+     331,   332,   367,   368,   333,   334,   371,   370,   369,   335,
+     337,   336,   372,   352,   352,   480,   354,   532,   349,   359,
+     359,   553,   349,   349,   359,   359,   484,   349,   484,   357,
+     359,   359,   359,   359,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   358,   483,   356,   359,   354,   528,
+     542,   546,   551,   525,   358,   354,   525,   526,   525,   521,
+     385,   350,   459,   484,   385,   482,   467,   348,   382,   568,
+     569,   350,   358,   350,   356,   350,   356,   350,   356,   356,
+     350,   356,   350,   356,   350,   356,   356,   350,   356,   356,
+     350,   356,   350,   356,   350,   350,   523,   512,   356,   359,
+     354,   467,   467,   467,   469,   469,   470,   470,   471,   471,
+     471,   471,   472,   472,   473,   474,   475,   476,   477,   478,
+     481,   352,   539,   552,   528,   554,   484,   359,   484,   357,
+     482,   482,   525,   354,   356,   354,   352,   352,   356,   352,
+     356,   572,   571,   485,   573,   577,   576,   485,   578,   348,
+     579,   581,   582,   359,   524,   484,   533,   484,   499,   544,
+     393,   527,   540,   555,   350,   350,   354,   525,   348,   382,
+     350,   350,   350,   350,   350,   350,   357,   354,   385,   350,
+     349,   544,   556,   557,   535,   536,   537,   543,   547,   482,
+     358,   529,   534,   538,   484,   359,   350,   397,   531,   529,
+     353,   525,   350,   484,   534,   535,   539,   548,   359,   354
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_int16 yyr1[] =
 {
-       0,   445,   446,   447,   447,   447,   447,   447,   447,   447,
-     447,   447,   447,   447,   447,   447,   447,   447,   448,   448,
-     448,   448,   448,   448,   449,   450,   451,   452,   452,   453,
-     453,   454,   454,   455,   456,   456,   456,   457,   457,   457,
-     457,   458,   458,   458,   458,   459,   459,   459,   459,   460,
-     460,   460,   461,   461,   461,   462,   462,   462,   462,   462,
-     463,   463,   463,   464,   464,   465,   465,   466,   466,   467,
-     467,   468,   468,   469,   469,   470,   471,   470,   472,   472,
-     473,   473,   473,   473,   473,   473,   473,   473,   473,   473,
-     473,   474,   474,   475,   476,   476,   476,   476,   476,   476,
-     476,   476,   476,   478,   477,   479,   479,   480,   480,   480,
-     480,   481,   481,   482,   482,   483,   484,   484,   485,   485,
-     485,   485,   486,   487,   487,   487,   487,   487,   488,   488,
-     488,   488,   488,   489,   489,   490,   491,   491,   491,   491,
-     491,   491,   491,   491,   492,   493,   493,   494,   494,   494,
-     495,   496,   496,   497,   497,   497,   497,   497,   497,   497,
-     498,   498,   498,   498,   498,   498,   498,   498,   498,   498,
-     498,   498,   498,   498,   498,   498,   498,   498,   498,   498,
-     498,   498,   498,   498,   498,   498,   498,   498,   498,   498,
-     498,   498,   498,   498,   498,   499,   500,   500,   501,   501,
-     502,   502,   502,   502,   503,   503,   504,   505,   505,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   506,   506,   506,   506,   506,   506,   506,
-     506,   506,   506,   507,   507,   507,   509,   508,   510,   508,
-     511,   511,   512,   512,   513,   513,   514,   514,   515,   515,
-     515,   515,   516,   516,   517,   518,   518,   519,   519,   519,
-     519,   519,   519,   519,   519,   520,   521,   522,   523,   521,
-     524,   524,   526,   525,   527,   525,   528,   528,   529,   529,
-     530,   530,   531,   531,   532,   533,   533,   534,   534,   535,
-     535,   537,   536,   538,   538,   539,   539,   540,   540,   542,
-     541,   543,   541,   544,   541,   545,   545,   546,   546,   547,
-     547,   548,   548,   548,   548,   548,   548,   548,   548,   549,
-     549,   550,   550,   550,   552,   551,   553,   554,   554,   555,
-     555
+       0,   455,   456,   457,   457,   457,   457,   457,   457,   457,
+     457,   457,   457,   457,   457,   457,   457,   457,   458,   458,
+     458,   458,   458,   458,   459,   460,   461,   462,   462,   463,
+     463,   464,   464,   465,   466,   466,   466,   467,   467,   467,
+     467,   468,   468,   468,   468,   469,   469,   469,   469,   470,
+     470,   470,   471,   471,   471,   472,   472,   472,   472,   472,
+     473,   473,   473,   474,   474,   475,   475,   476,   476,   477,
+     477,   478,   478,   479,   479,   480,   481,   480,   482,   482,
+     483,   483,   483,   483,   483,   483,   483,   483,   483,   483,
+     483,   484,   484,   485,   486,   486,   486,   486,   486,   486,
+     486,   486,   486,   486,   486,   488,   487,   489,   489,   490,
+     490,   490,   490,   491,   491,   492,   492,   493,   494,   494,
+     495,   495,   495,   495,   496,   497,   497,   497,   497,   497,
+     498,   498,   498,   498,   498,   499,   499,   500,   501,   501,
+     501,   501,   501,   501,   501,   501,   502,   503,   503,   504,
+     504,   504,   505,   506,   506,   507,   507,   507,   507,   507,
+     507,   507,   507,   507,   507,   507,   508,   508,   508,   508,
+     508,   508,   508,   508,   508,   508,   508,   508,   508,   508,
+     508,   508,   508,   508,   508,   508,   508,   508,   508,   508,
+     508,   508,   508,   508,   508,   508,   508,   508,   508,   508,
+     508,   509,   510,   510,   511,   511,   512,   512,   512,   512,
+     513,   513,   514,   515,   515,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     517,   517,   517,   519,   518,   520,   518,   521,   521,   522,
+     522,   523,   523,   524,   524,   525,   525,   525,   525,   526,
+     526,   527,   528,   528,   529,   529,   529,   529,   529,   529,
+     529,   529,   530,   531,   532,   533,   531,   534,   534,   536,
+     535,   537,   535,   538,   538,   539,   539,   540,   540,   541,
+     541,   542,   543,   543,   544,   544,   545,   545,   547,   546,
+     548,   548,   549,   549,   550,   550,   552,   551,   553,   551,
+     554,   551,   555,   555,   556,   556,   557,   557,   558,   558,
+     558,   558,   558,   558,   558,   558,   559,   559,   560,   560,
+     560,   562,   561,   563,   564,   564,   565,   565,   566,   566,
+     567,   567,   568,   568,   569,   569,   570,   570,   570,   570,
+     570,   570,   571,   571,   572,   572,   572,   572,   572,   573,
+     573,   574,   574,   575,   575,   575,   575,   575,   575,   575,
+     575,   576,   576,   577,   577,   577,   577,   578,   578,   579,
+     579,   580,   580,   580,   580,   581,   581,   582,   582,   583,
+     583,   584,   584,   585,   585
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -3961,19 +4368,19 @@ static const yytype_int8 yyr2[] =
        1,     3,     3,     1,     3,     1,     3,     1,     3,     1,
        3,     1,     3,     1,     3,     1,     0,     6,     1,     3,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     3,     1,     2,     2,     4,     2,     3,     4,
-       2,     3,     4,     0,     6,     2,     3,     2,     3,     3,
-       4,     1,     1,     2,     3,     3,     2,     3,     2,     1,
-       2,     1,     1,     1,     3,     4,     6,     5,     1,     2,
-       3,     5,     4,     1,     2,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     4,     1,     3,     1,     3,     1,
-       1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     3,     1,     2,     3,     2,     2,     4,     2,
+       3,     4,     2,     3,     4,     0,     6,     2,     3,     2,
+       3,     3,     4,     1,     1,     2,     3,     3,     2,     3,
+       2,     1,     2,     1,     1,     1,     3,     4,     6,     5,
+       1,     2,     3,     5,     4,     1,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     4,     1,     3,     1,
+       3,     1,     1,     1,     2,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     4,     1,     1,     3,     2,     3,
-       2,     3,     3,     4,     1,     0,     3,     1,     3,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       4,     1,     1,     3,     2,     3,     2,     3,     3,     4,
+       1,     0,     3,     1,     3,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
@@ -4004,17 +4411,23 @@ static const yytype_int8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     0,     6,     0,     5,
-       1,     2,     3,     4,     1,     3,     1,     2,     1,     3,
-       4,     2,     1,     3,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     2,     2,     0,     0,     5,
-       1,     1,     0,     2,     0,     2,     2,     3,     1,     2,
-       1,     2,     1,     2,     5,     3,     1,     1,     4,     1,
-       2,     0,     8,     0,     1,     3,     2,     1,     2,     0,
-       6,     0,     8,     0,     7,     1,     1,     1,     0,     2,
-       3,     2,     2,     2,     3,     2,     2,     2,     2,     1,
-       2,     1,     1,     1,     0,     3,     5,     1,     3,     1,
-       4
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     0,     6,     0,     5,     1,     2,     3,
+       4,     1,     3,     1,     2,     1,     3,     4,     2,     1,
+       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     2,     2,     0,     0,     5,     1,     1,     0,
+       2,     0,     2,     2,     3,     1,     2,     1,     2,     1,
+       2,     5,     3,     1,     1,     4,     1,     2,     0,     8,
+       0,     1,     3,     2,     1,     2,     0,     6,     0,     8,
+       0,     7,     1,     1,     1,     0,     2,     3,     2,     2,
+       2,     3,     2,     2,     2,     2,     1,     2,     1,     1,
+       1,     0,     3,     5,     1,     3,     1,     4,     1,     3,
+       5,     5,     1,     3,     1,     3,     4,     6,     6,     8,
+       6,     8,     1,     3,     1,     1,     1,     1,     1,     1,
+       3,     4,     6,     4,     6,     6,     8,     6,     8,     6,
+       8,     1,     3,     1,     1,     1,     1,     1,     3,     1,
+       3,     6,     8,     4,     6,     1,     3,     1,     1,     4,
+       6,     1,     3,     3,     3
 };
 
 
@@ -4093,8 +4506,8 @@ yy_symbol_value_print (FILE *yyo,
                        yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
 {
   FILE *yyoutput = yyo;
-  YY_USE (yyoutput);
-  YY_USE (pParseContext);
+  YYUSE (yyoutput);
+  YYUSE (pParseContext);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
@@ -4102,7 +4515,7 @@ yy_symbol_value_print (FILE *yyo,
     YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
 # endif
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YY_USE (yykind);
+  YYUSE (yykind);
   YY_IGNORE_MAYBE_UNINITIALIZED_END
 }
 
@@ -4483,14 +4896,14 @@ static void
 yydestruct (const char *yymsg,
             yysymbol_kind_t yykind, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext)
 {
-  YY_USE (yyvaluep);
-  YY_USE (pParseContext);
+  YYUSE (yyvaluep);
+  YYUSE (pParseContext);
   if (!yymsg)
     yymsg = "Deleting";
   YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YY_USE (yykind);
+  YYUSE (yykind);
   YY_IGNORE_MAYBE_UNINITIALIZED_END
 }
 
@@ -4760,260 +5173,260 @@ yyreduce:
   switch (yyn)
     {
   case 2: /* variable_identifier: IDENTIFIER  */
-#line 371 "MachineIndependent/glslang.y"
+#line 392 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
     }
-#line 4768 "MachineIndependent/glslang_tab.cpp"
+#line 5181 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 3: /* primary_expression: variable_identifier  */
-#line 377 "MachineIndependent/glslang.y"
+#line 398 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4776 "MachineIndependent/glslang_tab.cpp"
+#line 5189 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN  */
-#line 380 "MachineIndependent/glslang.y"
+#line 401 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
     }
-#line 4786 "MachineIndependent/glslang_tab.cpp"
+#line 5199 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 5: /* primary_expression: FLOATCONSTANT  */
-#line 385 "MachineIndependent/glslang.y"
+#line 406 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 4794 "MachineIndependent/glslang_tab.cpp"
+#line 5207 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 6: /* primary_expression: INTCONSTANT  */
-#line 388 "MachineIndependent/glslang.y"
+#line 409 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4802 "MachineIndependent/glslang_tab.cpp"
+#line 5215 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 7: /* primary_expression: UINTCONSTANT  */
-#line 391 "MachineIndependent/glslang.y"
+#line 412 "MachineIndependent/glslang.y"
                    {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4811 "MachineIndependent/glslang_tab.cpp"
+#line 5224 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 8: /* primary_expression: BOOLCONSTANT  */
-#line 395 "MachineIndependent/glslang.y"
+#line 416 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 4819 "MachineIndependent/glslang_tab.cpp"
+#line 5232 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 9: /* primary_expression: STRING_LITERAL  */
-#line 399 "MachineIndependent/glslang.y"
+#line 420 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
     }
-#line 4827 "MachineIndependent/glslang_tab.cpp"
+#line 5240 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 10: /* primary_expression: INT32CONSTANT  */
-#line 402 "MachineIndependent/glslang.y"
+#line 423 "MachineIndependent/glslang.y"
                     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4836 "MachineIndependent/glslang_tab.cpp"
+#line 5249 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 11: /* primary_expression: UINT32CONSTANT  */
-#line 406 "MachineIndependent/glslang.y"
+#line 427 "MachineIndependent/glslang.y"
                      {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4845 "MachineIndependent/glslang_tab.cpp"
+#line 5258 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 12: /* primary_expression: INT64CONSTANT  */
-#line 410 "MachineIndependent/glslang.y"
+#line 431 "MachineIndependent/glslang.y"
                     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
     }
-#line 4854 "MachineIndependent/glslang_tab.cpp"
+#line 5267 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 13: /* primary_expression: UINT64CONSTANT  */
-#line 414 "MachineIndependent/glslang.y"
+#line 435 "MachineIndependent/glslang.y"
                      {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
     }
-#line 4863 "MachineIndependent/glslang_tab.cpp"
+#line 5276 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 14: /* primary_expression: INT16CONSTANT  */
-#line 418 "MachineIndependent/glslang.y"
+#line 439 "MachineIndependent/glslang.y"
                     {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4872 "MachineIndependent/glslang_tab.cpp"
+#line 5285 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 15: /* primary_expression: UINT16CONSTANT  */
-#line 422 "MachineIndependent/glslang.y"
+#line 443 "MachineIndependent/glslang.y"
                      {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4881 "MachineIndependent/glslang_tab.cpp"
+#line 5294 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 16: /* primary_expression: DOUBLECONSTANT  */
-#line 426 "MachineIndependent/glslang.y"
+#line 447 "MachineIndependent/glslang.y"
                      {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal");
         if (! parseContext.symbolTable.atBuiltInLevel())
             parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true);
     }
-#line 4892 "MachineIndependent/glslang_tab.cpp"
+#line 5305 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 17: /* primary_expression: FLOAT16CONSTANT  */
-#line 432 "MachineIndependent/glslang.y"
+#line 453 "MachineIndependent/glslang.y"
                       {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
     }
-#line 4901 "MachineIndependent/glslang_tab.cpp"
+#line 5314 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 18: /* postfix_expression: primary_expression  */
-#line 440 "MachineIndependent/glslang.y"
+#line 461 "MachineIndependent/glslang.y"
                          {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4909 "MachineIndependent/glslang_tab.cpp"
+#line 5322 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET  */
-#line 443 "MachineIndependent/glslang.y"
+#line 464 "MachineIndependent/glslang.y"
                                                                        {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4917 "MachineIndependent/glslang_tab.cpp"
+#line 5330 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 20: /* postfix_expression: function_call  */
-#line 446 "MachineIndependent/glslang.y"
+#line 467 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4925 "MachineIndependent/glslang_tab.cpp"
+#line 5338 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER  */
-#line 449 "MachineIndependent/glslang.y"
+#line 470 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
     }
-#line 4933 "MachineIndependent/glslang_tab.cpp"
+#line 5346 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 22: /* postfix_expression: postfix_expression INC_OP  */
-#line 452 "MachineIndependent/glslang.y"
+#line 473 "MachineIndependent/glslang.y"
                                 {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4943 "MachineIndependent/glslang_tab.cpp"
+#line 5356 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 23: /* postfix_expression: postfix_expression DEC_OP  */
-#line 457 "MachineIndependent/glslang.y"
+#line 478 "MachineIndependent/glslang.y"
                                 {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4953 "MachineIndependent/glslang_tab.cpp"
+#line 5366 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 24: /* integer_expression: expression  */
-#line 465 "MachineIndependent/glslang.y"
+#line 486 "MachineIndependent/glslang.y"
                  {
         parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4962 "MachineIndependent/glslang_tab.cpp"
+#line 5375 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 25: /* function_call: function_call_or_method  */
-#line 472 "MachineIndependent/glslang.y"
+#line 493 "MachineIndependent/glslang.y"
                               {
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
         delete (yyvsp[0].interm).function;
     }
-#line 4971 "MachineIndependent/glslang_tab.cpp"
+#line 5384 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 26: /* function_call_or_method: function_call_generic  */
-#line 479 "MachineIndependent/glslang.y"
+#line 500 "MachineIndependent/glslang.y"
                             {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4979 "MachineIndependent/glslang_tab.cpp"
+#line 5392 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN  */
-#line 485 "MachineIndependent/glslang.y"
+#line 506 "MachineIndependent/glslang.y"
                                                        {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4988 "MachineIndependent/glslang_tab.cpp"
+#line 5401 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN  */
-#line 489 "MachineIndependent/glslang.y"
+#line 510 "MachineIndependent/glslang.y"
                                                      {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4997 "MachineIndependent/glslang_tab.cpp"
+#line 5410 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 29: /* function_call_header_no_parameters: function_call_header VOID  */
-#line 496 "MachineIndependent/glslang.y"
+#line 517 "MachineIndependent/glslang.y"
                                 {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 5005 "MachineIndependent/glslang_tab.cpp"
+#line 5418 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 30: /* function_call_header_no_parameters: function_call_header  */
-#line 499 "MachineIndependent/glslang.y"
+#line 520 "MachineIndependent/glslang.y"
                            {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 5013 "MachineIndependent/glslang_tab.cpp"
+#line 5426 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 31: /* function_call_header_with_parameters: function_call_header assignment_expression  */
-#line 505 "MachineIndependent/glslang.y"
+#line 526 "MachineIndependent/glslang.y"
                                                  {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -5021,11 +5434,11 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-1].interm).function;
         (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5025 "MachineIndependent/glslang_tab.cpp"
+#line 5438 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression  */
-#line 512 "MachineIndependent/glslang.y"
+#line 533 "MachineIndependent/glslang.y"
                                                                        {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -5033,29 +5446,29 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-2].interm).function;
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
     }
-#line 5037 "MachineIndependent/glslang_tab.cpp"
+#line 5450 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 33: /* function_call_header: function_identifier LEFT_PAREN  */
-#line 522 "MachineIndependent/glslang.y"
+#line 543 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 5045 "MachineIndependent/glslang_tab.cpp"
+#line 5458 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 34: /* function_identifier: type_specifier  */
-#line 530 "MachineIndependent/glslang.y"
+#line 551 "MachineIndependent/glslang.y"
                      {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 5055 "MachineIndependent/glslang_tab.cpp"
+#line 5468 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 35: /* function_identifier: postfix_expression  */
-#line 535 "MachineIndependent/glslang.y"
+#line 556 "MachineIndependent/glslang.y"
                          {
         //
         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
@@ -5083,50 +5496,50 @@ yyreduce:
             (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
         }
     }
-#line 5087 "MachineIndependent/glslang_tab.cpp"
+#line 5500 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 36: /* function_identifier: non_uniform_qualifier  */
-#line 563 "MachineIndependent/glslang.y"
+#line 584 "MachineIndependent/glslang.y"
                             {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 5097 "MachineIndependent/glslang_tab.cpp"
+#line 5510 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 37: /* unary_expression: postfix_expression  */
-#line 572 "MachineIndependent/glslang.y"
+#line 593 "MachineIndependent/glslang.y"
                          {
         parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
     }
-#line 5108 "MachineIndependent/glslang_tab.cpp"
+#line 5521 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 38: /* unary_expression: INC_OP unary_expression  */
-#line 578 "MachineIndependent/glslang.y"
+#line 599 "MachineIndependent/glslang.y"
                               {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 5117 "MachineIndependent/glslang_tab.cpp"
+#line 5530 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 39: /* unary_expression: DEC_OP unary_expression  */
-#line 582 "MachineIndependent/glslang.y"
+#line 603 "MachineIndependent/glslang.y"
                               {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 5126 "MachineIndependent/glslang_tab.cpp"
+#line 5539 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 40: /* unary_expression: unary_operator unary_expression  */
-#line 586 "MachineIndependent/glslang.y"
+#line 607 "MachineIndependent/glslang.y"
                                       {
         if ((yyvsp[-1].interm).op != EOpNull) {
             char errorOp[2] = {0, 0};
@@ -5143,179 +5556,179 @@ yyreduce:
                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
         }
     }
-#line 5147 "MachineIndependent/glslang_tab.cpp"
+#line 5560 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 41: /* unary_operator: PLUS  */
-#line 606 "MachineIndependent/glslang.y"
+#line 627 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
-#line 5153 "MachineIndependent/glslang_tab.cpp"
+#line 5566 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 42: /* unary_operator: DASH  */
-#line 607 "MachineIndependent/glslang.y"
+#line 628 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
-#line 5159 "MachineIndependent/glslang_tab.cpp"
+#line 5572 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 43: /* unary_operator: BANG  */
-#line 608 "MachineIndependent/glslang.y"
+#line 629 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
-#line 5165 "MachineIndependent/glslang_tab.cpp"
+#line 5578 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 44: /* unary_operator: TILDE  */
-#line 609 "MachineIndependent/glslang.y"
+#line 630 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
               parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
-#line 5172 "MachineIndependent/glslang_tab.cpp"
+#line 5585 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 45: /* multiplicative_expression: unary_expression  */
-#line 615 "MachineIndependent/glslang.y"
+#line 636 "MachineIndependent/glslang.y"
                        { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5178 "MachineIndependent/glslang_tab.cpp"
+#line 5591 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 46: /* multiplicative_expression: multiplicative_expression STAR unary_expression  */
-#line 616 "MachineIndependent/glslang.y"
+#line 637 "MachineIndependent/glslang.y"
                                                       {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5188 "MachineIndependent/glslang_tab.cpp"
+#line 5601 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 47: /* multiplicative_expression: multiplicative_expression SLASH unary_expression  */
-#line 621 "MachineIndependent/glslang.y"
+#line 642 "MachineIndependent/glslang.y"
                                                        {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5198 "MachineIndependent/glslang_tab.cpp"
+#line 5611 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 48: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression  */
-#line 626 "MachineIndependent/glslang.y"
+#line 647 "MachineIndependent/glslang.y"
                                                          {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5209 "MachineIndependent/glslang_tab.cpp"
+#line 5622 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 49: /* additive_expression: multiplicative_expression  */
-#line 635 "MachineIndependent/glslang.y"
+#line 656 "MachineIndependent/glslang.y"
                                 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5215 "MachineIndependent/glslang_tab.cpp"
+#line 5628 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 50: /* additive_expression: additive_expression PLUS multiplicative_expression  */
-#line 636 "MachineIndependent/glslang.y"
+#line 657 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5225 "MachineIndependent/glslang_tab.cpp"
+#line 5638 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 51: /* additive_expression: additive_expression DASH multiplicative_expression  */
-#line 641 "MachineIndependent/glslang.y"
+#line 662 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5235 "MachineIndependent/glslang_tab.cpp"
+#line 5648 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 52: /* shift_expression: additive_expression  */
-#line 649 "MachineIndependent/glslang.y"
+#line 670 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5241 "MachineIndependent/glslang_tab.cpp"
+#line 5654 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 53: /* shift_expression: shift_expression LEFT_OP additive_expression  */
-#line 650 "MachineIndependent/glslang.y"
+#line 671 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5252 "MachineIndependent/glslang_tab.cpp"
+#line 5665 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 54: /* shift_expression: shift_expression RIGHT_OP additive_expression  */
-#line 656 "MachineIndependent/glslang.y"
+#line 677 "MachineIndependent/glslang.y"
                                                     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5263 "MachineIndependent/glslang_tab.cpp"
+#line 5676 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 55: /* relational_expression: shift_expression  */
-#line 665 "MachineIndependent/glslang.y"
+#line 686 "MachineIndependent/glslang.y"
                        { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5269 "MachineIndependent/glslang_tab.cpp"
+#line 5682 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 56: /* relational_expression: relational_expression LEFT_ANGLE shift_expression  */
-#line 666 "MachineIndependent/glslang.y"
+#line 687 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5279 "MachineIndependent/glslang_tab.cpp"
+#line 5692 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 57: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression  */
-#line 671 "MachineIndependent/glslang.y"
+#line 692 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5289 "MachineIndependent/glslang_tab.cpp"
+#line 5702 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 58: /* relational_expression: relational_expression LE_OP shift_expression  */
-#line 676 "MachineIndependent/glslang.y"
+#line 697 "MachineIndependent/glslang.y"
                                                     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5299 "MachineIndependent/glslang_tab.cpp"
+#line 5712 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 59: /* relational_expression: relational_expression GE_OP shift_expression  */
-#line 681 "MachineIndependent/glslang.y"
+#line 702 "MachineIndependent/glslang.y"
                                                     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5309 "MachineIndependent/glslang_tab.cpp"
+#line 5722 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 60: /* equality_expression: relational_expression  */
-#line 689 "MachineIndependent/glslang.y"
+#line 710 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5315 "MachineIndependent/glslang_tab.cpp"
+#line 5728 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 61: /* equality_expression: equality_expression EQ_OP relational_expression  */
-#line 690 "MachineIndependent/glslang.y"
+#line 711 "MachineIndependent/glslang.y"
                                                        {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
@@ -5325,11 +5738,11 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5329 "MachineIndependent/glslang_tab.cpp"
+#line 5742 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 62: /* equality_expression: equality_expression NE_OP relational_expression  */
-#line 699 "MachineIndependent/glslang.y"
+#line 720 "MachineIndependent/glslang.y"
                                                       {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
@@ -5339,124 +5752,124 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5343 "MachineIndependent/glslang_tab.cpp"
+#line 5756 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 63: /* and_expression: equality_expression  */
-#line 711 "MachineIndependent/glslang.y"
+#line 732 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5349 "MachineIndependent/glslang_tab.cpp"
+#line 5762 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 64: /* and_expression: and_expression AMPERSAND equality_expression  */
-#line 712 "MachineIndependent/glslang.y"
+#line 733 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5360 "MachineIndependent/glslang_tab.cpp"
+#line 5773 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 65: /* exclusive_or_expression: and_expression  */
-#line 721 "MachineIndependent/glslang.y"
+#line 742 "MachineIndependent/glslang.y"
                      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5366 "MachineIndependent/glslang_tab.cpp"
+#line 5779 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 66: /* exclusive_or_expression: exclusive_or_expression CARET and_expression  */
-#line 722 "MachineIndependent/glslang.y"
+#line 743 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5377 "MachineIndependent/glslang_tab.cpp"
+#line 5790 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 67: /* inclusive_or_expression: exclusive_or_expression  */
-#line 731 "MachineIndependent/glslang.y"
+#line 752 "MachineIndependent/glslang.y"
                               { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5383 "MachineIndependent/glslang_tab.cpp"
+#line 5796 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 68: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression  */
-#line 732 "MachineIndependent/glslang.y"
+#line 753 "MachineIndependent/glslang.y"
                                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5394 "MachineIndependent/glslang_tab.cpp"
+#line 5807 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 69: /* logical_and_expression: inclusive_or_expression  */
-#line 741 "MachineIndependent/glslang.y"
+#line 762 "MachineIndependent/glslang.y"
                               { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5400 "MachineIndependent/glslang_tab.cpp"
+#line 5813 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 70: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression  */
-#line 742 "MachineIndependent/glslang.y"
+#line 763 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5410 "MachineIndependent/glslang_tab.cpp"
+#line 5823 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 71: /* logical_xor_expression: logical_and_expression  */
-#line 750 "MachineIndependent/glslang.y"
+#line 771 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5416 "MachineIndependent/glslang_tab.cpp"
+#line 5829 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 72: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression  */
-#line 751 "MachineIndependent/glslang.y"
+#line 772 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5426 "MachineIndependent/glslang_tab.cpp"
+#line 5839 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 73: /* logical_or_expression: logical_xor_expression  */
-#line 759 "MachineIndependent/glslang.y"
+#line 780 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5432 "MachineIndependent/glslang_tab.cpp"
+#line 5845 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 74: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression  */
-#line 760 "MachineIndependent/glslang.y"
+#line 781 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5442 "MachineIndependent/glslang_tab.cpp"
+#line 5855 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 75: /* conditional_expression: logical_or_expression  */
-#line 768 "MachineIndependent/glslang.y"
+#line 789 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5448 "MachineIndependent/glslang_tab.cpp"
+#line 5861 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 76: /* $@1: %empty  */
-#line 769 "MachineIndependent/glslang.y"
+#line 790 "MachineIndependent/glslang.y"
                                      {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 5456 "MachineIndependent/glslang_tab.cpp"
+#line 5869 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 77: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression  */
-#line 772 "MachineIndependent/glslang.y"
+#line 793 "MachineIndependent/glslang.y"
                                              {
         --parseContext.controlFlowNestingLevel;
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
@@ -5469,17 +5882,17 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 5473 "MachineIndependent/glslang_tab.cpp"
+#line 5886 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 78: /* assignment_expression: conditional_expression  */
-#line 787 "MachineIndependent/glslang.y"
+#line 808 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5479 "MachineIndependent/glslang_tab.cpp"
+#line 5892 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 79: /* assignment_expression: unary_expression assignment_operator assignment_expression  */
-#line 788 "MachineIndependent/glslang.y"
+#line 809 "MachineIndependent/glslang.y"
                                                                  {
         parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
         parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
@@ -5493,119 +5906,119 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
         }
     }
-#line 5497 "MachineIndependent/glslang_tab.cpp"
+#line 5910 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 80: /* assignment_operator: EQUAL  */
-#line 804 "MachineIndependent/glslang.y"
+#line 825 "MachineIndependent/glslang.y"
             {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
-#line 5506 "MachineIndependent/glslang_tab.cpp"
+#line 5919 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 81: /* assignment_operator: MUL_ASSIGN  */
-#line 808 "MachineIndependent/glslang.y"
+#line 829 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
-#line 5515 "MachineIndependent/glslang_tab.cpp"
+#line 5928 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 82: /* assignment_operator: DIV_ASSIGN  */
-#line 812 "MachineIndependent/glslang.y"
+#line 833 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
-#line 5524 "MachineIndependent/glslang_tab.cpp"
+#line 5937 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 83: /* assignment_operator: MOD_ASSIGN  */
-#line 816 "MachineIndependent/glslang.y"
+#line 837 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpModAssign;
     }
-#line 5534 "MachineIndependent/glslang_tab.cpp"
+#line 5947 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 84: /* assignment_operator: ADD_ASSIGN  */
-#line 821 "MachineIndependent/glslang.y"
+#line 842 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
-#line 5543 "MachineIndependent/glslang_tab.cpp"
+#line 5956 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 85: /* assignment_operator: SUB_ASSIGN  */
-#line 825 "MachineIndependent/glslang.y"
+#line 846 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
-#line 5552 "MachineIndependent/glslang_tab.cpp"
+#line 5965 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 86: /* assignment_operator: LEFT_ASSIGN  */
-#line 829 "MachineIndependent/glslang.y"
+#line 850 "MachineIndependent/glslang.y"
                   {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
-#line 5561 "MachineIndependent/glslang_tab.cpp"
+#line 5974 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 87: /* assignment_operator: RIGHT_ASSIGN  */
-#line 833 "MachineIndependent/glslang.y"
+#line 854 "MachineIndependent/glslang.y"
                    {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
-#line 5570 "MachineIndependent/glslang_tab.cpp"
+#line 5983 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 88: /* assignment_operator: AND_ASSIGN  */
-#line 837 "MachineIndependent/glslang.y"
+#line 858 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
-#line 5579 "MachineIndependent/glslang_tab.cpp"
+#line 5992 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 89: /* assignment_operator: XOR_ASSIGN  */
-#line 841 "MachineIndependent/glslang.y"
+#line 862 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
-#line 5588 "MachineIndependent/glslang_tab.cpp"
+#line 6001 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 90: /* assignment_operator: OR_ASSIGN  */
-#line 845 "MachineIndependent/glslang.y"
+#line 866 "MachineIndependent/glslang.y"
                 {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
-#line 5597 "MachineIndependent/glslang_tab.cpp"
+#line 6010 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 91: /* expression: assignment_expression  */
-#line 852 "MachineIndependent/glslang.y"
+#line 873 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5605 "MachineIndependent/glslang_tab.cpp"
+#line 6018 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 92: /* expression: expression COMMA assignment_expression  */
-#line 855 "MachineIndependent/glslang.y"
+#line 876 "MachineIndependent/glslang.y"
                                              {
         parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
@@ -5614,40 +6027,62 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 5618 "MachineIndependent/glslang_tab.cpp"
+#line 6031 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 93: /* constant_expression: conditional_expression  */
-#line 866 "MachineIndependent/glslang.y"
+#line 887 "MachineIndependent/glslang.y"
                              {
         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5627 "MachineIndependent/glslang_tab.cpp"
+#line 6040 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 94: /* declaration: function_prototype SEMICOLON  */
-#line 873 "MachineIndependent/glslang.y"
+#line 894 "MachineIndependent/glslang.y"
                                    {
         parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
         (yyval.interm.intermNode) = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
-#line 5637 "MachineIndependent/glslang_tab.cpp"
+#line 6050 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 95: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON  */
+#line 900 "MachineIndependent/glslang.y"
+                                                               {
+        parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier");
+        (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier
+        parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
+        (yyval.interm.intermNode) = 0;
+        // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
+    }
+#line 6062 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 96: /* declaration: spirv_execution_mode_qualifier SEMICOLON  */
+#line 907 "MachineIndependent/glslang.y"
+                                               {
+        parseContext.globalCheck((yyvsp[0].lex).loc, "SPIR-V execution mode qualifier");
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier");
+        (yyval.interm.intermNode) = 0;
+    }
+#line 6072 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 95: /* declaration: init_declarator_list SEMICOLON  */
-#line 878 "MachineIndependent/glslang.y"
+  case 97: /* declaration: init_declarator_list SEMICOLON  */
+#line 913 "MachineIndependent/glslang.y"
                                      {
         if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
             (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
     }
-#line 5647 "MachineIndependent/glslang_tab.cpp"
+#line 6082 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 96: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON  */
-#line 883 "MachineIndependent/glslang.y"
+  case 98: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON  */
+#line 918 "MachineIndependent/glslang.y"
                                                              {
         parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
         // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope
@@ -5655,75 +6090,75 @@ yyreduce:
         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
         (yyval.interm.intermNode) = 0;
     }
-#line 5659 "MachineIndependent/glslang_tab.cpp"
+#line 6094 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 97: /* declaration: block_structure SEMICOLON  */
-#line 890 "MachineIndependent/glslang.y"
+  case 99: /* declaration: block_structure SEMICOLON  */
+#line 925 "MachineIndependent/glslang.y"
                                 {
         parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
         (yyval.interm.intermNode) = 0;
     }
-#line 5668 "MachineIndependent/glslang_tab.cpp"
+#line 6103 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 98: /* declaration: block_structure IDENTIFIER SEMICOLON  */
-#line 894 "MachineIndependent/glslang.y"
+  case 100: /* declaration: block_structure IDENTIFIER SEMICOLON  */
+#line 929 "MachineIndependent/glslang.y"
                                            {
         parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 5677 "MachineIndependent/glslang_tab.cpp"
+#line 6112 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 99: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON  */
-#line 898 "MachineIndependent/glslang.y"
+  case 101: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON  */
+#line 933 "MachineIndependent/glslang.y"
                                                            {
         parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
         (yyval.interm.intermNode) = 0;
     }
-#line 5686 "MachineIndependent/glslang_tab.cpp"
+#line 6121 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 100: /* declaration: type_qualifier SEMICOLON  */
-#line 902 "MachineIndependent/glslang.y"
+  case 102: /* declaration: type_qualifier SEMICOLON  */
+#line 937 "MachineIndependent/glslang.y"
                                {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
         parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
         (yyval.interm.intermNode) = 0;
     }
-#line 5696 "MachineIndependent/glslang_tab.cpp"
+#line 6131 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 101: /* declaration: type_qualifier IDENTIFIER SEMICOLON  */
-#line 907 "MachineIndependent/glslang.y"
+  case 103: /* declaration: type_qualifier IDENTIFIER SEMICOLON  */
+#line 942 "MachineIndependent/glslang.y"
                                           {
         parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
         parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 5706 "MachineIndependent/glslang_tab.cpp"
+#line 6141 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 102: /* declaration: type_qualifier IDENTIFIER identifier_list SEMICOLON  */
-#line 912 "MachineIndependent/glslang.y"
+  case 104: /* declaration: type_qualifier IDENTIFIER identifier_list SEMICOLON  */
+#line 947 "MachineIndependent/glslang.y"
                                                           {
         parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers);
         (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string);
         parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
         (yyval.interm.intermNode) = 0;
     }
-#line 5717 "MachineIndependent/glslang_tab.cpp"
+#line 6152 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 103: /* $@2: %empty  */
-#line 921 "MachineIndependent/glslang.y"
+  case 105: /* $@2: %empty  */
+#line 956 "MachineIndependent/glslang.y"
                                            { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
-#line 5723 "MachineIndependent/glslang_tab.cpp"
+#line 6158 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 104: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE  */
-#line 921 "MachineIndependent/glslang.y"
+  case 106: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE  */
+#line 956 "MachineIndependent/glslang.y"
                                                                                                                           {
         --parseContext.blockNestingLevel;
         parseContext.blockName = (yyvsp[-4].lex).string;
@@ -5733,60 +6168,60 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
     }
-#line 5737 "MachineIndependent/glslang_tab.cpp"
+#line 6172 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 105: /* identifier_list: COMMA IDENTIFIER  */
-#line 932 "MachineIndependent/glslang.y"
+  case 107: /* identifier_list: COMMA IDENTIFIER  */
+#line 967 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5746 "MachineIndependent/glslang_tab.cpp"
+#line 6181 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 106: /* identifier_list: identifier_list COMMA IDENTIFIER  */
-#line 936 "MachineIndependent/glslang.y"
+  case 108: /* identifier_list: identifier_list COMMA IDENTIFIER  */
+#line 971 "MachineIndependent/glslang.y"
                                        {
         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5755 "MachineIndependent/glslang_tab.cpp"
+#line 6190 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 107: /* function_prototype: function_declarator RIGHT_PAREN  */
-#line 943 "MachineIndependent/glslang.y"
+  case 109: /* function_prototype: function_declarator RIGHT_PAREN  */
+#line 978 "MachineIndependent/glslang.y"
                                        {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 5764 "MachineIndependent/glslang_tab.cpp"
+#line 6199 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 108: /* function_prototype: function_declarator RIGHT_PAREN attribute  */
-#line 947 "MachineIndependent/glslang.y"
+  case 110: /* function_prototype: function_declarator RIGHT_PAREN attribute  */
+#line 982 "MachineIndependent/glslang.y"
                                                 {
         (yyval.interm).function = (yyvsp[-2].interm.function);
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes), (yyval.interm).function);
     }
-#line 5775 "MachineIndependent/glslang_tab.cpp"
+#line 6210 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 109: /* function_prototype: attribute function_declarator RIGHT_PAREN  */
-#line 953 "MachineIndependent/glslang.y"
+  case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN  */
+#line 988 "MachineIndependent/glslang.y"
                                                 {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_subgroup_uniform_control_flow, "attribute");
         parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes), (yyval.interm).function);
     }
-#line 5786 "MachineIndependent/glslang_tab.cpp"
+#line 6221 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 110: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute  */
-#line 959 "MachineIndependent/glslang.y"
+  case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute  */
+#line 994 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm).function = (yyvsp[-2].interm.function);
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
@@ -5794,27 +6229,27 @@ yyreduce:
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes), (yyval.interm).function);
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes), (yyval.interm).function);
     }
-#line 5798 "MachineIndependent/glslang_tab.cpp"
+#line 6233 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 111: /* function_declarator: function_header  */
-#line 969 "MachineIndependent/glslang.y"
+  case 113: /* function_declarator: function_header  */
+#line 1004 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5806 "MachineIndependent/glslang_tab.cpp"
+#line 6241 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 112: /* function_declarator: function_header_with_parameters  */
-#line 972 "MachineIndependent/glslang.y"
+  case 114: /* function_declarator: function_header_with_parameters  */
+#line 1007 "MachineIndependent/glslang.y"
                                       {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5814 "MachineIndependent/glslang_tab.cpp"
+#line 6249 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 113: /* function_header_with_parameters: function_header parameter_declaration  */
-#line 979 "MachineIndependent/glslang.y"
+  case 115: /* function_header_with_parameters: function_header parameter_declaration  */
+#line 1014 "MachineIndependent/glslang.y"
                                             {
         // Add the parameter
         (yyval.interm.function) = (yyvsp[-1].interm.function);
@@ -5823,11 +6258,11 @@ yyreduce:
         else
             delete (yyvsp[0].interm).param.type;
     }
-#line 5827 "MachineIndependent/glslang_tab.cpp"
+#line 6262 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 114: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration  */
-#line 987 "MachineIndependent/glslang.y"
+  case 116: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration  */
+#line 1022 "MachineIndependent/glslang.y"
                                                                   {
         //
         // Only first parameter of one-parameter functions can be void
@@ -5845,11 +6280,11 @@ yyreduce:
             (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
         }
     }
-#line 5849 "MachineIndependent/glslang_tab.cpp"
+#line 6284 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 115: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN  */
-#line 1007 "MachineIndependent/glslang.y"
+  case 117: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN  */
+#line 1042 "MachineIndependent/glslang.y"
                                                  {
         if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
             parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
@@ -5869,11 +6304,11 @@ yyreduce:
         function = new TFunction((yyvsp[-1].lex).string, type);
         (yyval.interm.function) = function;
     }
-#line 5873 "MachineIndependent/glslang_tab.cpp"
+#line 6308 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 116: /* parameter_declarator: type_specifier IDENTIFIER  */
-#line 1030 "MachineIndependent/glslang.y"
+  case 118: /* parameter_declarator: type_specifier IDENTIFIER  */
+#line 1065 "MachineIndependent/glslang.y"
                                 {
         if ((yyvsp[-1].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5889,11 +6324,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5893 "MachineIndependent/glslang_tab.cpp"
+#line 6328 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 117: /* parameter_declarator: type_specifier IDENTIFIER array_specifier  */
-#line 1045 "MachineIndependent/glslang.y"
+  case 119: /* parameter_declarator: type_specifier IDENTIFIER array_specifier  */
+#line 1080 "MachineIndependent/glslang.y"
                                                 {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5913,11 +6348,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5917 "MachineIndependent/glslang_tab.cpp"
+#line 6352 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 118: /* parameter_declaration: type_qualifier parameter_declarator  */
-#line 1070 "MachineIndependent/glslang.y"
+  case 120: /* parameter_declaration: type_qualifier parameter_declarator  */
+#line 1105 "MachineIndependent/glslang.y"
                                           {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5929,11 +6364,11 @@ yyreduce:
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
 
     }
-#line 5933 "MachineIndependent/glslang_tab.cpp"
+#line 6368 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 119: /* parameter_declaration: parameter_declarator  */
-#line 1081 "MachineIndependent/glslang.y"
+  case 121: /* parameter_declaration: parameter_declarator  */
+#line 1116 "MachineIndependent/glslang.y"
                            {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5941,11 +6376,11 @@ yyreduce:
         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
     }
-#line 5945 "MachineIndependent/glslang_tab.cpp"
+#line 6380 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 120: /* parameter_declaration: type_qualifier parameter_type_specifier  */
-#line 1091 "MachineIndependent/glslang.y"
+  case 122: /* parameter_declaration: type_qualifier parameter_type_specifier  */
+#line 1126 "MachineIndependent/glslang.y"
                                               {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5956,11 +6391,11 @@ yyreduce:
         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
     }
-#line 5960 "MachineIndependent/glslang_tab.cpp"
+#line 6395 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 121: /* parameter_declaration: parameter_type_specifier  */
-#line 1101 "MachineIndependent/glslang.y"
+  case 123: /* parameter_declaration: parameter_type_specifier  */
+#line 1136 "MachineIndependent/glslang.y"
                                {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5968,68 +6403,68 @@ yyreduce:
         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
     }
-#line 5972 "MachineIndependent/glslang_tab.cpp"
+#line 6407 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 122: /* parameter_type_specifier: type_specifier  */
-#line 1111 "MachineIndependent/glslang.y"
+  case 124: /* parameter_type_specifier: type_specifier  */
+#line 1146 "MachineIndependent/glslang.y"
                      {
         TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
         (yyval.interm).param = param;
         if ((yyvsp[0].interm.type).arraySizes)
             parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
     }
-#line 5983 "MachineIndependent/glslang_tab.cpp"
+#line 6418 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 123: /* init_declarator_list: single_declaration  */
-#line 1120 "MachineIndependent/glslang.y"
+  case 125: /* init_declarator_list: single_declaration  */
+#line 1155 "MachineIndependent/glslang.y"
                          {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 5991 "MachineIndependent/glslang_tab.cpp"
+#line 6426 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 124: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER  */
-#line 1123 "MachineIndependent/glslang.y"
+  case 126: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER  */
+#line 1158 "MachineIndependent/glslang.y"
                                             {
         (yyval.interm) = (yyvsp[-2].interm);
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
     }
-#line 6000 "MachineIndependent/glslang_tab.cpp"
+#line 6435 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 125: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier  */
-#line 1127 "MachineIndependent/glslang.y"
+  case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier  */
+#line 1162 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm) = (yyvsp[-3].interm);
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
     }
-#line 6009 "MachineIndependent/glslang_tab.cpp"
+#line 6444 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 126: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer  */
-#line 1131 "MachineIndependent/glslang.y"
+  case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer  */
+#line 1166 "MachineIndependent/glslang.y"
                                                                               {
         (yyval.interm).type = (yyvsp[-5].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
     }
-#line 6019 "MachineIndependent/glslang_tab.cpp"
+#line 6454 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer  */
-#line 1136 "MachineIndependent/glslang.y"
+  case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer  */
+#line 1171 "MachineIndependent/glslang.y"
                                                               {
         (yyval.interm).type = (yyvsp[-4].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
     }
-#line 6029 "MachineIndependent/glslang_tab.cpp"
+#line 6464 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 128: /* single_declaration: fully_specified_type  */
-#line 1144 "MachineIndependent/glslang.y"
+  case 130: /* single_declaration: fully_specified_type  */
+#line 1179 "MachineIndependent/glslang.y"
                            {
         (yyval.interm).type = (yyvsp[0].interm.type);
         (yyval.interm).intermNode = 0;
@@ -6037,51 +6472,51 @@ yyreduce:
         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
 
     }
-#line 6041 "MachineIndependent/glslang_tab.cpp"
+#line 6476 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 129: /* single_declaration: fully_specified_type IDENTIFIER  */
-#line 1151 "MachineIndependent/glslang.y"
+  case 131: /* single_declaration: fully_specified_type IDENTIFIER  */
+#line 1186 "MachineIndependent/glslang.y"
                                       {
         (yyval.interm).type = (yyvsp[-1].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
     }
-#line 6051 "MachineIndependent/glslang_tab.cpp"
+#line 6486 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 130: /* single_declaration: fully_specified_type IDENTIFIER array_specifier  */
-#line 1156 "MachineIndependent/glslang.y"
+  case 132: /* single_declaration: fully_specified_type IDENTIFIER array_specifier  */
+#line 1191 "MachineIndependent/glslang.y"
                                                       {
         (yyval.interm).type = (yyvsp[-2].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
     }
-#line 6061 "MachineIndependent/glslang_tab.cpp"
+#line 6496 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 131: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer  */
-#line 1161 "MachineIndependent/glslang.y"
+  case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer  */
+#line 1196 "MachineIndependent/glslang.y"
                                                                         {
         (yyval.interm).type = (yyvsp[-4].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
     }
-#line 6071 "MachineIndependent/glslang_tab.cpp"
+#line 6506 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 132: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer  */
-#line 1166 "MachineIndependent/glslang.y"
+  case 134: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer  */
+#line 1201 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm).type = (yyvsp[-3].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
     }
-#line 6081 "MachineIndependent/glslang_tab.cpp"
+#line 6516 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 133: /* fully_specified_type: type_specifier  */
-#line 1175 "MachineIndependent/glslang.y"
+  case 135: /* fully_specified_type: type_specifier  */
+#line 1210 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type) = (yyvsp[0].interm.type);
 
@@ -6092,11 +6527,11 @@ yyreduce:
         }
         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
     }
-#line 6096 "MachineIndependent/glslang_tab.cpp"
+#line 6531 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 134: /* fully_specified_type: type_qualifier type_specifier  */
-#line 1185 "MachineIndependent/glslang.y"
+  case 136: /* fully_specified_type: type_qualifier type_specifier  */
+#line 1220 "MachineIndependent/glslang.y"
                                      {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
         parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
@@ -6121,22 +6556,22 @@ yyreduce:
              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
             (yyval.interm.type).qualifier.smooth = true;
     }
-#line 6125 "MachineIndependent/glslang_tab.cpp"
+#line 6560 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 135: /* invariant_qualifier: INVARIANT  */
-#line 1212 "MachineIndependent/glslang.y"
+  case 137: /* invariant_qualifier: INVARIANT  */
+#line 1247 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
         parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.invariant = true;
     }
-#line 6136 "MachineIndependent/glslang_tab.cpp"
+#line 6571 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 136: /* interpolation_qualifier: SMOOTH  */
-#line 1221 "MachineIndependent/glslang.y"
+  case 138: /* interpolation_qualifier: SMOOTH  */
+#line 1256 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
@@ -6144,11 +6579,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.smooth = true;
     }
-#line 6148 "MachineIndependent/glslang_tab.cpp"
+#line 6583 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 137: /* interpolation_qualifier: FLAT  */
-#line 1228 "MachineIndependent/glslang.y"
+  case 139: /* interpolation_qualifier: FLAT  */
+#line 1263 "MachineIndependent/glslang.y"
            {
         parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
@@ -6156,11 +6591,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.flat = true;
     }
-#line 6160 "MachineIndependent/glslang_tab.cpp"
+#line 6595 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 138: /* interpolation_qualifier: NOPERSPECTIVE  */
-#line 1236 "MachineIndependent/glslang.y"
+  case 140: /* interpolation_qualifier: NOPERSPECTIVE  */
+#line 1271 "MachineIndependent/glslang.y"
                     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
@@ -6168,11 +6603,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nopersp = true;
     }
-#line 6172 "MachineIndependent/glslang_tab.cpp"
+#line 6607 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 139: /* interpolation_qualifier: EXPLICITINTERPAMD  */
-#line 1243 "MachineIndependent/glslang.y"
+  case 141: /* interpolation_qualifier: EXPLICITINTERPAMD  */
+#line 1278 "MachineIndependent/glslang.y"
                         {
         parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
@@ -6180,11 +6615,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.explicitInterp = true;
     }
-#line 6184 "MachineIndependent/glslang_tab.cpp"
+#line 6619 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 140: /* interpolation_qualifier: PERVERTEXNV  */
-#line 1250 "MachineIndependent/glslang.y"
+  case 142: /* interpolation_qualifier: PERVERTEXNV  */
+#line 1285 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
@@ -6193,11 +6628,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.pervertexNV = true;
     }
-#line 6197 "MachineIndependent/glslang_tab.cpp"
+#line 6632 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 141: /* interpolation_qualifier: PERPRIMITIVENV  */
-#line 1258 "MachineIndependent/glslang.y"
+  case 143: /* interpolation_qualifier: PERPRIMITIVENV  */
+#line 1293 "MachineIndependent/glslang.y"
                      {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
@@ -6208,11 +6643,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perPrimitiveNV = true;
     }
-#line 6212 "MachineIndependent/glslang_tab.cpp"
+#line 6647 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 142: /* interpolation_qualifier: PERVIEWNV  */
-#line 1268 "MachineIndependent/glslang.y"
+  case 144: /* interpolation_qualifier: PERVIEWNV  */
+#line 1303 "MachineIndependent/glslang.y"
                 {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
@@ -6220,11 +6655,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perViewNV = true;
     }
-#line 6224 "MachineIndependent/glslang_tab.cpp"
+#line 6659 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 143: /* interpolation_qualifier: PERTASKNV  */
-#line 1275 "MachineIndependent/glslang.y"
+  case 145: /* interpolation_qualifier: PERTASKNV  */
+#line 1310 "MachineIndependent/glslang.y"
                 {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
@@ -6232,84 +6667,84 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perTaskNV = true;
     }
-#line 6236 "MachineIndependent/glslang_tab.cpp"
+#line 6671 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 144: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN  */
-#line 1286 "MachineIndependent/glslang.y"
+  case 146: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN  */
+#line 1321 "MachineIndependent/glslang.y"
                                                              {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
     }
-#line 6244 "MachineIndependent/glslang_tab.cpp"
+#line 6679 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 145: /* layout_qualifier_id_list: layout_qualifier_id  */
-#line 1292 "MachineIndependent/glslang.y"
+  case 147: /* layout_qualifier_id_list: layout_qualifier_id  */
+#line 1327 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6252 "MachineIndependent/glslang_tab.cpp"
+#line 6687 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 146: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id  */
-#line 1295 "MachineIndependent/glslang.y"
+  case 148: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id  */
+#line 1330 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.type) = (yyvsp[-2].interm.type);
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 6262 "MachineIndependent/glslang_tab.cpp"
+#line 6697 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 147: /* layout_qualifier_id: IDENTIFIER  */
-#line 1302 "MachineIndependent/glslang.y"
+  case 149: /* layout_qualifier_id: IDENTIFIER  */
+#line 1337 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
     }
-#line 6271 "MachineIndependent/glslang_tab.cpp"
+#line 6706 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 148: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression  */
-#line 1306 "MachineIndependent/glslang.y"
+  case 150: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression  */
+#line 1341 "MachineIndependent/glslang.y"
                                            {
         (yyval.interm.type).init((yyvsp[-2].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
     }
-#line 6280 "MachineIndependent/glslang_tab.cpp"
+#line 6715 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 149: /* layout_qualifier_id: SHARED  */
-#line 1310 "MachineIndependent/glslang.y"
+  case 151: /* layout_qualifier_id: SHARED  */
+#line 1345 "MachineIndependent/glslang.y"
              { // because "shared" is both an identifier and a keyword
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         TString strShared("shared");
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
     }
-#line 6290 "MachineIndependent/glslang_tab.cpp"
+#line 6725 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 150: /* precise_qualifier: PRECISE  */
-#line 1319 "MachineIndependent/glslang.y"
+  case 152: /* precise_qualifier: PRECISE  */
+#line 1354 "MachineIndependent/glslang.y"
               {
         parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.noContraction = true;
     }
-#line 6301 "MachineIndependent/glslang_tab.cpp"
+#line 6736 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 151: /* type_qualifier: single_type_qualifier  */
-#line 1329 "MachineIndependent/glslang.y"
+  case 153: /* type_qualifier: single_type_qualifier  */
+#line 1364 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6309 "MachineIndependent/glslang_tab.cpp"
+#line 6744 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 152: /* type_qualifier: type_qualifier single_type_qualifier  */
-#line 1332 "MachineIndependent/glslang.y"
+  case 154: /* type_qualifier: type_qualifier single_type_qualifier  */
+#line 1367 "MachineIndependent/glslang.y"
                                            {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         if ((yyval.interm.type).basicType == EbtVoid)
@@ -6318,112 +6753,151 @@ yyreduce:
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 6322 "MachineIndependent/glslang_tab.cpp"
+#line 6757 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 153: /* single_type_qualifier: storage_qualifier  */
-#line 1343 "MachineIndependent/glslang.y"
+  case 155: /* single_type_qualifier: storage_qualifier  */
+#line 1378 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6330 "MachineIndependent/glslang_tab.cpp"
+#line 6765 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 154: /* single_type_qualifier: layout_qualifier  */
-#line 1346 "MachineIndependent/glslang.y"
+  case 156: /* single_type_qualifier: layout_qualifier  */
+#line 1381 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6338 "MachineIndependent/glslang_tab.cpp"
+#line 6773 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 155: /* single_type_qualifier: precision_qualifier  */
-#line 1349 "MachineIndependent/glslang.y"
+  case 157: /* single_type_qualifier: precision_qualifier  */
+#line 1384 "MachineIndependent/glslang.y"
                           {
         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6347 "MachineIndependent/glslang_tab.cpp"
+#line 6782 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 156: /* single_type_qualifier: interpolation_qualifier  */
-#line 1353 "MachineIndependent/glslang.y"
+  case 158: /* single_type_qualifier: interpolation_qualifier  */
+#line 1388 "MachineIndependent/glslang.y"
                               {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6356 "MachineIndependent/glslang_tab.cpp"
+#line 6791 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 157: /* single_type_qualifier: invariant_qualifier  */
-#line 1357 "MachineIndependent/glslang.y"
+  case 159: /* single_type_qualifier: invariant_qualifier  */
+#line 1392 "MachineIndependent/glslang.y"
                           {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6365 "MachineIndependent/glslang_tab.cpp"
+#line 6800 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 158: /* single_type_qualifier: precise_qualifier  */
-#line 1362 "MachineIndependent/glslang.y"
+  case 160: /* single_type_qualifier: precise_qualifier  */
+#line 1397 "MachineIndependent/glslang.y"
                         {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6374 "MachineIndependent/glslang_tab.cpp"
+#line 6809 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 159: /* single_type_qualifier: non_uniform_qualifier  */
-#line 1366 "MachineIndependent/glslang.y"
+  case 161: /* single_type_qualifier: non_uniform_qualifier  */
+#line 1401 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 6382 "MachineIndependent/glslang_tab.cpp"
+#line 6817 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 162: /* single_type_qualifier: spirv_storage_class_qualifier  */
+#line 1404 "MachineIndependent/glslang.y"
+                                    {
+        parseContext.globalCheck((yyvsp[0].interm.type).loc, "spirv_storage_class");
+        parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier");
+        (yyval.interm.type) = (yyvsp[0].interm.type);
+    }
+#line 6827 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 163: /* single_type_qualifier: spirv_decorate_qualifier  */
+#line 1409 "MachineIndependent/glslang.y"
+                               {
+        parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier");
+        (yyval.interm.type) = (yyvsp[0].interm.type);
+    }
+#line 6836 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 164: /* single_type_qualifier: SPIRV_BY_REFERENCE  */
+#line 1413 "MachineIndependent/glslang.y"
+                         {
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference");
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvByReference();
+    }
+#line 6846 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 165: /* single_type_qualifier: SPIRV_LITERAL  */
+#line 1418 "MachineIndependent/glslang.y"
+                    {
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal");
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvLiteral();
+    }
+#line 6856 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 160: /* storage_qualifier: CONST  */
-#line 1373 "MachineIndependent/glslang.y"
+  case 166: /* storage_qualifier: CONST  */
+#line 1427 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
     }
-#line 6391 "MachineIndependent/glslang_tab.cpp"
+#line 6865 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 161: /* storage_qualifier: INOUT  */
-#line 1377 "MachineIndependent/glslang.y"
+  case 167: /* storage_qualifier: INOUT  */
+#line 1431 "MachineIndependent/glslang.y"
             {
         parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqInOut;
     }
-#line 6401 "MachineIndependent/glslang_tab.cpp"
+#line 6875 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 162: /* storage_qualifier: IN  */
-#line 1382 "MachineIndependent/glslang.y"
+  case 168: /* storage_qualifier: IN  */
+#line 1436 "MachineIndependent/glslang.y"
          {
         parseContext.globalCheck((yyvsp[0].lex).loc, "in");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqIn;
     }
-#line 6412 "MachineIndependent/glslang_tab.cpp"
+#line 6886 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 163: /* storage_qualifier: OUT  */
-#line 1388 "MachineIndependent/glslang.y"
+  case 169: /* storage_qualifier: OUT  */
+#line 1442 "MachineIndependent/glslang.y"
           {
         parseContext.globalCheck((yyvsp[0].lex).loc, "out");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqOut;
     }
-#line 6423 "MachineIndependent/glslang_tab.cpp"
+#line 6897 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 164: /* storage_qualifier: CENTROID  */
-#line 1394 "MachineIndependent/glslang.y"
+  case 170: /* storage_qualifier: CENTROID  */
+#line 1448 "MachineIndependent/glslang.y"
                {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
@@ -6431,21 +6905,21 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.centroid = true;
     }
-#line 6435 "MachineIndependent/glslang_tab.cpp"
+#line 6909 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 165: /* storage_qualifier: UNIFORM  */
-#line 1401 "MachineIndependent/glslang.y"
+  case 171: /* storage_qualifier: UNIFORM  */
+#line 1455 "MachineIndependent/glslang.y"
               {
         parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqUniform;
     }
-#line 6445 "MachineIndependent/glslang_tab.cpp"
+#line 6919 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 166: /* storage_qualifier: SHARED  */
-#line 1406 "MachineIndependent/glslang.y"
+  case 172: /* storage_qualifier: SHARED  */
+#line 1460 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
@@ -6454,21 +6928,21 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqShared;
     }
-#line 6458 "MachineIndependent/glslang_tab.cpp"
+#line 6932 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 167: /* storage_qualifier: BUFFER  */
-#line 1414 "MachineIndependent/glslang.y"
+  case 173: /* storage_qualifier: BUFFER  */
+#line 1468 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqBuffer;
     }
-#line 6468 "MachineIndependent/glslang_tab.cpp"
+#line 6942 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 168: /* storage_qualifier: ATTRIBUTE  */
-#line 1420 "MachineIndependent/glslang.y"
+  case 174: /* storage_qualifier: ATTRIBUTE  */
+#line 1474 "MachineIndependent/glslang.y"
                 {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
@@ -6481,11 +6955,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 6485 "MachineIndependent/glslang_tab.cpp"
+#line 6959 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 169: /* storage_qualifier: VARYING  */
-#line 1432 "MachineIndependent/glslang.y"
+  case 175: /* storage_qualifier: VARYING  */
+#line 1486 "MachineIndependent/glslang.y"
               {
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
@@ -6500,32 +6974,32 @@ yyreduce:
         else
             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 6504 "MachineIndependent/glslang_tab.cpp"
+#line 6978 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 170: /* storage_qualifier: PATCH  */
-#line 1446 "MachineIndependent/glslang.y"
+  case 176: /* storage_qualifier: PATCH  */
+#line 1500 "MachineIndependent/glslang.y"
             {
         parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.patch = true;
     }
-#line 6515 "MachineIndependent/glslang_tab.cpp"
+#line 6989 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 171: /* storage_qualifier: SAMPLE  */
-#line 1452 "MachineIndependent/glslang.y"
+  case 177: /* storage_qualifier: SAMPLE  */
+#line 1506 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.sample = true;
     }
-#line 6525 "MachineIndependent/glslang_tab.cpp"
+#line 6999 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 172: /* storage_qualifier: HITATTRNV  */
-#line 1457 "MachineIndependent/glslang.y"
+  case 178: /* storage_qualifier: HITATTRNV  */
+#line 1511 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -6534,11 +7008,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 6538 "MachineIndependent/glslang_tab.cpp"
+#line 7012 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 173: /* storage_qualifier: HITATTREXT  */
-#line 1465 "MachineIndependent/glslang.y"
+  case 179: /* storage_qualifier: HITATTREXT  */
+#line 1519 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -6547,11 +7021,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 6551 "MachineIndependent/glslang_tab.cpp"
+#line 7025 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 174: /* storage_qualifier: PAYLOADNV  */
-#line 1473 "MachineIndependent/glslang.y"
+  case 180: /* storage_qualifier: PAYLOADNV  */
+#line 1527 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -6560,11 +7034,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 6564 "MachineIndependent/glslang_tab.cpp"
+#line 7038 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 175: /* storage_qualifier: PAYLOADEXT  */
-#line 1481 "MachineIndependent/glslang.y"
+  case 181: /* storage_qualifier: PAYLOADEXT  */
+#line 1535 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -6573,11 +7047,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 6577 "MachineIndependent/glslang_tab.cpp"
+#line 7051 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 176: /* storage_qualifier: PAYLOADINNV  */
-#line 1489 "MachineIndependent/glslang.y"
+  case 182: /* storage_qualifier: PAYLOADINNV  */
+#line 1543 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -6586,11 +7060,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 6590 "MachineIndependent/glslang_tab.cpp"
+#line 7064 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 177: /* storage_qualifier: PAYLOADINEXT  */
-#line 1497 "MachineIndependent/glslang.y"
+  case 183: /* storage_qualifier: PAYLOADINEXT  */
+#line 1551 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -6599,11 +7073,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 6603 "MachineIndependent/glslang_tab.cpp"
+#line 7077 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 178: /* storage_qualifier: CALLDATANV  */
-#line 1505 "MachineIndependent/glslang.y"
+  case 184: /* storage_qualifier: CALLDATANV  */
+#line 1559 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -6612,11 +7086,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 6616 "MachineIndependent/glslang_tab.cpp"
+#line 7090 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 179: /* storage_qualifier: CALLDATAEXT  */
-#line 1513 "MachineIndependent/glslang.y"
+  case 185: /* storage_qualifier: CALLDATAEXT  */
+#line 1567 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -6625,11 +7099,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 6629 "MachineIndependent/glslang_tab.cpp"
+#line 7103 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 180: /* storage_qualifier: CALLDATAINNV  */
-#line 1521 "MachineIndependent/glslang.y"
+  case 186: /* storage_qualifier: CALLDATAINNV  */
+#line 1575 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV");
@@ -6637,11 +7111,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 6641 "MachineIndependent/glslang_tab.cpp"
+#line 7115 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 181: /* storage_qualifier: CALLDATAINEXT  */
-#line 1528 "MachineIndependent/glslang.y"
+  case 187: /* storage_qualifier: CALLDATAINEXT  */
+#line 1582 "MachineIndependent/glslang.y"
                     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT");
@@ -6649,175 +7123,175 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 6653 "MachineIndependent/glslang_tab.cpp"
+#line 7127 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 182: /* storage_qualifier: COHERENT  */
-#line 1535 "MachineIndependent/glslang.y"
+  case 188: /* storage_qualifier: COHERENT  */
+#line 1589 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
-#line 6662 "MachineIndependent/glslang_tab.cpp"
+#line 7136 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 183: /* storage_qualifier: DEVICECOHERENT  */
-#line 1539 "MachineIndependent/glslang.y"
+  case 189: /* storage_qualifier: DEVICECOHERENT  */
+#line 1593 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
         (yyval.interm.type).qualifier.devicecoherent = true;
     }
-#line 6672 "MachineIndependent/glslang_tab.cpp"
+#line 7146 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 184: /* storage_qualifier: QUEUEFAMILYCOHERENT  */
-#line 1544 "MachineIndependent/glslang.y"
+  case 190: /* storage_qualifier: QUEUEFAMILYCOHERENT  */
+#line 1598 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
         (yyval.interm.type).qualifier.queuefamilycoherent = true;
     }
-#line 6682 "MachineIndependent/glslang_tab.cpp"
+#line 7156 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 185: /* storage_qualifier: WORKGROUPCOHERENT  */
-#line 1549 "MachineIndependent/glslang.y"
+  case 191: /* storage_qualifier: WORKGROUPCOHERENT  */
+#line 1603 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
         (yyval.interm.type).qualifier.workgroupcoherent = true;
     }
-#line 6692 "MachineIndependent/glslang_tab.cpp"
+#line 7166 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 186: /* storage_qualifier: SUBGROUPCOHERENT  */
-#line 1554 "MachineIndependent/glslang.y"
+  case 192: /* storage_qualifier: SUBGROUPCOHERENT  */
+#line 1608 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
         (yyval.interm.type).qualifier.subgroupcoherent = true;
     }
-#line 6702 "MachineIndependent/glslang_tab.cpp"
+#line 7176 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 187: /* storage_qualifier: NONPRIVATE  */
-#line 1559 "MachineIndependent/glslang.y"
+  case 193: /* storage_qualifier: NONPRIVATE  */
+#line 1613 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
         (yyval.interm.type).qualifier.nonprivate = true;
     }
-#line 6712 "MachineIndependent/glslang_tab.cpp"
+#line 7186 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 188: /* storage_qualifier: SHADERCALLCOHERENT  */
-#line 1564 "MachineIndependent/glslang.y"
+  case 194: /* storage_qualifier: SHADERCALLCOHERENT  */
+#line 1618 "MachineIndependent/glslang.y"
                          {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent");
         (yyval.interm.type).qualifier.shadercallcoherent = true;
     }
-#line 6722 "MachineIndependent/glslang_tab.cpp"
+#line 7196 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 189: /* storage_qualifier: VOLATILE  */
-#line 1569 "MachineIndependent/glslang.y"
+  case 195: /* storage_qualifier: VOLATILE  */
+#line 1623 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.volatil = true;
     }
-#line 6731 "MachineIndependent/glslang_tab.cpp"
+#line 7205 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 190: /* storage_qualifier: RESTRICT  */
-#line 1573 "MachineIndependent/glslang.y"
+  case 196: /* storage_qualifier: RESTRICT  */
+#line 1627 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.restrict = true;
     }
-#line 6740 "MachineIndependent/glslang_tab.cpp"
+#line 7214 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 191: /* storage_qualifier: READONLY  */
-#line 1577 "MachineIndependent/glslang.y"
+  case 197: /* storage_qualifier: READONLY  */
+#line 1631 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.readonly = true;
     }
-#line 6749 "MachineIndependent/glslang_tab.cpp"
+#line 7223 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 192: /* storage_qualifier: WRITEONLY  */
-#line 1581 "MachineIndependent/glslang.y"
+  case 198: /* storage_qualifier: WRITEONLY  */
+#line 1635 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.writeonly = true;
     }
-#line 6758 "MachineIndependent/glslang_tab.cpp"
+#line 7232 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 193: /* storage_qualifier: SUBROUTINE  */
-#line 1585 "MachineIndependent/glslang.y"
+  case 199: /* storage_qualifier: SUBROUTINE  */
+#line 1639 "MachineIndependent/glslang.y"
                  {
         parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
     }
-#line 6769 "MachineIndependent/glslang_tab.cpp"
+#line 7243 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 194: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN  */
-#line 1591 "MachineIndependent/glslang.y"
+  case 200: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN  */
+#line 1645 "MachineIndependent/glslang.y"
                                                        {
         parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[-3].lex).loc);
     }
-#line 6780 "MachineIndependent/glslang_tab.cpp"
+#line 7254 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 195: /* non_uniform_qualifier: NONUNIFORM  */
-#line 1602 "MachineIndependent/glslang.y"
+  case 201: /* non_uniform_qualifier: NONUNIFORM  */
+#line 1656 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nonUniform = true;
     }
-#line 6789 "MachineIndependent/glslang_tab.cpp"
+#line 7263 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 196: /* type_name_list: IDENTIFIER  */
-#line 1609 "MachineIndependent/glslang.y"
+  case 202: /* type_name_list: IDENTIFIER  */
+#line 1663 "MachineIndependent/glslang.y"
                  {
         // TODO
     }
-#line 6797 "MachineIndependent/glslang_tab.cpp"
+#line 7271 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 197: /* type_name_list: type_name_list COMMA IDENTIFIER  */
-#line 1612 "MachineIndependent/glslang.y"
+  case 203: /* type_name_list: type_name_list COMMA IDENTIFIER  */
+#line 1666 "MachineIndependent/glslang.y"
                                       {
         // TODO: 4.0 semantics: subroutines
         // 1) make sure each identifier is a type declared earlier with SUBROUTINE
         // 2) save all of the identifiers for future comparison with the declared function
     }
-#line 6807 "MachineIndependent/glslang_tab.cpp"
+#line 7281 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 198: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt  */
-#line 1621 "MachineIndependent/glslang.y"
+  case 204: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt  */
+#line 1675 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
         (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters);
     }
-#line 6817 "MachineIndependent/glslang_tab.cpp"
+#line 7291 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 199: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier  */
-#line 1626 "MachineIndependent/glslang.y"
+  case 205: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier  */
+#line 1680 "MachineIndependent/glslang.y"
                                                                            {
         parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
         (yyval.interm.type) = (yyvsp[-2].interm.type);
@@ -6825,21 +7299,21 @@ yyreduce:
         (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters);
         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
     }
-#line 6829 "MachineIndependent/glslang_tab.cpp"
+#line 7303 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 200: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET  */
-#line 1636 "MachineIndependent/glslang.y"
+  case 206: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET  */
+#line 1690 "MachineIndependent/glslang.y"
                                  {
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 6839 "MachineIndependent/glslang_tab.cpp"
+#line 7313 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 201: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
-#line 1641 "MachineIndependent/glslang.y"
+  case 207: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
+#line 1695 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm).loc = (yyvsp[-2].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -6848,20 +7322,20 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 6852 "MachineIndependent/glslang_tab.cpp"
+#line 7326 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 202: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET  */
-#line 1649 "MachineIndependent/glslang.y"
+  case 208: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET  */
+#line 1703 "MachineIndependent/glslang.y"
                                                  {
         (yyval.interm) = (yyvsp[-2].interm);
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 6861 "MachineIndependent/glslang_tab.cpp"
+#line 7335 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 203: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
-#line 1653 "MachineIndependent/glslang.y"
+  case 209: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
+#line 1707 "MachineIndependent/glslang.y"
                                                                         {
         (yyval.interm) = (yyvsp[-3].interm);
 
@@ -6869,35 +7343,35 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 6873 "MachineIndependent/glslang_tab.cpp"
+#line 7347 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 204: /* type_parameter_specifier_opt: type_parameter_specifier  */
-#line 1663 "MachineIndependent/glslang.y"
+  case 210: /* type_parameter_specifier_opt: type_parameter_specifier  */
+#line 1717 "MachineIndependent/glslang.y"
                                {
         (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
     }
-#line 6881 "MachineIndependent/glslang_tab.cpp"
+#line 7355 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 205: /* type_parameter_specifier_opt: %empty  */
-#line 1666 "MachineIndependent/glslang.y"
+  case 211: /* type_parameter_specifier_opt: %empty  */
+#line 1720 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.typeParameters) = 0;
     }
-#line 6889 "MachineIndependent/glslang_tab.cpp"
+#line 7363 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 206: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE  */
-#line 1672 "MachineIndependent/glslang.y"
+  case 212: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE  */
+#line 1726 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
     }
-#line 6897 "MachineIndependent/glslang_tab.cpp"
+#line 7371 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 207: /* type_parameter_specifier_list: unary_expression  */
-#line 1678 "MachineIndependent/glslang.y"
+  case 213: /* type_parameter_specifier_list: unary_expression  */
+#line 1732 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.typeParameters) = new TArraySizes;
 
@@ -6905,11 +7379,11 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
         (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6909 "MachineIndependent/glslang_tab.cpp"
+#line 7383 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 208: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression  */
-#line 1685 "MachineIndependent/glslang.y"
+  case 214: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression  */
+#line 1739 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
 
@@ -6917,300 +7391,300 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
         (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6921 "MachineIndependent/glslang_tab.cpp"
+#line 7395 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 209: /* type_specifier_nonarray: VOID  */
-#line 1695 "MachineIndependent/glslang.y"
+  case 215: /* type_specifier_nonarray: VOID  */
+#line 1749 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
-#line 6930 "MachineIndependent/glslang_tab.cpp"
+#line 7404 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 210: /* type_specifier_nonarray: FLOAT  */
-#line 1699 "MachineIndependent/glslang.y"
+  case 216: /* type_specifier_nonarray: FLOAT  */
+#line 1753 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 6939 "MachineIndependent/glslang_tab.cpp"
+#line 7413 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 211: /* type_specifier_nonarray: INT  */
-#line 1703 "MachineIndependent/glslang.y"
+  case 217: /* type_specifier_nonarray: INT  */
+#line 1757 "MachineIndependent/glslang.y"
           {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 6948 "MachineIndependent/glslang_tab.cpp"
+#line 7422 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 212: /* type_specifier_nonarray: UINT  */
-#line 1707 "MachineIndependent/glslang.y"
+  case 218: /* type_specifier_nonarray: UINT  */
+#line 1761 "MachineIndependent/glslang.y"
            {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 6958 "MachineIndependent/glslang_tab.cpp"
+#line 7432 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 213: /* type_specifier_nonarray: BOOL  */
-#line 1712 "MachineIndependent/glslang.y"
+  case 219: /* type_specifier_nonarray: BOOL  */
+#line 1766 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
     }
-#line 6967 "MachineIndependent/glslang_tab.cpp"
+#line 7441 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 214: /* type_specifier_nonarray: VEC2  */
-#line 1716 "MachineIndependent/glslang.y"
+  case 220: /* type_specifier_nonarray: VEC2  */
+#line 1770 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 6977 "MachineIndependent/glslang_tab.cpp"
+#line 7451 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 215: /* type_specifier_nonarray: VEC3  */
-#line 1721 "MachineIndependent/glslang.y"
+  case 221: /* type_specifier_nonarray: VEC3  */
+#line 1775 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 6987 "MachineIndependent/glslang_tab.cpp"
+#line 7461 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 216: /* type_specifier_nonarray: VEC4  */
-#line 1726 "MachineIndependent/glslang.y"
+  case 222: /* type_specifier_nonarray: VEC4  */
+#line 1780 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 6997 "MachineIndependent/glslang_tab.cpp"
+#line 7471 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 217: /* type_specifier_nonarray: BVEC2  */
-#line 1731 "MachineIndependent/glslang.y"
+  case 223: /* type_specifier_nonarray: BVEC2  */
+#line 1785 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(2);
     }
-#line 7007 "MachineIndependent/glslang_tab.cpp"
+#line 7481 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 218: /* type_specifier_nonarray: BVEC3  */
-#line 1736 "MachineIndependent/glslang.y"
+  case 224: /* type_specifier_nonarray: BVEC3  */
+#line 1790 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(3);
     }
-#line 7017 "MachineIndependent/glslang_tab.cpp"
+#line 7491 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 219: /* type_specifier_nonarray: BVEC4  */
-#line 1741 "MachineIndependent/glslang.y"
+  case 225: /* type_specifier_nonarray: BVEC4  */
+#line 1795 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(4);
     }
-#line 7027 "MachineIndependent/glslang_tab.cpp"
+#line 7501 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 220: /* type_specifier_nonarray: IVEC2  */
-#line 1746 "MachineIndependent/glslang.y"
+  case 226: /* type_specifier_nonarray: IVEC2  */
+#line 1800 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 7037 "MachineIndependent/glslang_tab.cpp"
+#line 7511 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 221: /* type_specifier_nonarray: IVEC3  */
-#line 1751 "MachineIndependent/glslang.y"
+  case 227: /* type_specifier_nonarray: IVEC3  */
+#line 1805 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 7047 "MachineIndependent/glslang_tab.cpp"
+#line 7521 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 222: /* type_specifier_nonarray: IVEC4  */
-#line 1756 "MachineIndependent/glslang.y"
+  case 228: /* type_specifier_nonarray: IVEC4  */
+#line 1810 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 7057 "MachineIndependent/glslang_tab.cpp"
+#line 7531 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 223: /* type_specifier_nonarray: UVEC2  */
-#line 1761 "MachineIndependent/glslang.y"
+  case 229: /* type_specifier_nonarray: UVEC2  */
+#line 1815 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 7068 "MachineIndependent/glslang_tab.cpp"
+#line 7542 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 224: /* type_specifier_nonarray: UVEC3  */
-#line 1767 "MachineIndependent/glslang.y"
+  case 230: /* type_specifier_nonarray: UVEC3  */
+#line 1821 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 7079 "MachineIndependent/glslang_tab.cpp"
+#line 7553 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 225: /* type_specifier_nonarray: UVEC4  */
-#line 1773 "MachineIndependent/glslang.y"
+  case 231: /* type_specifier_nonarray: UVEC4  */
+#line 1827 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 7090 "MachineIndependent/glslang_tab.cpp"
+#line 7564 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 226: /* type_specifier_nonarray: MAT2  */
-#line 1779 "MachineIndependent/glslang.y"
+  case 232: /* type_specifier_nonarray: MAT2  */
+#line 1833 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7100 "MachineIndependent/glslang_tab.cpp"
+#line 7574 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 227: /* type_specifier_nonarray: MAT3  */
-#line 1784 "MachineIndependent/glslang.y"
+  case 233: /* type_specifier_nonarray: MAT3  */
+#line 1838 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7110 "MachineIndependent/glslang_tab.cpp"
+#line 7584 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 228: /* type_specifier_nonarray: MAT4  */
-#line 1789 "MachineIndependent/glslang.y"
+  case 234: /* type_specifier_nonarray: MAT4  */
+#line 1843 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7120 "MachineIndependent/glslang_tab.cpp"
+#line 7594 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 229: /* type_specifier_nonarray: MAT2X2  */
-#line 1794 "MachineIndependent/glslang.y"
+  case 235: /* type_specifier_nonarray: MAT2X2  */
+#line 1848 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7130 "MachineIndependent/glslang_tab.cpp"
+#line 7604 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 230: /* type_specifier_nonarray: MAT2X3  */
-#line 1799 "MachineIndependent/glslang.y"
+  case 236: /* type_specifier_nonarray: MAT2X3  */
+#line 1853 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7140 "MachineIndependent/glslang_tab.cpp"
+#line 7614 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 231: /* type_specifier_nonarray: MAT2X4  */
-#line 1804 "MachineIndependent/glslang.y"
+  case 237: /* type_specifier_nonarray: MAT2X4  */
+#line 1858 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7150 "MachineIndependent/glslang_tab.cpp"
+#line 7624 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 232: /* type_specifier_nonarray: MAT3X2  */
-#line 1809 "MachineIndependent/glslang.y"
+  case 238: /* type_specifier_nonarray: MAT3X2  */
+#line 1863 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7160 "MachineIndependent/glslang_tab.cpp"
+#line 7634 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 233: /* type_specifier_nonarray: MAT3X3  */
-#line 1814 "MachineIndependent/glslang.y"
+  case 239: /* type_specifier_nonarray: MAT3X3  */
+#line 1868 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7170 "MachineIndependent/glslang_tab.cpp"
+#line 7644 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 234: /* type_specifier_nonarray: MAT3X4  */
-#line 1819 "MachineIndependent/glslang.y"
+  case 240: /* type_specifier_nonarray: MAT3X4  */
+#line 1873 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7180 "MachineIndependent/glslang_tab.cpp"
+#line 7654 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 235: /* type_specifier_nonarray: MAT4X2  */
-#line 1824 "MachineIndependent/glslang.y"
+  case 241: /* type_specifier_nonarray: MAT4X2  */
+#line 1878 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7190 "MachineIndependent/glslang_tab.cpp"
+#line 7664 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 236: /* type_specifier_nonarray: MAT4X3  */
-#line 1829 "MachineIndependent/glslang.y"
+  case 242: /* type_specifier_nonarray: MAT4X3  */
+#line 1883 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7200 "MachineIndependent/glslang_tab.cpp"
+#line 7674 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 237: /* type_specifier_nonarray: MAT4X4  */
-#line 1834 "MachineIndependent/glslang.y"
+  case 243: /* type_specifier_nonarray: MAT4X4  */
+#line 1888 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7210 "MachineIndependent/glslang_tab.cpp"
+#line 7684 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 238: /* type_specifier_nonarray: DOUBLE  */
-#line 1840 "MachineIndependent/glslang.y"
+  case 244: /* type_specifier_nonarray: DOUBLE  */
+#line 1894 "MachineIndependent/glslang.y"
              {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7218,121 +7692,121 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 7222 "MachineIndependent/glslang_tab.cpp"
+#line 7696 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 239: /* type_specifier_nonarray: FLOAT16_T  */
-#line 1847 "MachineIndependent/glslang.y"
+  case 245: /* type_specifier_nonarray: FLOAT16_T  */
+#line 1901 "MachineIndependent/glslang.y"
                 {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
     }
-#line 7232 "MachineIndependent/glslang_tab.cpp"
+#line 7706 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 240: /* type_specifier_nonarray: FLOAT32_T  */
-#line 1852 "MachineIndependent/glslang.y"
+  case 246: /* type_specifier_nonarray: FLOAT32_T  */
+#line 1906 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 7242 "MachineIndependent/glslang_tab.cpp"
+#line 7716 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 241: /* type_specifier_nonarray: FLOAT64_T  */
-#line 1857 "MachineIndependent/glslang.y"
+  case 247: /* type_specifier_nonarray: FLOAT64_T  */
+#line 1911 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 7252 "MachineIndependent/glslang_tab.cpp"
+#line 7726 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 242: /* type_specifier_nonarray: INT8_T  */
-#line 1862 "MachineIndependent/glslang.y"
+  case 248: /* type_specifier_nonarray: INT8_T  */
+#line 1916 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
     }
-#line 7262 "MachineIndependent/glslang_tab.cpp"
+#line 7736 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 243: /* type_specifier_nonarray: UINT8_T  */
-#line 1867 "MachineIndependent/glslang.y"
+  case 249: /* type_specifier_nonarray: UINT8_T  */
+#line 1921 "MachineIndependent/glslang.y"
               {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
     }
-#line 7272 "MachineIndependent/glslang_tab.cpp"
+#line 7746 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 244: /* type_specifier_nonarray: INT16_T  */
-#line 1872 "MachineIndependent/glslang.y"
+  case 250: /* type_specifier_nonarray: INT16_T  */
+#line 1926 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
     }
-#line 7282 "MachineIndependent/glslang_tab.cpp"
+#line 7756 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 245: /* type_specifier_nonarray: UINT16_T  */
-#line 1877 "MachineIndependent/glslang.y"
+  case 251: /* type_specifier_nonarray: UINT16_T  */
+#line 1931 "MachineIndependent/glslang.y"
                {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
     }
-#line 7292 "MachineIndependent/glslang_tab.cpp"
+#line 7766 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 246: /* type_specifier_nonarray: INT32_T  */
-#line 1882 "MachineIndependent/glslang.y"
+  case 252: /* type_specifier_nonarray: INT32_T  */
+#line 1936 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 7302 "MachineIndependent/glslang_tab.cpp"
+#line 7776 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 247: /* type_specifier_nonarray: UINT32_T  */
-#line 1887 "MachineIndependent/glslang.y"
+  case 253: /* type_specifier_nonarray: UINT32_T  */
+#line 1941 "MachineIndependent/glslang.y"
                {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 7312 "MachineIndependent/glslang_tab.cpp"
+#line 7786 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 248: /* type_specifier_nonarray: INT64_T  */
-#line 1892 "MachineIndependent/glslang.y"
+  case 254: /* type_specifier_nonarray: INT64_T  */
+#line 1946 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
     }
-#line 7322 "MachineIndependent/glslang_tab.cpp"
+#line 7796 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 249: /* type_specifier_nonarray: UINT64_T  */
-#line 1897 "MachineIndependent/glslang.y"
+  case 255: /* type_specifier_nonarray: UINT64_T  */
+#line 1951 "MachineIndependent/glslang.y"
                {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
     }
-#line 7332 "MachineIndependent/glslang_tab.cpp"
+#line 7806 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 250: /* type_specifier_nonarray: DVEC2  */
-#line 1902 "MachineIndependent/glslang.y"
+  case 256: /* type_specifier_nonarray: DVEC2  */
+#line 1956 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7341,11 +7815,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 7345 "MachineIndependent/glslang_tab.cpp"
+#line 7819 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 251: /* type_specifier_nonarray: DVEC3  */
-#line 1910 "MachineIndependent/glslang.y"
+  case 257: /* type_specifier_nonarray: DVEC3  */
+#line 1964 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7354,11 +7828,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 7358 "MachineIndependent/glslang_tab.cpp"
+#line 7832 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 252: /* type_specifier_nonarray: DVEC4  */
-#line 1918 "MachineIndependent/glslang.y"
+  case 258: /* type_specifier_nonarray: DVEC4  */
+#line 1972 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7367,374 +7841,374 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 7371 "MachineIndependent/glslang_tab.cpp"
+#line 7845 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 253: /* type_specifier_nonarray: F16VEC2  */
-#line 1926 "MachineIndependent/glslang.y"
+  case 259: /* type_specifier_nonarray: F16VEC2  */
+#line 1980 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(2);
     }
-#line 7382 "MachineIndependent/glslang_tab.cpp"
+#line 7856 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 254: /* type_specifier_nonarray: F16VEC3  */
-#line 1932 "MachineIndependent/glslang.y"
+  case 260: /* type_specifier_nonarray: F16VEC3  */
+#line 1986 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(3);
     }
-#line 7393 "MachineIndependent/glslang_tab.cpp"
+#line 7867 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 255: /* type_specifier_nonarray: F16VEC4  */
-#line 1938 "MachineIndependent/glslang.y"
+  case 261: /* type_specifier_nonarray: F16VEC4  */
+#line 1992 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(4);
     }
-#line 7404 "MachineIndependent/glslang_tab.cpp"
+#line 7878 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 256: /* type_specifier_nonarray: F32VEC2  */
-#line 1944 "MachineIndependent/glslang.y"
+  case 262: /* type_specifier_nonarray: F32VEC2  */
+#line 1998 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 7415 "MachineIndependent/glslang_tab.cpp"
+#line 7889 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 257: /* type_specifier_nonarray: F32VEC3  */
-#line 1950 "MachineIndependent/glslang.y"
+  case 263: /* type_specifier_nonarray: F32VEC3  */
+#line 2004 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 7426 "MachineIndependent/glslang_tab.cpp"
+#line 7900 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 258: /* type_specifier_nonarray: F32VEC4  */
-#line 1956 "MachineIndependent/glslang.y"
+  case 264: /* type_specifier_nonarray: F32VEC4  */
+#line 2010 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 7437 "MachineIndependent/glslang_tab.cpp"
+#line 7911 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 259: /* type_specifier_nonarray: F64VEC2  */
-#line 1962 "MachineIndependent/glslang.y"
+  case 265: /* type_specifier_nonarray: F64VEC2  */
+#line 2016 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 7448 "MachineIndependent/glslang_tab.cpp"
+#line 7922 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 260: /* type_specifier_nonarray: F64VEC3  */
-#line 1968 "MachineIndependent/glslang.y"
+  case 266: /* type_specifier_nonarray: F64VEC3  */
+#line 2022 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 7459 "MachineIndependent/glslang_tab.cpp"
+#line 7933 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 261: /* type_specifier_nonarray: F64VEC4  */
-#line 1974 "MachineIndependent/glslang.y"
+  case 267: /* type_specifier_nonarray: F64VEC4  */
+#line 2028 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 7470 "MachineIndependent/glslang_tab.cpp"
+#line 7944 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 262: /* type_specifier_nonarray: I8VEC2  */
-#line 1980 "MachineIndependent/glslang.y"
+  case 268: /* type_specifier_nonarray: I8VEC2  */
+#line 2034 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(2);
     }
-#line 7481 "MachineIndependent/glslang_tab.cpp"
+#line 7955 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 263: /* type_specifier_nonarray: I8VEC3  */
-#line 1986 "MachineIndependent/glslang.y"
+  case 269: /* type_specifier_nonarray: I8VEC3  */
+#line 2040 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(3);
     }
-#line 7492 "MachineIndependent/glslang_tab.cpp"
+#line 7966 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 264: /* type_specifier_nonarray: I8VEC4  */
-#line 1992 "MachineIndependent/glslang.y"
+  case 270: /* type_specifier_nonarray: I8VEC4  */
+#line 2046 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(4);
     }
-#line 7503 "MachineIndependent/glslang_tab.cpp"
+#line 7977 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 265: /* type_specifier_nonarray: I16VEC2  */
-#line 1998 "MachineIndependent/glslang.y"
+  case 271: /* type_specifier_nonarray: I16VEC2  */
+#line 2052 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(2);
     }
-#line 7514 "MachineIndependent/glslang_tab.cpp"
+#line 7988 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 266: /* type_specifier_nonarray: I16VEC3  */
-#line 2004 "MachineIndependent/glslang.y"
+  case 272: /* type_specifier_nonarray: I16VEC3  */
+#line 2058 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(3);
     }
-#line 7525 "MachineIndependent/glslang_tab.cpp"
+#line 7999 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 267: /* type_specifier_nonarray: I16VEC4  */
-#line 2010 "MachineIndependent/glslang.y"
+  case 273: /* type_specifier_nonarray: I16VEC4  */
+#line 2064 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(4);
     }
-#line 7536 "MachineIndependent/glslang_tab.cpp"
+#line 8010 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 268: /* type_specifier_nonarray: I32VEC2  */
-#line 2016 "MachineIndependent/glslang.y"
+  case 274: /* type_specifier_nonarray: I32VEC2  */
+#line 2070 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 7547 "MachineIndependent/glslang_tab.cpp"
+#line 8021 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 269: /* type_specifier_nonarray: I32VEC3  */
-#line 2022 "MachineIndependent/glslang.y"
+  case 275: /* type_specifier_nonarray: I32VEC3  */
+#line 2076 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 7558 "MachineIndependent/glslang_tab.cpp"
+#line 8032 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 270: /* type_specifier_nonarray: I32VEC4  */
-#line 2028 "MachineIndependent/glslang.y"
+  case 276: /* type_specifier_nonarray: I32VEC4  */
+#line 2082 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 7569 "MachineIndependent/glslang_tab.cpp"
+#line 8043 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 271: /* type_specifier_nonarray: I64VEC2  */
-#line 2034 "MachineIndependent/glslang.y"
+  case 277: /* type_specifier_nonarray: I64VEC2  */
+#line 2088 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(2);
     }
-#line 7580 "MachineIndependent/glslang_tab.cpp"
+#line 8054 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 272: /* type_specifier_nonarray: I64VEC3  */
-#line 2040 "MachineIndependent/glslang.y"
+  case 278: /* type_specifier_nonarray: I64VEC3  */
+#line 2094 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(3);
     }
-#line 7591 "MachineIndependent/glslang_tab.cpp"
+#line 8065 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 273: /* type_specifier_nonarray: I64VEC4  */
-#line 2046 "MachineIndependent/glslang.y"
+  case 279: /* type_specifier_nonarray: I64VEC4  */
+#line 2100 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(4);
     }
-#line 7602 "MachineIndependent/glslang_tab.cpp"
+#line 8076 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 274: /* type_specifier_nonarray: U8VEC2  */
-#line 2052 "MachineIndependent/glslang.y"
+  case 280: /* type_specifier_nonarray: U8VEC2  */
+#line 2106 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(2);
     }
-#line 7613 "MachineIndependent/glslang_tab.cpp"
+#line 8087 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 275: /* type_specifier_nonarray: U8VEC3  */
-#line 2058 "MachineIndependent/glslang.y"
+  case 281: /* type_specifier_nonarray: U8VEC3  */
+#line 2112 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(3);
     }
-#line 7624 "MachineIndependent/glslang_tab.cpp"
+#line 8098 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 276: /* type_specifier_nonarray: U8VEC4  */
-#line 2064 "MachineIndependent/glslang.y"
+  case 282: /* type_specifier_nonarray: U8VEC4  */
+#line 2118 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(4);
     }
-#line 7635 "MachineIndependent/glslang_tab.cpp"
+#line 8109 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 277: /* type_specifier_nonarray: U16VEC2  */
-#line 2070 "MachineIndependent/glslang.y"
+  case 283: /* type_specifier_nonarray: U16VEC2  */
+#line 2124 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(2);
     }
-#line 7646 "MachineIndependent/glslang_tab.cpp"
+#line 8120 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 278: /* type_specifier_nonarray: U16VEC3  */
-#line 2076 "MachineIndependent/glslang.y"
+  case 284: /* type_specifier_nonarray: U16VEC3  */
+#line 2130 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(3);
     }
-#line 7657 "MachineIndependent/glslang_tab.cpp"
+#line 8131 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 279: /* type_specifier_nonarray: U16VEC4  */
-#line 2082 "MachineIndependent/glslang.y"
+  case 285: /* type_specifier_nonarray: U16VEC4  */
+#line 2136 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(4);
     }
-#line 7668 "MachineIndependent/glslang_tab.cpp"
+#line 8142 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 280: /* type_specifier_nonarray: U32VEC2  */
-#line 2088 "MachineIndependent/glslang.y"
+  case 286: /* type_specifier_nonarray: U32VEC2  */
+#line 2142 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 7679 "MachineIndependent/glslang_tab.cpp"
+#line 8153 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 281: /* type_specifier_nonarray: U32VEC3  */
-#line 2094 "MachineIndependent/glslang.y"
+  case 287: /* type_specifier_nonarray: U32VEC3  */
+#line 2148 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 7690 "MachineIndependent/glslang_tab.cpp"
+#line 8164 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 282: /* type_specifier_nonarray: U32VEC4  */
-#line 2100 "MachineIndependent/glslang.y"
+  case 288: /* type_specifier_nonarray: U32VEC4  */
+#line 2154 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 7701 "MachineIndependent/glslang_tab.cpp"
+#line 8175 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 283: /* type_specifier_nonarray: U64VEC2  */
-#line 2106 "MachineIndependent/glslang.y"
+  case 289: /* type_specifier_nonarray: U64VEC2  */
+#line 2160 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(2);
     }
-#line 7712 "MachineIndependent/glslang_tab.cpp"
+#line 8186 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 284: /* type_specifier_nonarray: U64VEC3  */
-#line 2112 "MachineIndependent/glslang.y"
+  case 290: /* type_specifier_nonarray: U64VEC3  */
+#line 2166 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(3);
     }
-#line 7723 "MachineIndependent/glslang_tab.cpp"
+#line 8197 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 285: /* type_specifier_nonarray: U64VEC4  */
-#line 2118 "MachineIndependent/glslang.y"
+  case 291: /* type_specifier_nonarray: U64VEC4  */
+#line 2172 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(4);
     }
-#line 7734 "MachineIndependent/glslang_tab.cpp"
+#line 8208 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 286: /* type_specifier_nonarray: DMAT2  */
-#line 2124 "MachineIndependent/glslang.y"
+  case 292: /* type_specifier_nonarray: DMAT2  */
+#line 2178 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7743,11 +8217,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7747 "MachineIndependent/glslang_tab.cpp"
+#line 8221 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 287: /* type_specifier_nonarray: DMAT3  */
-#line 2132 "MachineIndependent/glslang.y"
+  case 293: /* type_specifier_nonarray: DMAT3  */
+#line 2186 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7756,11 +8230,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7760 "MachineIndependent/glslang_tab.cpp"
+#line 8234 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 288: /* type_specifier_nonarray: DMAT4  */
-#line 2140 "MachineIndependent/glslang.y"
+  case 294: /* type_specifier_nonarray: DMAT4  */
+#line 2194 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7769,11 +8243,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7773 "MachineIndependent/glslang_tab.cpp"
+#line 8247 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 289: /* type_specifier_nonarray: DMAT2X2  */
-#line 2148 "MachineIndependent/glslang.y"
+  case 295: /* type_specifier_nonarray: DMAT2X2  */
+#line 2202 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7782,11 +8256,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7786 "MachineIndependent/glslang_tab.cpp"
+#line 8260 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 290: /* type_specifier_nonarray: DMAT2X3  */
-#line 2156 "MachineIndependent/glslang.y"
+  case 296: /* type_specifier_nonarray: DMAT2X3  */
+#line 2210 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7795,11 +8269,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7799 "MachineIndependent/glslang_tab.cpp"
+#line 8273 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 291: /* type_specifier_nonarray: DMAT2X4  */
-#line 2164 "MachineIndependent/glslang.y"
+  case 297: /* type_specifier_nonarray: DMAT2X4  */
+#line 2218 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7808,11 +8282,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7812 "MachineIndependent/glslang_tab.cpp"
+#line 8286 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 292: /* type_specifier_nonarray: DMAT3X2  */
-#line 2172 "MachineIndependent/glslang.y"
+  case 298: /* type_specifier_nonarray: DMAT3X2  */
+#line 2226 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7821,11 +8295,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7825 "MachineIndependent/glslang_tab.cpp"
+#line 8299 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 293: /* type_specifier_nonarray: DMAT3X3  */
-#line 2180 "MachineIndependent/glslang.y"
+  case 299: /* type_specifier_nonarray: DMAT3X3  */
+#line 2234 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7834,11 +8308,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7838 "MachineIndependent/glslang_tab.cpp"
+#line 8312 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 294: /* type_specifier_nonarray: DMAT3X4  */
-#line 2188 "MachineIndependent/glslang.y"
+  case 300: /* type_specifier_nonarray: DMAT3X4  */
+#line 2242 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7847,11 +8321,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7851 "MachineIndependent/glslang_tab.cpp"
+#line 8325 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 295: /* type_specifier_nonarray: DMAT4X2  */
-#line 2196 "MachineIndependent/glslang.y"
+  case 301: /* type_specifier_nonarray: DMAT4X2  */
+#line 2250 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7860,11 +8334,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7864 "MachineIndependent/glslang_tab.cpp"
+#line 8338 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 296: /* type_specifier_nonarray: DMAT4X3  */
-#line 2204 "MachineIndependent/glslang.y"
+  case 302: /* type_specifier_nonarray: DMAT4X3  */
+#line 2258 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7873,11 +8347,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7877 "MachineIndependent/glslang_tab.cpp"
+#line 8351 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 297: /* type_specifier_nonarray: DMAT4X4  */
-#line 2212 "MachineIndependent/glslang.y"
+  case 303: /* type_specifier_nonarray: DMAT4X4  */
+#line 2266 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7886,2228 +8360,2228 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7890 "MachineIndependent/glslang_tab.cpp"
+#line 8364 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 298: /* type_specifier_nonarray: F16MAT2  */
-#line 2220 "MachineIndependent/glslang.y"
+  case 304: /* type_specifier_nonarray: F16MAT2  */
+#line 2274 "MachineIndependent/glslang.y"
               {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7901 "MachineIndependent/glslang_tab.cpp"
+#line 8375 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 299: /* type_specifier_nonarray: F16MAT3  */
-#line 2226 "MachineIndependent/glslang.y"
+  case 305: /* type_specifier_nonarray: F16MAT3  */
+#line 2280 "MachineIndependent/glslang.y"
               {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7912 "MachineIndependent/glslang_tab.cpp"
+#line 8386 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 300: /* type_specifier_nonarray: F16MAT4  */
-#line 2232 "MachineIndependent/glslang.y"
+  case 306: /* type_specifier_nonarray: F16MAT4  */
+#line 2286 "MachineIndependent/glslang.y"
               {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7923 "MachineIndependent/glslang_tab.cpp"
+#line 8397 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 301: /* type_specifier_nonarray: F16MAT2X2  */
-#line 2238 "MachineIndependent/glslang.y"
+  case 307: /* type_specifier_nonarray: F16MAT2X2  */
+#line 2292 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7934 "MachineIndependent/glslang_tab.cpp"
+#line 8408 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 302: /* type_specifier_nonarray: F16MAT2X3  */
-#line 2244 "MachineIndependent/glslang.y"
+  case 308: /* type_specifier_nonarray: F16MAT2X3  */
+#line 2298 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7945 "MachineIndependent/glslang_tab.cpp"
+#line 8419 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 303: /* type_specifier_nonarray: F16MAT2X4  */
-#line 2250 "MachineIndependent/glslang.y"
+  case 309: /* type_specifier_nonarray: F16MAT2X4  */
+#line 2304 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7956 "MachineIndependent/glslang_tab.cpp"
+#line 8430 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 304: /* type_specifier_nonarray: F16MAT3X2  */
-#line 2256 "MachineIndependent/glslang.y"
+  case 310: /* type_specifier_nonarray: F16MAT3X2  */
+#line 2310 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7967 "MachineIndependent/glslang_tab.cpp"
+#line 8441 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 305: /* type_specifier_nonarray: F16MAT3X3  */
-#line 2262 "MachineIndependent/glslang.y"
+  case 311: /* type_specifier_nonarray: F16MAT3X3  */
+#line 2316 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7978 "MachineIndependent/glslang_tab.cpp"
+#line 8452 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 306: /* type_specifier_nonarray: F16MAT3X4  */
-#line 2268 "MachineIndependent/glslang.y"
+  case 312: /* type_specifier_nonarray: F16MAT3X4  */
+#line 2322 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7989 "MachineIndependent/glslang_tab.cpp"
+#line 8463 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 307: /* type_specifier_nonarray: F16MAT4X2  */
-#line 2274 "MachineIndependent/glslang.y"
+  case 313: /* type_specifier_nonarray: F16MAT4X2  */
+#line 2328 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 8000 "MachineIndependent/glslang_tab.cpp"
+#line 8474 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 308: /* type_specifier_nonarray: F16MAT4X3  */
-#line 2280 "MachineIndependent/glslang.y"
+  case 314: /* type_specifier_nonarray: F16MAT4X3  */
+#line 2334 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 8011 "MachineIndependent/glslang_tab.cpp"
+#line 8485 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 309: /* type_specifier_nonarray: F16MAT4X4  */
-#line 2286 "MachineIndependent/glslang.y"
+  case 315: /* type_specifier_nonarray: F16MAT4X4  */
+#line 2340 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8022 "MachineIndependent/glslang_tab.cpp"
+#line 8496 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 310: /* type_specifier_nonarray: F32MAT2  */
-#line 2292 "MachineIndependent/glslang.y"
+  case 316: /* type_specifier_nonarray: F32MAT2  */
+#line 2346 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8033 "MachineIndependent/glslang_tab.cpp"
+#line 8507 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 311: /* type_specifier_nonarray: F32MAT3  */
-#line 2298 "MachineIndependent/glslang.y"
+  case 317: /* type_specifier_nonarray: F32MAT3  */
+#line 2352 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8044 "MachineIndependent/glslang_tab.cpp"
+#line 8518 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 312: /* type_specifier_nonarray: F32MAT4  */
-#line 2304 "MachineIndependent/glslang.y"
+  case 318: /* type_specifier_nonarray: F32MAT4  */
+#line 2358 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8055 "MachineIndependent/glslang_tab.cpp"
+#line 8529 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 313: /* type_specifier_nonarray: F32MAT2X2  */
-#line 2310 "MachineIndependent/glslang.y"
+  case 319: /* type_specifier_nonarray: F32MAT2X2  */
+#line 2364 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8066 "MachineIndependent/glslang_tab.cpp"
+#line 8540 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 314: /* type_specifier_nonarray: F32MAT2X3  */
-#line 2316 "MachineIndependent/glslang.y"
+  case 320: /* type_specifier_nonarray: F32MAT2X3  */
+#line 2370 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 8077 "MachineIndependent/glslang_tab.cpp"
+#line 8551 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 315: /* type_specifier_nonarray: F32MAT2X4  */
-#line 2322 "MachineIndependent/glslang.y"
+  case 321: /* type_specifier_nonarray: F32MAT2X4  */
+#line 2376 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 8088 "MachineIndependent/glslang_tab.cpp"
+#line 8562 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 316: /* type_specifier_nonarray: F32MAT3X2  */
-#line 2328 "MachineIndependent/glslang.y"
+  case 322: /* type_specifier_nonarray: F32MAT3X2  */
+#line 2382 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 8099 "MachineIndependent/glslang_tab.cpp"
+#line 8573 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 317: /* type_specifier_nonarray: F32MAT3X3  */
-#line 2334 "MachineIndependent/glslang.y"
+  case 323: /* type_specifier_nonarray: F32MAT3X3  */
+#line 2388 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8110 "MachineIndependent/glslang_tab.cpp"
+#line 8584 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 318: /* type_specifier_nonarray: F32MAT3X4  */
-#line 2340 "MachineIndependent/glslang.y"
+  case 324: /* type_specifier_nonarray: F32MAT3X4  */
+#line 2394 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 8121 "MachineIndependent/glslang_tab.cpp"
+#line 8595 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 319: /* type_specifier_nonarray: F32MAT4X2  */
-#line 2346 "MachineIndependent/glslang.y"
+  case 325: /* type_specifier_nonarray: F32MAT4X2  */
+#line 2400 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 8132 "MachineIndependent/glslang_tab.cpp"
+#line 8606 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 320: /* type_specifier_nonarray: F32MAT4X3  */
-#line 2352 "MachineIndependent/glslang.y"
+  case 326: /* type_specifier_nonarray: F32MAT4X3  */
+#line 2406 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 8143 "MachineIndependent/glslang_tab.cpp"
+#line 8617 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 321: /* type_specifier_nonarray: F32MAT4X4  */
-#line 2358 "MachineIndependent/glslang.y"
+  case 327: /* type_specifier_nonarray: F32MAT4X4  */
+#line 2412 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8154 "MachineIndependent/glslang_tab.cpp"
+#line 8628 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 322: /* type_specifier_nonarray: F64MAT2  */
-#line 2364 "MachineIndependent/glslang.y"
+  case 328: /* type_specifier_nonarray: F64MAT2  */
+#line 2418 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8165 "MachineIndependent/glslang_tab.cpp"
+#line 8639 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 323: /* type_specifier_nonarray: F64MAT3  */
-#line 2370 "MachineIndependent/glslang.y"
+  case 329: /* type_specifier_nonarray: F64MAT3  */
+#line 2424 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8176 "MachineIndependent/glslang_tab.cpp"
+#line 8650 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 324: /* type_specifier_nonarray: F64MAT4  */
-#line 2376 "MachineIndependent/glslang.y"
+  case 330: /* type_specifier_nonarray: F64MAT4  */
+#line 2430 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8187 "MachineIndependent/glslang_tab.cpp"
+#line 8661 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 325: /* type_specifier_nonarray: F64MAT2X2  */
-#line 2382 "MachineIndependent/glslang.y"
+  case 331: /* type_specifier_nonarray: F64MAT2X2  */
+#line 2436 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8198 "MachineIndependent/glslang_tab.cpp"
+#line 8672 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 326: /* type_specifier_nonarray: F64MAT2X3  */
-#line 2388 "MachineIndependent/glslang.y"
+  case 332: /* type_specifier_nonarray: F64MAT2X3  */
+#line 2442 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 8209 "MachineIndependent/glslang_tab.cpp"
+#line 8683 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 327: /* type_specifier_nonarray: F64MAT2X4  */
-#line 2394 "MachineIndependent/glslang.y"
+  case 333: /* type_specifier_nonarray: F64MAT2X4  */
+#line 2448 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 8220 "MachineIndependent/glslang_tab.cpp"
+#line 8694 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 328: /* type_specifier_nonarray: F64MAT3X2  */
-#line 2400 "MachineIndependent/glslang.y"
+  case 334: /* type_specifier_nonarray: F64MAT3X2  */
+#line 2454 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 8231 "MachineIndependent/glslang_tab.cpp"
+#line 8705 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 329: /* type_specifier_nonarray: F64MAT3X3  */
-#line 2406 "MachineIndependent/glslang.y"
+  case 335: /* type_specifier_nonarray: F64MAT3X3  */
+#line 2460 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8242 "MachineIndependent/glslang_tab.cpp"
+#line 8716 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 330: /* type_specifier_nonarray: F64MAT3X4  */
-#line 2412 "MachineIndependent/glslang.y"
+  case 336: /* type_specifier_nonarray: F64MAT3X4  */
+#line 2466 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 8253 "MachineIndependent/glslang_tab.cpp"
+#line 8727 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 331: /* type_specifier_nonarray: F64MAT4X2  */
-#line 2418 "MachineIndependent/glslang.y"
+  case 337: /* type_specifier_nonarray: F64MAT4X2  */
+#line 2472 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 8264 "MachineIndependent/glslang_tab.cpp"
+#line 8738 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 332: /* type_specifier_nonarray: F64MAT4X3  */
-#line 2424 "MachineIndependent/glslang.y"
+  case 338: /* type_specifier_nonarray: F64MAT4X3  */
+#line 2478 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 8275 "MachineIndependent/glslang_tab.cpp"
+#line 8749 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 333: /* type_specifier_nonarray: F64MAT4X4  */
-#line 2430 "MachineIndependent/glslang.y"
+  case 339: /* type_specifier_nonarray: F64MAT4X4  */
+#line 2484 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8286 "MachineIndependent/glslang_tab.cpp"
+#line 8760 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 334: /* type_specifier_nonarray: ACCSTRUCTNV  */
-#line 2436 "MachineIndependent/glslang.y"
+  case 340: /* type_specifier_nonarray: ACCSTRUCTNV  */
+#line 2490 "MachineIndependent/glslang.y"
                   {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 8295 "MachineIndependent/glslang_tab.cpp"
+#line 8769 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 335: /* type_specifier_nonarray: ACCSTRUCTEXT  */
-#line 2440 "MachineIndependent/glslang.y"
+  case 341: /* type_specifier_nonarray: ACCSTRUCTEXT  */
+#line 2494 "MachineIndependent/glslang.y"
                    {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 8304 "MachineIndependent/glslang_tab.cpp"
+#line 8778 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 336: /* type_specifier_nonarray: RAYQUERYEXT  */
-#line 2444 "MachineIndependent/glslang.y"
+  case 342: /* type_specifier_nonarray: RAYQUERYEXT  */
+#line 2498 "MachineIndependent/glslang.y"
                   {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtRayQuery;
     }
-#line 8313 "MachineIndependent/glslang_tab.cpp"
+#line 8787 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 337: /* type_specifier_nonarray: ATOMIC_UINT  */
-#line 2448 "MachineIndependent/glslang.y"
+  case 343: /* type_specifier_nonarray: ATOMIC_UINT  */
+#line 2502 "MachineIndependent/glslang.y"
                   {
         parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtAtomicUint;
     }
-#line 8323 "MachineIndependent/glslang_tab.cpp"
+#line 8797 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 338: /* type_specifier_nonarray: SAMPLER1D  */
-#line 2453 "MachineIndependent/glslang.y"
+  case 344: /* type_specifier_nonarray: SAMPLER1D  */
+#line 2507 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
     }
-#line 8333 "MachineIndependent/glslang_tab.cpp"
+#line 8807 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 339: /* type_specifier_nonarray: SAMPLER2D  */
-#line 2459 "MachineIndependent/glslang.y"
+  case 345: /* type_specifier_nonarray: SAMPLER2D  */
+#line 2513 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
     }
-#line 8343 "MachineIndependent/glslang_tab.cpp"
+#line 8817 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 340: /* type_specifier_nonarray: SAMPLER3D  */
-#line 2464 "MachineIndependent/glslang.y"
+  case 346: /* type_specifier_nonarray: SAMPLER3D  */
+#line 2518 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
     }
-#line 8353 "MachineIndependent/glslang_tab.cpp"
+#line 8827 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 341: /* type_specifier_nonarray: SAMPLERCUBE  */
-#line 2469 "MachineIndependent/glslang.y"
+  case 347: /* type_specifier_nonarray: SAMPLERCUBE  */
+#line 2523 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
     }
-#line 8363 "MachineIndependent/glslang_tab.cpp"
+#line 8837 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 342: /* type_specifier_nonarray: SAMPLER2DSHADOW  */
-#line 2474 "MachineIndependent/glslang.y"
+  case 348: /* type_specifier_nonarray: SAMPLER2DSHADOW  */
+#line 2528 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
     }
-#line 8373 "MachineIndependent/glslang_tab.cpp"
+#line 8847 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 343: /* type_specifier_nonarray: SAMPLERCUBESHADOW  */
-#line 2479 "MachineIndependent/glslang.y"
+  case 349: /* type_specifier_nonarray: SAMPLERCUBESHADOW  */
+#line 2533 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
     }
-#line 8383 "MachineIndependent/glslang_tab.cpp"
+#line 8857 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 344: /* type_specifier_nonarray: SAMPLER2DARRAY  */
-#line 2484 "MachineIndependent/glslang.y"
+  case 350: /* type_specifier_nonarray: SAMPLER2DARRAY  */
+#line 2538 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
     }
-#line 8393 "MachineIndependent/glslang_tab.cpp"
+#line 8867 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 345: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW  */
-#line 2489 "MachineIndependent/glslang.y"
+  case 351: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW  */
+#line 2543 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
     }
-#line 8403 "MachineIndependent/glslang_tab.cpp"
+#line 8877 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 346: /* type_specifier_nonarray: SAMPLER1DSHADOW  */
-#line 2495 "MachineIndependent/glslang.y"
+  case 352: /* type_specifier_nonarray: SAMPLER1DSHADOW  */
+#line 2549 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
     }
-#line 8413 "MachineIndependent/glslang_tab.cpp"
+#line 8887 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 347: /* type_specifier_nonarray: SAMPLER1DARRAY  */
-#line 2500 "MachineIndependent/glslang.y"
+  case 353: /* type_specifier_nonarray: SAMPLER1DARRAY  */
+#line 2554 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
     }
-#line 8423 "MachineIndependent/glslang_tab.cpp"
+#line 8897 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 348: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW  */
-#line 2505 "MachineIndependent/glslang.y"
+  case 354: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW  */
+#line 2559 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
     }
-#line 8433 "MachineIndependent/glslang_tab.cpp"
+#line 8907 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 349: /* type_specifier_nonarray: SAMPLERCUBEARRAY  */
-#line 2510 "MachineIndependent/glslang.y"
+  case 355: /* type_specifier_nonarray: SAMPLERCUBEARRAY  */
+#line 2564 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
     }
-#line 8443 "MachineIndependent/glslang_tab.cpp"
+#line 8917 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 350: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW  */
-#line 2515 "MachineIndependent/glslang.y"
+  case 356: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW  */
+#line 2569 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
     }
-#line 8453 "MachineIndependent/glslang_tab.cpp"
+#line 8927 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 351: /* type_specifier_nonarray: F16SAMPLER1D  */
-#line 2520 "MachineIndependent/glslang.y"
+  case 357: /* type_specifier_nonarray: F16SAMPLER1D  */
+#line 2574 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
     }
-#line 8464 "MachineIndependent/glslang_tab.cpp"
+#line 8938 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 352: /* type_specifier_nonarray: F16SAMPLER2D  */
-#line 2526 "MachineIndependent/glslang.y"
+  case 358: /* type_specifier_nonarray: F16SAMPLER2D  */
+#line 2580 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
     }
-#line 8475 "MachineIndependent/glslang_tab.cpp"
+#line 8949 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 353: /* type_specifier_nonarray: F16SAMPLER3D  */
-#line 2532 "MachineIndependent/glslang.y"
+  case 359: /* type_specifier_nonarray: F16SAMPLER3D  */
+#line 2586 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
     }
-#line 8486 "MachineIndependent/glslang_tab.cpp"
+#line 8960 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 354: /* type_specifier_nonarray: F16SAMPLERCUBE  */
-#line 2538 "MachineIndependent/glslang.y"
+  case 360: /* type_specifier_nonarray: F16SAMPLERCUBE  */
+#line 2592 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
     }
-#line 8497 "MachineIndependent/glslang_tab.cpp"
+#line 8971 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 355: /* type_specifier_nonarray: F16SAMPLER1DSHADOW  */
-#line 2544 "MachineIndependent/glslang.y"
+  case 361: /* type_specifier_nonarray: F16SAMPLER1DSHADOW  */
+#line 2598 "MachineIndependent/glslang.y"
                          {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
     }
-#line 8508 "MachineIndependent/glslang_tab.cpp"
+#line 8982 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 356: /* type_specifier_nonarray: F16SAMPLER2DSHADOW  */
-#line 2550 "MachineIndependent/glslang.y"
+  case 362: /* type_specifier_nonarray: F16SAMPLER2DSHADOW  */
+#line 2604 "MachineIndependent/glslang.y"
                          {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
     }
-#line 8519 "MachineIndependent/glslang_tab.cpp"
+#line 8993 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 357: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW  */
-#line 2556 "MachineIndependent/glslang.y"
+  case 363: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW  */
+#line 2610 "MachineIndependent/glslang.y"
                            {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
     }
-#line 8530 "MachineIndependent/glslang_tab.cpp"
+#line 9004 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 358: /* type_specifier_nonarray: F16SAMPLER1DARRAY  */
-#line 2562 "MachineIndependent/glslang.y"
+  case 364: /* type_specifier_nonarray: F16SAMPLER1DARRAY  */
+#line 2616 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
     }
-#line 8541 "MachineIndependent/glslang_tab.cpp"
+#line 9015 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 359: /* type_specifier_nonarray: F16SAMPLER2DARRAY  */
-#line 2568 "MachineIndependent/glslang.y"
+  case 365: /* type_specifier_nonarray: F16SAMPLER2DARRAY  */
+#line 2622 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
     }
-#line 8552 "MachineIndependent/glslang_tab.cpp"
+#line 9026 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 360: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW  */
-#line 2574 "MachineIndependent/glslang.y"
+  case 366: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW  */
+#line 2628 "MachineIndependent/glslang.y"
                               {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
     }
-#line 8563 "MachineIndependent/glslang_tab.cpp"
+#line 9037 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 361: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW  */
-#line 2580 "MachineIndependent/glslang.y"
+  case 367: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW  */
+#line 2634 "MachineIndependent/glslang.y"
                               {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
     }
-#line 8574 "MachineIndependent/glslang_tab.cpp"
+#line 9048 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 362: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY  */
-#line 2586 "MachineIndependent/glslang.y"
+  case 368: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY  */
+#line 2640 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
     }
-#line 8585 "MachineIndependent/glslang_tab.cpp"
+#line 9059 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 363: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW  */
-#line 2592 "MachineIndependent/glslang.y"
+  case 369: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW  */
+#line 2646 "MachineIndependent/glslang.y"
                                 {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
     }
-#line 8596 "MachineIndependent/glslang_tab.cpp"
+#line 9070 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 364: /* type_specifier_nonarray: ISAMPLER1D  */
-#line 2598 "MachineIndependent/glslang.y"
+  case 370: /* type_specifier_nonarray: ISAMPLER1D  */
+#line 2652 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D);
     }
-#line 8606 "MachineIndependent/glslang_tab.cpp"
+#line 9080 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 365: /* type_specifier_nonarray: ISAMPLER2D  */
-#line 2604 "MachineIndependent/glslang.y"
+  case 371: /* type_specifier_nonarray: ISAMPLER2D  */
+#line 2658 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D);
     }
-#line 8616 "MachineIndependent/glslang_tab.cpp"
+#line 9090 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 366: /* type_specifier_nonarray: ISAMPLER3D  */
-#line 2609 "MachineIndependent/glslang.y"
+  case 372: /* type_specifier_nonarray: ISAMPLER3D  */
+#line 2663 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd3D);
     }
-#line 8626 "MachineIndependent/glslang_tab.cpp"
+#line 9100 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 367: /* type_specifier_nonarray: ISAMPLERCUBE  */
-#line 2614 "MachineIndependent/glslang.y"
+  case 373: /* type_specifier_nonarray: ISAMPLERCUBE  */
+#line 2668 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube);
     }
-#line 8636 "MachineIndependent/glslang_tab.cpp"
+#line 9110 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 368: /* type_specifier_nonarray: ISAMPLER2DARRAY  */
-#line 2619 "MachineIndependent/glslang.y"
+  case 374: /* type_specifier_nonarray: ISAMPLER2DARRAY  */
+#line 2673 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
     }
-#line 8646 "MachineIndependent/glslang_tab.cpp"
+#line 9120 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 369: /* type_specifier_nonarray: USAMPLER2D  */
-#line 2624 "MachineIndependent/glslang.y"
+  case 375: /* type_specifier_nonarray: USAMPLER2D  */
+#line 2678 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D);
     }
-#line 8656 "MachineIndependent/glslang_tab.cpp"
+#line 9130 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 370: /* type_specifier_nonarray: USAMPLER3D  */
-#line 2629 "MachineIndependent/glslang.y"
+  case 376: /* type_specifier_nonarray: USAMPLER3D  */
+#line 2683 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd3D);
     }
-#line 8666 "MachineIndependent/glslang_tab.cpp"
+#line 9140 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 371: /* type_specifier_nonarray: USAMPLERCUBE  */
-#line 2634 "MachineIndependent/glslang.y"
+  case 377: /* type_specifier_nonarray: USAMPLERCUBE  */
+#line 2688 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube);
     }
-#line 8676 "MachineIndependent/glslang_tab.cpp"
+#line 9150 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 372: /* type_specifier_nonarray: ISAMPLER1DARRAY  */
-#line 2640 "MachineIndependent/glslang.y"
+  case 378: /* type_specifier_nonarray: ISAMPLER1DARRAY  */
+#line 2694 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
     }
-#line 8686 "MachineIndependent/glslang_tab.cpp"
+#line 9160 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 373: /* type_specifier_nonarray: ISAMPLERCUBEARRAY  */
-#line 2645 "MachineIndependent/glslang.y"
+  case 379: /* type_specifier_nonarray: ISAMPLERCUBEARRAY  */
+#line 2699 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
     }
-#line 8696 "MachineIndependent/glslang_tab.cpp"
+#line 9170 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 374: /* type_specifier_nonarray: USAMPLER1D  */
-#line 2650 "MachineIndependent/glslang.y"
+  case 380: /* type_specifier_nonarray: USAMPLER1D  */
+#line 2704 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D);
     }
-#line 8706 "MachineIndependent/glslang_tab.cpp"
+#line 9180 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 375: /* type_specifier_nonarray: USAMPLER1DARRAY  */
-#line 2655 "MachineIndependent/glslang.y"
+  case 381: /* type_specifier_nonarray: USAMPLER1DARRAY  */
+#line 2709 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
     }
-#line 8716 "MachineIndependent/glslang_tab.cpp"
+#line 9190 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 376: /* type_specifier_nonarray: USAMPLERCUBEARRAY  */
-#line 2660 "MachineIndependent/glslang.y"
+  case 382: /* type_specifier_nonarray: USAMPLERCUBEARRAY  */
+#line 2714 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
     }
-#line 8726 "MachineIndependent/glslang_tab.cpp"
+#line 9200 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 377: /* type_specifier_nonarray: TEXTURECUBEARRAY  */
-#line 2665 "MachineIndependent/glslang.y"
+  case 383: /* type_specifier_nonarray: TEXTURECUBEARRAY  */
+#line 2719 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
     }
-#line 8736 "MachineIndependent/glslang_tab.cpp"
+#line 9210 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 378: /* type_specifier_nonarray: ITEXTURECUBEARRAY  */
-#line 2670 "MachineIndependent/glslang.y"
+  case 384: /* type_specifier_nonarray: ITEXTURECUBEARRAY  */
+#line 2724 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true);
     }
-#line 8746 "MachineIndependent/glslang_tab.cpp"
+#line 9220 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 379: /* type_specifier_nonarray: UTEXTURECUBEARRAY  */
-#line 2675 "MachineIndependent/glslang.y"
+  case 385: /* type_specifier_nonarray: UTEXTURECUBEARRAY  */
+#line 2729 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
     }
-#line 8756 "MachineIndependent/glslang_tab.cpp"
+#line 9230 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 380: /* type_specifier_nonarray: USAMPLER2DARRAY  */
-#line 2681 "MachineIndependent/glslang.y"
+  case 386: /* type_specifier_nonarray: USAMPLER2DARRAY  */
+#line 2735 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
     }
-#line 8766 "MachineIndependent/glslang_tab.cpp"
+#line 9240 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 381: /* type_specifier_nonarray: TEXTURE2D  */
-#line 2686 "MachineIndependent/glslang.y"
+  case 387: /* type_specifier_nonarray: TEXTURE2D  */
+#line 2740 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
     }
-#line 8776 "MachineIndependent/glslang_tab.cpp"
+#line 9250 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 382: /* type_specifier_nonarray: TEXTURE3D  */
-#line 2691 "MachineIndependent/glslang.y"
+  case 388: /* type_specifier_nonarray: TEXTURE3D  */
+#line 2745 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
     }
-#line 8786 "MachineIndependent/glslang_tab.cpp"
+#line 9260 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 383: /* type_specifier_nonarray: TEXTURE2DARRAY  */
-#line 2696 "MachineIndependent/glslang.y"
+  case 389: /* type_specifier_nonarray: TEXTURE2DARRAY  */
+#line 2750 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
     }
-#line 8796 "MachineIndependent/glslang_tab.cpp"
+#line 9270 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 384: /* type_specifier_nonarray: TEXTURECUBE  */
-#line 2701 "MachineIndependent/glslang.y"
+  case 390: /* type_specifier_nonarray: TEXTURECUBE  */
+#line 2755 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
     }
-#line 8806 "MachineIndependent/glslang_tab.cpp"
+#line 9280 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 385: /* type_specifier_nonarray: ITEXTURE2D  */
-#line 2706 "MachineIndependent/glslang.y"
+  case 391: /* type_specifier_nonarray: ITEXTURE2D  */
+#line 2760 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
     }
-#line 8816 "MachineIndependent/glslang_tab.cpp"
+#line 9290 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 386: /* type_specifier_nonarray: ITEXTURE3D  */
-#line 2711 "MachineIndependent/glslang.y"
+  case 392: /* type_specifier_nonarray: ITEXTURE3D  */
+#line 2765 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
     }
-#line 8826 "MachineIndependent/glslang_tab.cpp"
+#line 9300 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 387: /* type_specifier_nonarray: ITEXTURECUBE  */
-#line 2716 "MachineIndependent/glslang.y"
+  case 393: /* type_specifier_nonarray: ITEXTURECUBE  */
+#line 2770 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
     }
-#line 8836 "MachineIndependent/glslang_tab.cpp"
+#line 9310 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 388: /* type_specifier_nonarray: ITEXTURE2DARRAY  */
-#line 2721 "MachineIndependent/glslang.y"
+  case 394: /* type_specifier_nonarray: ITEXTURE2DARRAY  */
+#line 2775 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
     }
-#line 8846 "MachineIndependent/glslang_tab.cpp"
+#line 9320 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 389: /* type_specifier_nonarray: UTEXTURE2D  */
-#line 2726 "MachineIndependent/glslang.y"
+  case 395: /* type_specifier_nonarray: UTEXTURE2D  */
+#line 2780 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
     }
-#line 8856 "MachineIndependent/glslang_tab.cpp"
+#line 9330 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 390: /* type_specifier_nonarray: UTEXTURE3D  */
-#line 2731 "MachineIndependent/glslang.y"
+  case 396: /* type_specifier_nonarray: UTEXTURE3D  */
+#line 2785 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
     }
-#line 8866 "MachineIndependent/glslang_tab.cpp"
+#line 9340 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 391: /* type_specifier_nonarray: UTEXTURECUBE  */
-#line 2736 "MachineIndependent/glslang.y"
+  case 397: /* type_specifier_nonarray: UTEXTURECUBE  */
+#line 2790 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
     }
-#line 8876 "MachineIndependent/glslang_tab.cpp"
+#line 9350 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 392: /* type_specifier_nonarray: UTEXTURE2DARRAY  */
-#line 2741 "MachineIndependent/glslang.y"
+  case 398: /* type_specifier_nonarray: UTEXTURE2DARRAY  */
+#line 2795 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
     }
-#line 8886 "MachineIndependent/glslang_tab.cpp"
+#line 9360 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 393: /* type_specifier_nonarray: SAMPLER  */
-#line 2746 "MachineIndependent/glslang.y"
+  case 399: /* type_specifier_nonarray: SAMPLER  */
+#line 2800 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(false);
     }
-#line 8896 "MachineIndependent/glslang_tab.cpp"
+#line 9370 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 394: /* type_specifier_nonarray: SAMPLERSHADOW  */
-#line 2751 "MachineIndependent/glslang.y"
+  case 400: /* type_specifier_nonarray: SAMPLERSHADOW  */
+#line 2805 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(true);
     }
-#line 8906 "MachineIndependent/glslang_tab.cpp"
+#line 9380 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 395: /* type_specifier_nonarray: SAMPLER2DRECT  */
-#line 2757 "MachineIndependent/glslang.y"
+  case 401: /* type_specifier_nonarray: SAMPLER2DRECT  */
+#line 2811 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
     }
-#line 8916 "MachineIndependent/glslang_tab.cpp"
+#line 9390 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 396: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW  */
-#line 2762 "MachineIndependent/glslang.y"
+  case 402: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW  */
+#line 2816 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
     }
-#line 8926 "MachineIndependent/glslang_tab.cpp"
+#line 9400 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 397: /* type_specifier_nonarray: F16SAMPLER2DRECT  */
-#line 2767 "MachineIndependent/glslang.y"
+  case 403: /* type_specifier_nonarray: F16SAMPLER2DRECT  */
+#line 2821 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
     }
-#line 8937 "MachineIndependent/glslang_tab.cpp"
+#line 9411 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 398: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW  */
-#line 2773 "MachineIndependent/glslang.y"
+  case 404: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW  */
+#line 2827 "MachineIndependent/glslang.y"
                              {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
     }
-#line 8948 "MachineIndependent/glslang_tab.cpp"
+#line 9422 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 399: /* type_specifier_nonarray: ISAMPLER2DRECT  */
-#line 2779 "MachineIndependent/glslang.y"
+  case 405: /* type_specifier_nonarray: ISAMPLER2DRECT  */
+#line 2833 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdRect);
     }
-#line 8958 "MachineIndependent/glslang_tab.cpp"
+#line 9432 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 400: /* type_specifier_nonarray: USAMPLER2DRECT  */
-#line 2784 "MachineIndependent/glslang.y"
+  case 406: /* type_specifier_nonarray: USAMPLER2DRECT  */
+#line 2838 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdRect);
     }
-#line 8968 "MachineIndependent/glslang_tab.cpp"
+#line 9442 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 401: /* type_specifier_nonarray: SAMPLERBUFFER  */
-#line 2789 "MachineIndependent/glslang.y"
+  case 407: /* type_specifier_nonarray: SAMPLERBUFFER  */
+#line 2843 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
     }
-#line 8978 "MachineIndependent/glslang_tab.cpp"
+#line 9452 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 402: /* type_specifier_nonarray: F16SAMPLERBUFFER  */
-#line 2794 "MachineIndependent/glslang.y"
+  case 408: /* type_specifier_nonarray: F16SAMPLERBUFFER  */
+#line 2848 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
     }
-#line 8989 "MachineIndependent/glslang_tab.cpp"
+#line 9463 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 403: /* type_specifier_nonarray: ISAMPLERBUFFER  */
-#line 2800 "MachineIndependent/glslang.y"
+  case 409: /* type_specifier_nonarray: ISAMPLERBUFFER  */
+#line 2854 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
     }
-#line 8999 "MachineIndependent/glslang_tab.cpp"
+#line 9473 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 404: /* type_specifier_nonarray: USAMPLERBUFFER  */
-#line 2805 "MachineIndependent/glslang.y"
+  case 410: /* type_specifier_nonarray: USAMPLERBUFFER  */
+#line 2859 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
     }
-#line 9009 "MachineIndependent/glslang_tab.cpp"
+#line 9483 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 405: /* type_specifier_nonarray: SAMPLER2DMS  */
-#line 2810 "MachineIndependent/glslang.y"
+  case 411: /* type_specifier_nonarray: SAMPLER2DMS  */
+#line 2864 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
     }
-#line 9019 "MachineIndependent/glslang_tab.cpp"
+#line 9493 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 406: /* type_specifier_nonarray: F16SAMPLER2DMS  */
-#line 2815 "MachineIndependent/glslang.y"
+  case 412: /* type_specifier_nonarray: F16SAMPLER2DMS  */
+#line 2869 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
     }
-#line 9030 "MachineIndependent/glslang_tab.cpp"
+#line 9504 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 407: /* type_specifier_nonarray: ISAMPLER2DMS  */
-#line 2821 "MachineIndependent/glslang.y"
+  case 413: /* type_specifier_nonarray: ISAMPLER2DMS  */
+#line 2875 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
     }
-#line 9040 "MachineIndependent/glslang_tab.cpp"
+#line 9514 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 408: /* type_specifier_nonarray: USAMPLER2DMS  */
-#line 2826 "MachineIndependent/glslang.y"
+  case 414: /* type_specifier_nonarray: USAMPLER2DMS  */
+#line 2880 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
     }
-#line 9050 "MachineIndependent/glslang_tab.cpp"
+#line 9524 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 409: /* type_specifier_nonarray: SAMPLER2DMSARRAY  */
-#line 2831 "MachineIndependent/glslang.y"
+  case 415: /* type_specifier_nonarray: SAMPLER2DMSARRAY  */
+#line 2885 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
     }
-#line 9060 "MachineIndependent/glslang_tab.cpp"
+#line 9534 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 410: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY  */
-#line 2836 "MachineIndependent/glslang.y"
+  case 416: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY  */
+#line 2890 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
     }
-#line 9071 "MachineIndependent/glslang_tab.cpp"
+#line 9545 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 411: /* type_specifier_nonarray: ISAMPLER2DMSARRAY  */
-#line 2842 "MachineIndependent/glslang.y"
+  case 417: /* type_specifier_nonarray: ISAMPLER2DMSARRAY  */
+#line 2896 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
     }
-#line 9081 "MachineIndependent/glslang_tab.cpp"
+#line 9555 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 412: /* type_specifier_nonarray: USAMPLER2DMSARRAY  */
-#line 2847 "MachineIndependent/glslang.y"
+  case 418: /* type_specifier_nonarray: USAMPLER2DMSARRAY  */
+#line 2901 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
     }
-#line 9091 "MachineIndependent/glslang_tab.cpp"
+#line 9565 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 413: /* type_specifier_nonarray: TEXTURE1D  */
-#line 2852 "MachineIndependent/glslang.y"
+  case 419: /* type_specifier_nonarray: TEXTURE1D  */
+#line 2906 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
     }
-#line 9101 "MachineIndependent/glslang_tab.cpp"
+#line 9575 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 414: /* type_specifier_nonarray: F16TEXTURE1D  */
-#line 2857 "MachineIndependent/glslang.y"
+  case 420: /* type_specifier_nonarray: F16TEXTURE1D  */
+#line 2911 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
     }
-#line 9112 "MachineIndependent/glslang_tab.cpp"
+#line 9586 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 415: /* type_specifier_nonarray: F16TEXTURE2D  */
-#line 2863 "MachineIndependent/glslang.y"
+  case 421: /* type_specifier_nonarray: F16TEXTURE2D  */
+#line 2917 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
     }
-#line 9123 "MachineIndependent/glslang_tab.cpp"
+#line 9597 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 416: /* type_specifier_nonarray: F16TEXTURE3D  */
-#line 2869 "MachineIndependent/glslang.y"
+  case 422: /* type_specifier_nonarray: F16TEXTURE3D  */
+#line 2923 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
     }
-#line 9134 "MachineIndependent/glslang_tab.cpp"
+#line 9608 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 417: /* type_specifier_nonarray: F16TEXTURECUBE  */
-#line 2875 "MachineIndependent/glslang.y"
+  case 423: /* type_specifier_nonarray: F16TEXTURECUBE  */
+#line 2929 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
     }
-#line 9145 "MachineIndependent/glslang_tab.cpp"
+#line 9619 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 418: /* type_specifier_nonarray: TEXTURE1DARRAY  */
-#line 2881 "MachineIndependent/glslang.y"
+  case 424: /* type_specifier_nonarray: TEXTURE1DARRAY  */
+#line 2935 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
     }
-#line 9155 "MachineIndependent/glslang_tab.cpp"
+#line 9629 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 419: /* type_specifier_nonarray: F16TEXTURE1DARRAY  */
-#line 2886 "MachineIndependent/glslang.y"
+  case 425: /* type_specifier_nonarray: F16TEXTURE1DARRAY  */
+#line 2940 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
     }
-#line 9166 "MachineIndependent/glslang_tab.cpp"
+#line 9640 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 420: /* type_specifier_nonarray: F16TEXTURE2DARRAY  */
-#line 2892 "MachineIndependent/glslang.y"
+  case 426: /* type_specifier_nonarray: F16TEXTURE2DARRAY  */
+#line 2946 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
     }
-#line 9177 "MachineIndependent/glslang_tab.cpp"
+#line 9651 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 421: /* type_specifier_nonarray: F16TEXTURECUBEARRAY  */
-#line 2898 "MachineIndependent/glslang.y"
+  case 427: /* type_specifier_nonarray: F16TEXTURECUBEARRAY  */
+#line 2952 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
     }
-#line 9188 "MachineIndependent/glslang_tab.cpp"
+#line 9662 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 422: /* type_specifier_nonarray: ITEXTURE1D  */
-#line 2904 "MachineIndependent/glslang.y"
+  case 428: /* type_specifier_nonarray: ITEXTURE1D  */
+#line 2958 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
     }
-#line 9198 "MachineIndependent/glslang_tab.cpp"
+#line 9672 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 423: /* type_specifier_nonarray: ITEXTURE1DARRAY  */
-#line 2909 "MachineIndependent/glslang.y"
+  case 429: /* type_specifier_nonarray: ITEXTURE1DARRAY  */
+#line 2963 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
     }
-#line 9208 "MachineIndependent/glslang_tab.cpp"
+#line 9682 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 424: /* type_specifier_nonarray: UTEXTURE1D  */
-#line 2914 "MachineIndependent/glslang.y"
+  case 430: /* type_specifier_nonarray: UTEXTURE1D  */
+#line 2968 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
     }
-#line 9218 "MachineIndependent/glslang_tab.cpp"
+#line 9692 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 425: /* type_specifier_nonarray: UTEXTURE1DARRAY  */
-#line 2919 "MachineIndependent/glslang.y"
+  case 431: /* type_specifier_nonarray: UTEXTURE1DARRAY  */
+#line 2973 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
     }
-#line 9228 "MachineIndependent/glslang_tab.cpp"
+#line 9702 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 426: /* type_specifier_nonarray: TEXTURE2DRECT  */
-#line 2924 "MachineIndependent/glslang.y"
+  case 432: /* type_specifier_nonarray: TEXTURE2DRECT  */
+#line 2978 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
     }
-#line 9238 "MachineIndependent/glslang_tab.cpp"
+#line 9712 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 427: /* type_specifier_nonarray: F16TEXTURE2DRECT  */
-#line 2929 "MachineIndependent/glslang.y"
+  case 433: /* type_specifier_nonarray: F16TEXTURE2DRECT  */
+#line 2983 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
     }
-#line 9249 "MachineIndependent/glslang_tab.cpp"
+#line 9723 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 428: /* type_specifier_nonarray: ITEXTURE2DRECT  */
-#line 2935 "MachineIndependent/glslang.y"
+  case 434: /* type_specifier_nonarray: ITEXTURE2DRECT  */
+#line 2989 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
     }
-#line 9259 "MachineIndependent/glslang_tab.cpp"
+#line 9733 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 429: /* type_specifier_nonarray: UTEXTURE2DRECT  */
-#line 2940 "MachineIndependent/glslang.y"
+  case 435: /* type_specifier_nonarray: UTEXTURE2DRECT  */
+#line 2994 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
     }
-#line 9269 "MachineIndependent/glslang_tab.cpp"
+#line 9743 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 430: /* type_specifier_nonarray: TEXTUREBUFFER  */
-#line 2945 "MachineIndependent/glslang.y"
+  case 436: /* type_specifier_nonarray: TEXTUREBUFFER  */
+#line 2999 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
     }
-#line 9279 "MachineIndependent/glslang_tab.cpp"
+#line 9753 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 431: /* type_specifier_nonarray: F16TEXTUREBUFFER  */
-#line 2950 "MachineIndependent/glslang.y"
+  case 437: /* type_specifier_nonarray: F16TEXTUREBUFFER  */
+#line 3004 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
     }
-#line 9290 "MachineIndependent/glslang_tab.cpp"
+#line 9764 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 432: /* type_specifier_nonarray: ITEXTUREBUFFER  */
-#line 2956 "MachineIndependent/glslang.y"
+  case 438: /* type_specifier_nonarray: ITEXTUREBUFFER  */
+#line 3010 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
     }
-#line 9300 "MachineIndependent/glslang_tab.cpp"
+#line 9774 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 433: /* type_specifier_nonarray: UTEXTUREBUFFER  */
-#line 2961 "MachineIndependent/glslang.y"
+  case 439: /* type_specifier_nonarray: UTEXTUREBUFFER  */
+#line 3015 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
     }
-#line 9310 "MachineIndependent/glslang_tab.cpp"
+#line 9784 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 434: /* type_specifier_nonarray: TEXTURE2DMS  */
-#line 2966 "MachineIndependent/glslang.y"
+  case 440: /* type_specifier_nonarray: TEXTURE2DMS  */
+#line 3020 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
     }
-#line 9320 "MachineIndependent/glslang_tab.cpp"
+#line 9794 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 435: /* type_specifier_nonarray: F16TEXTURE2DMS  */
-#line 2971 "MachineIndependent/glslang.y"
+  case 441: /* type_specifier_nonarray: F16TEXTURE2DMS  */
+#line 3025 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
     }
-#line 9331 "MachineIndependent/glslang_tab.cpp"
+#line 9805 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 436: /* type_specifier_nonarray: ITEXTURE2DMS  */
-#line 2977 "MachineIndependent/glslang.y"
+  case 442: /* type_specifier_nonarray: ITEXTURE2DMS  */
+#line 3031 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
     }
-#line 9341 "MachineIndependent/glslang_tab.cpp"
+#line 9815 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 437: /* type_specifier_nonarray: UTEXTURE2DMS  */
-#line 2982 "MachineIndependent/glslang.y"
+  case 443: /* type_specifier_nonarray: UTEXTURE2DMS  */
+#line 3036 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
     }
-#line 9351 "MachineIndependent/glslang_tab.cpp"
+#line 9825 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 438: /* type_specifier_nonarray: TEXTURE2DMSARRAY  */
-#line 2987 "MachineIndependent/glslang.y"
+  case 444: /* type_specifier_nonarray: TEXTURE2DMSARRAY  */
+#line 3041 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
     }
-#line 9361 "MachineIndependent/glslang_tab.cpp"
+#line 9835 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 439: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY  */
-#line 2992 "MachineIndependent/glslang.y"
+  case 445: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY  */
+#line 3046 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
     }
-#line 9372 "MachineIndependent/glslang_tab.cpp"
+#line 9846 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 440: /* type_specifier_nonarray: ITEXTURE2DMSARRAY  */
-#line 2998 "MachineIndependent/glslang.y"
+  case 446: /* type_specifier_nonarray: ITEXTURE2DMSARRAY  */
+#line 3052 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
     }
-#line 9382 "MachineIndependent/glslang_tab.cpp"
+#line 9856 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 441: /* type_specifier_nonarray: UTEXTURE2DMSARRAY  */
-#line 3003 "MachineIndependent/glslang.y"
+  case 447: /* type_specifier_nonarray: UTEXTURE2DMSARRAY  */
+#line 3057 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
     }
-#line 9392 "MachineIndependent/glslang_tab.cpp"
+#line 9866 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 442: /* type_specifier_nonarray: IMAGE1D  */
-#line 3008 "MachineIndependent/glslang.y"
+  case 448: /* type_specifier_nonarray: IMAGE1D  */
+#line 3062 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
     }
-#line 9402 "MachineIndependent/glslang_tab.cpp"
+#line 9876 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 443: /* type_specifier_nonarray: F16IMAGE1D  */
-#line 3013 "MachineIndependent/glslang.y"
+  case 449: /* type_specifier_nonarray: F16IMAGE1D  */
+#line 3067 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
     }
-#line 9413 "MachineIndependent/glslang_tab.cpp"
+#line 9887 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 444: /* type_specifier_nonarray: IIMAGE1D  */
-#line 3019 "MachineIndependent/glslang.y"
+  case 450: /* type_specifier_nonarray: IIMAGE1D  */
+#line 3073 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
     }
-#line 9423 "MachineIndependent/glslang_tab.cpp"
+#line 9897 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 445: /* type_specifier_nonarray: UIMAGE1D  */
-#line 3024 "MachineIndependent/glslang.y"
+  case 451: /* type_specifier_nonarray: UIMAGE1D  */
+#line 3078 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
     }
-#line 9433 "MachineIndependent/glslang_tab.cpp"
+#line 9907 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 446: /* type_specifier_nonarray: IMAGE2D  */
-#line 3029 "MachineIndependent/glslang.y"
+  case 452: /* type_specifier_nonarray: IMAGE2D  */
+#line 3083 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
     }
-#line 9443 "MachineIndependent/glslang_tab.cpp"
+#line 9917 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 447: /* type_specifier_nonarray: F16IMAGE2D  */
-#line 3034 "MachineIndependent/glslang.y"
+  case 453: /* type_specifier_nonarray: F16IMAGE2D  */
+#line 3088 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
     }
-#line 9454 "MachineIndependent/glslang_tab.cpp"
+#line 9928 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 448: /* type_specifier_nonarray: IIMAGE2D  */
-#line 3040 "MachineIndependent/glslang.y"
+  case 454: /* type_specifier_nonarray: IIMAGE2D  */
+#line 3094 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
     }
-#line 9464 "MachineIndependent/glslang_tab.cpp"
+#line 9938 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 449: /* type_specifier_nonarray: UIMAGE2D  */
-#line 3045 "MachineIndependent/glslang.y"
+  case 455: /* type_specifier_nonarray: UIMAGE2D  */
+#line 3099 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
     }
-#line 9474 "MachineIndependent/glslang_tab.cpp"
+#line 9948 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 450: /* type_specifier_nonarray: IMAGE3D  */
-#line 3050 "MachineIndependent/glslang.y"
+  case 456: /* type_specifier_nonarray: IMAGE3D  */
+#line 3104 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
     }
-#line 9484 "MachineIndependent/glslang_tab.cpp"
+#line 9958 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 451: /* type_specifier_nonarray: F16IMAGE3D  */
-#line 3055 "MachineIndependent/glslang.y"
+  case 457: /* type_specifier_nonarray: F16IMAGE3D  */
+#line 3109 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
     }
-#line 9495 "MachineIndependent/glslang_tab.cpp"
+#line 9969 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 452: /* type_specifier_nonarray: IIMAGE3D  */
-#line 3061 "MachineIndependent/glslang.y"
+  case 458: /* type_specifier_nonarray: IIMAGE3D  */
+#line 3115 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
     }
-#line 9505 "MachineIndependent/glslang_tab.cpp"
+#line 9979 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 453: /* type_specifier_nonarray: UIMAGE3D  */
-#line 3066 "MachineIndependent/glslang.y"
+  case 459: /* type_specifier_nonarray: UIMAGE3D  */
+#line 3120 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
     }
-#line 9515 "MachineIndependent/glslang_tab.cpp"
+#line 9989 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 454: /* type_specifier_nonarray: IMAGE2DRECT  */
-#line 3071 "MachineIndependent/glslang.y"
+  case 460: /* type_specifier_nonarray: IMAGE2DRECT  */
+#line 3125 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
     }
-#line 9525 "MachineIndependent/glslang_tab.cpp"
+#line 9999 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 455: /* type_specifier_nonarray: F16IMAGE2DRECT  */
-#line 3076 "MachineIndependent/glslang.y"
+  case 461: /* type_specifier_nonarray: F16IMAGE2DRECT  */
+#line 3130 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
     }
-#line 9536 "MachineIndependent/glslang_tab.cpp"
+#line 10010 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 456: /* type_specifier_nonarray: IIMAGE2DRECT  */
-#line 3082 "MachineIndependent/glslang.y"
+  case 462: /* type_specifier_nonarray: IIMAGE2DRECT  */
+#line 3136 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
     }
-#line 9546 "MachineIndependent/glslang_tab.cpp"
+#line 10020 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 457: /* type_specifier_nonarray: UIMAGE2DRECT  */
-#line 3087 "MachineIndependent/glslang.y"
+  case 463: /* type_specifier_nonarray: UIMAGE2DRECT  */
+#line 3141 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
     }
-#line 9556 "MachineIndependent/glslang_tab.cpp"
+#line 10030 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 458: /* type_specifier_nonarray: IMAGECUBE  */
-#line 3092 "MachineIndependent/glslang.y"
+  case 464: /* type_specifier_nonarray: IMAGECUBE  */
+#line 3146 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
     }
-#line 9566 "MachineIndependent/glslang_tab.cpp"
+#line 10040 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 459: /* type_specifier_nonarray: F16IMAGECUBE  */
-#line 3097 "MachineIndependent/glslang.y"
+  case 465: /* type_specifier_nonarray: F16IMAGECUBE  */
+#line 3151 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
     }
-#line 9577 "MachineIndependent/glslang_tab.cpp"
+#line 10051 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 460: /* type_specifier_nonarray: IIMAGECUBE  */
-#line 3103 "MachineIndependent/glslang.y"
+  case 466: /* type_specifier_nonarray: IIMAGECUBE  */
+#line 3157 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
     }
-#line 9587 "MachineIndependent/glslang_tab.cpp"
+#line 10061 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 461: /* type_specifier_nonarray: UIMAGECUBE  */
-#line 3108 "MachineIndependent/glslang.y"
+  case 467: /* type_specifier_nonarray: UIMAGECUBE  */
+#line 3162 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
     }
-#line 9597 "MachineIndependent/glslang_tab.cpp"
+#line 10071 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 462: /* type_specifier_nonarray: IMAGEBUFFER  */
-#line 3113 "MachineIndependent/glslang.y"
+  case 468: /* type_specifier_nonarray: IMAGEBUFFER  */
+#line 3167 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
     }
-#line 9607 "MachineIndependent/glslang_tab.cpp"
+#line 10081 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 463: /* type_specifier_nonarray: F16IMAGEBUFFER  */
-#line 3118 "MachineIndependent/glslang.y"
+  case 469: /* type_specifier_nonarray: F16IMAGEBUFFER  */
+#line 3172 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
     }
-#line 9618 "MachineIndependent/glslang_tab.cpp"
+#line 10092 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 464: /* type_specifier_nonarray: IIMAGEBUFFER  */
-#line 3124 "MachineIndependent/glslang.y"
+  case 470: /* type_specifier_nonarray: IIMAGEBUFFER  */
+#line 3178 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
     }
-#line 9628 "MachineIndependent/glslang_tab.cpp"
+#line 10102 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 465: /* type_specifier_nonarray: UIMAGEBUFFER  */
-#line 3129 "MachineIndependent/glslang.y"
+  case 471: /* type_specifier_nonarray: UIMAGEBUFFER  */
+#line 3183 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
     }
-#line 9638 "MachineIndependent/glslang_tab.cpp"
+#line 10112 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 466: /* type_specifier_nonarray: IMAGE1DARRAY  */
-#line 3134 "MachineIndependent/glslang.y"
+  case 472: /* type_specifier_nonarray: IMAGE1DARRAY  */
+#line 3188 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
     }
-#line 9648 "MachineIndependent/glslang_tab.cpp"
+#line 10122 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 467: /* type_specifier_nonarray: F16IMAGE1DARRAY  */
-#line 3139 "MachineIndependent/glslang.y"
+  case 473: /* type_specifier_nonarray: F16IMAGE1DARRAY  */
+#line 3193 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
     }
-#line 9659 "MachineIndependent/glslang_tab.cpp"
+#line 10133 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 468: /* type_specifier_nonarray: IIMAGE1DARRAY  */
-#line 3145 "MachineIndependent/glslang.y"
+  case 474: /* type_specifier_nonarray: IIMAGE1DARRAY  */
+#line 3199 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
     }
-#line 9669 "MachineIndependent/glslang_tab.cpp"
+#line 10143 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 469: /* type_specifier_nonarray: UIMAGE1DARRAY  */
-#line 3150 "MachineIndependent/glslang.y"
+  case 475: /* type_specifier_nonarray: UIMAGE1DARRAY  */
+#line 3204 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
     }
-#line 9679 "MachineIndependent/glslang_tab.cpp"
+#line 10153 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 470: /* type_specifier_nonarray: IMAGE2DARRAY  */
-#line 3155 "MachineIndependent/glslang.y"
+  case 476: /* type_specifier_nonarray: IMAGE2DARRAY  */
+#line 3209 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
     }
-#line 9689 "MachineIndependent/glslang_tab.cpp"
+#line 10163 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 471: /* type_specifier_nonarray: F16IMAGE2DARRAY  */
-#line 3160 "MachineIndependent/glslang.y"
+  case 477: /* type_specifier_nonarray: F16IMAGE2DARRAY  */
+#line 3214 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
     }
-#line 9700 "MachineIndependent/glslang_tab.cpp"
+#line 10174 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 472: /* type_specifier_nonarray: IIMAGE2DARRAY  */
-#line 3166 "MachineIndependent/glslang.y"
+  case 478: /* type_specifier_nonarray: IIMAGE2DARRAY  */
+#line 3220 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
     }
-#line 9710 "MachineIndependent/glslang_tab.cpp"
+#line 10184 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 473: /* type_specifier_nonarray: UIMAGE2DARRAY  */
-#line 3171 "MachineIndependent/glslang.y"
+  case 479: /* type_specifier_nonarray: UIMAGE2DARRAY  */
+#line 3225 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
     }
-#line 9720 "MachineIndependent/glslang_tab.cpp"
+#line 10194 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 474: /* type_specifier_nonarray: IMAGECUBEARRAY  */
-#line 3176 "MachineIndependent/glslang.y"
+  case 480: /* type_specifier_nonarray: IMAGECUBEARRAY  */
+#line 3230 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true);
     }
-#line 9730 "MachineIndependent/glslang_tab.cpp"
+#line 10204 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 475: /* type_specifier_nonarray: F16IMAGECUBEARRAY  */
-#line 3181 "MachineIndependent/glslang.y"
+  case 481: /* type_specifier_nonarray: F16IMAGECUBEARRAY  */
+#line 3235 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
     }
-#line 9741 "MachineIndependent/glslang_tab.cpp"
+#line 10215 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 476: /* type_specifier_nonarray: IIMAGECUBEARRAY  */
-#line 3187 "MachineIndependent/glslang.y"
+  case 482: /* type_specifier_nonarray: IIMAGECUBEARRAY  */
+#line 3241 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
     }
-#line 9751 "MachineIndependent/glslang_tab.cpp"
+#line 10225 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 477: /* type_specifier_nonarray: UIMAGECUBEARRAY  */
-#line 3192 "MachineIndependent/glslang.y"
+  case 483: /* type_specifier_nonarray: UIMAGECUBEARRAY  */
+#line 3246 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
     }
-#line 9761 "MachineIndependent/glslang_tab.cpp"
+#line 10235 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 478: /* type_specifier_nonarray: IMAGE2DMS  */
-#line 3197 "MachineIndependent/glslang.y"
+  case 484: /* type_specifier_nonarray: IMAGE2DMS  */
+#line 3251 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
     }
-#line 9771 "MachineIndependent/glslang_tab.cpp"
+#line 10245 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 479: /* type_specifier_nonarray: F16IMAGE2DMS  */
-#line 3202 "MachineIndependent/glslang.y"
+  case 485: /* type_specifier_nonarray: F16IMAGE2DMS  */
+#line 3256 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
     }
-#line 9782 "MachineIndependent/glslang_tab.cpp"
+#line 10256 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 480: /* type_specifier_nonarray: IIMAGE2DMS  */
-#line 3208 "MachineIndependent/glslang.y"
+  case 486: /* type_specifier_nonarray: IIMAGE2DMS  */
+#line 3262 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
     }
-#line 9792 "MachineIndependent/glslang_tab.cpp"
+#line 10266 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 481: /* type_specifier_nonarray: UIMAGE2DMS  */
-#line 3213 "MachineIndependent/glslang.y"
+  case 487: /* type_specifier_nonarray: UIMAGE2DMS  */
+#line 3267 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
     }
-#line 9802 "MachineIndependent/glslang_tab.cpp"
+#line 10276 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 482: /* type_specifier_nonarray: IMAGE2DMSARRAY  */
-#line 3218 "MachineIndependent/glslang.y"
+  case 488: /* type_specifier_nonarray: IMAGE2DMSARRAY  */
+#line 3272 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
     }
-#line 9812 "MachineIndependent/glslang_tab.cpp"
+#line 10286 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 483: /* type_specifier_nonarray: F16IMAGE2DMSARRAY  */
-#line 3223 "MachineIndependent/glslang.y"
+  case 489: /* type_specifier_nonarray: F16IMAGE2DMSARRAY  */
+#line 3277 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
     }
-#line 9823 "MachineIndependent/glslang_tab.cpp"
+#line 10297 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 484: /* type_specifier_nonarray: IIMAGE2DMSARRAY  */
-#line 3229 "MachineIndependent/glslang.y"
+  case 490: /* type_specifier_nonarray: IIMAGE2DMSARRAY  */
+#line 3283 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
     }
-#line 9833 "MachineIndependent/glslang_tab.cpp"
+#line 10307 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 485: /* type_specifier_nonarray: UIMAGE2DMSARRAY  */
-#line 3234 "MachineIndependent/glslang.y"
+  case 491: /* type_specifier_nonarray: UIMAGE2DMSARRAY  */
+#line 3288 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
     }
-#line 9843 "MachineIndependent/glslang_tab.cpp"
+#line 10317 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 486: /* type_specifier_nonarray: I64IMAGE1D  */
-#line 3239 "MachineIndependent/glslang.y"
+  case 492: /* type_specifier_nonarray: I64IMAGE1D  */
+#line 3293 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D);
     }
-#line 9853 "MachineIndependent/glslang_tab.cpp"
+#line 10327 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 487: /* type_specifier_nonarray: U64IMAGE1D  */
-#line 3244 "MachineIndependent/glslang.y"
+  case 493: /* type_specifier_nonarray: U64IMAGE1D  */
+#line 3298 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D);
     }
-#line 9863 "MachineIndependent/glslang_tab.cpp"
+#line 10337 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 488: /* type_specifier_nonarray: I64IMAGE2D  */
-#line 3249 "MachineIndependent/glslang.y"
+  case 494: /* type_specifier_nonarray: I64IMAGE2D  */
+#line 3303 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D);
     }
-#line 9873 "MachineIndependent/glslang_tab.cpp"
+#line 10347 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 489: /* type_specifier_nonarray: U64IMAGE2D  */
-#line 3254 "MachineIndependent/glslang.y"
+  case 495: /* type_specifier_nonarray: U64IMAGE2D  */
+#line 3308 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D);
     }
-#line 9883 "MachineIndependent/glslang_tab.cpp"
+#line 10357 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 490: /* type_specifier_nonarray: I64IMAGE3D  */
-#line 3259 "MachineIndependent/glslang.y"
+  case 496: /* type_specifier_nonarray: I64IMAGE3D  */
+#line 3313 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D);
     }
-#line 9893 "MachineIndependent/glslang_tab.cpp"
+#line 10367 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 491: /* type_specifier_nonarray: U64IMAGE3D  */
-#line 3264 "MachineIndependent/glslang.y"
+  case 497: /* type_specifier_nonarray: U64IMAGE3D  */
+#line 3318 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd3D);
     }
-#line 9903 "MachineIndependent/glslang_tab.cpp"
+#line 10377 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 492: /* type_specifier_nonarray: I64IMAGE2DRECT  */
-#line 3269 "MachineIndependent/glslang.y"
+  case 498: /* type_specifier_nonarray: I64IMAGE2DRECT  */
+#line 3323 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdRect);
     }
-#line 9913 "MachineIndependent/glslang_tab.cpp"
+#line 10387 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 493: /* type_specifier_nonarray: U64IMAGE2DRECT  */
-#line 3274 "MachineIndependent/glslang.y"
+  case 499: /* type_specifier_nonarray: U64IMAGE2DRECT  */
+#line 3328 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdRect);
     }
-#line 9923 "MachineIndependent/glslang_tab.cpp"
+#line 10397 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 494: /* type_specifier_nonarray: I64IMAGECUBE  */
-#line 3279 "MachineIndependent/glslang.y"
+  case 500: /* type_specifier_nonarray: I64IMAGECUBE  */
+#line 3333 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube);
     }
-#line 9933 "MachineIndependent/glslang_tab.cpp"
+#line 10407 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 495: /* type_specifier_nonarray: U64IMAGECUBE  */
-#line 3284 "MachineIndependent/glslang.y"
+  case 501: /* type_specifier_nonarray: U64IMAGECUBE  */
+#line 3338 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube);
     }
-#line 9943 "MachineIndependent/glslang_tab.cpp"
+#line 10417 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 496: /* type_specifier_nonarray: I64IMAGEBUFFER  */
-#line 3289 "MachineIndependent/glslang.y"
+  case 502: /* type_specifier_nonarray: I64IMAGEBUFFER  */
+#line 3343 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdBuffer);
     }
-#line 9953 "MachineIndependent/glslang_tab.cpp"
+#line 10427 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 497: /* type_specifier_nonarray: U64IMAGEBUFFER  */
-#line 3294 "MachineIndependent/glslang.y"
+  case 503: /* type_specifier_nonarray: U64IMAGEBUFFER  */
+#line 3348 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdBuffer);
     }
-#line 9963 "MachineIndependent/glslang_tab.cpp"
+#line 10437 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 498: /* type_specifier_nonarray: I64IMAGE1DARRAY  */
-#line 3299 "MachineIndependent/glslang.y"
+  case 504: /* type_specifier_nonarray: I64IMAGE1DARRAY  */
+#line 3353 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D, true);
     }
-#line 9973 "MachineIndependent/glslang_tab.cpp"
+#line 10447 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 499: /* type_specifier_nonarray: U64IMAGE1DARRAY  */
-#line 3304 "MachineIndependent/glslang.y"
+  case 505: /* type_specifier_nonarray: U64IMAGE1DARRAY  */
+#line 3358 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D, true);
     }
-#line 9983 "MachineIndependent/glslang_tab.cpp"
+#line 10457 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 500: /* type_specifier_nonarray: I64IMAGE2DARRAY  */
-#line 3309 "MachineIndependent/glslang.y"
+  case 506: /* type_specifier_nonarray: I64IMAGE2DARRAY  */
+#line 3363 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true);
     }
-#line 9993 "MachineIndependent/glslang_tab.cpp"
+#line 10467 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 501: /* type_specifier_nonarray: U64IMAGE2DARRAY  */
-#line 3314 "MachineIndependent/glslang.y"
+  case 507: /* type_specifier_nonarray: U64IMAGE2DARRAY  */
+#line 3368 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true);
     }
-#line 10003 "MachineIndependent/glslang_tab.cpp"
+#line 10477 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 502: /* type_specifier_nonarray: I64IMAGECUBEARRAY  */
-#line 3319 "MachineIndependent/glslang.y"
+  case 508: /* type_specifier_nonarray: I64IMAGECUBEARRAY  */
+#line 3373 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube, true);
     }
-#line 10013 "MachineIndependent/glslang_tab.cpp"
+#line 10487 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 503: /* type_specifier_nonarray: U64IMAGECUBEARRAY  */
-#line 3324 "MachineIndependent/glslang.y"
+  case 509: /* type_specifier_nonarray: U64IMAGECUBEARRAY  */
+#line 3378 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube, true);
     }
-#line 10023 "MachineIndependent/glslang_tab.cpp"
+#line 10497 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 504: /* type_specifier_nonarray: I64IMAGE2DMS  */
-#line 3329 "MachineIndependent/glslang.y"
+  case 510: /* type_specifier_nonarray: I64IMAGE2DMS  */
+#line 3383 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, false, false, true);
     }
-#line 10033 "MachineIndependent/glslang_tab.cpp"
+#line 10507 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 505: /* type_specifier_nonarray: U64IMAGE2DMS  */
-#line 3334 "MachineIndependent/glslang.y"
+  case 511: /* type_specifier_nonarray: U64IMAGE2DMS  */
+#line 3388 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, false, false, true);
     }
-#line 10043 "MachineIndependent/glslang_tab.cpp"
+#line 10517 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 506: /* type_specifier_nonarray: I64IMAGE2DMSARRAY  */
-#line 3339 "MachineIndependent/glslang.y"
+  case 512: /* type_specifier_nonarray: I64IMAGE2DMSARRAY  */
+#line 3393 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true, false, true);
     }
-#line 10053 "MachineIndependent/glslang_tab.cpp"
+#line 10527 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 507: /* type_specifier_nonarray: U64IMAGE2DMSARRAY  */
-#line 3344 "MachineIndependent/glslang.y"
+  case 513: /* type_specifier_nonarray: U64IMAGE2DMSARRAY  */
+#line 3398 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true, false, true);
     }
-#line 10063 "MachineIndependent/glslang_tab.cpp"
+#line 10537 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 508: /* type_specifier_nonarray: SAMPLEREXTERNALOES  */
-#line 3349 "MachineIndependent/glslang.y"
+  case 514: /* type_specifier_nonarray: SAMPLEREXTERNALOES  */
+#line 3403 "MachineIndependent/glslang.y"
                          {  // GL_OES_EGL_image_external
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.external = true;
     }
-#line 10074 "MachineIndependent/glslang_tab.cpp"
+#line 10548 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 509: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT  */
-#line 3355 "MachineIndependent/glslang.y"
+  case 515: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT  */
+#line 3409 "MachineIndependent/glslang.y"
                               { // GL_EXT_YUV_target
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.yuv = true;
     }
-#line 10085 "MachineIndependent/glslang_tab.cpp"
+#line 10559 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 510: /* type_specifier_nonarray: SUBPASSINPUT  */
-#line 3361 "MachineIndependent/glslang.y"
+  case 516: /* type_specifier_nonarray: SUBPASSINPUT  */
+#line 3415 "MachineIndependent/glslang.y"
                    {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat);
     }
-#line 10096 "MachineIndependent/glslang_tab.cpp"
+#line 10570 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 511: /* type_specifier_nonarray: SUBPASSINPUTMS  */
-#line 3367 "MachineIndependent/glslang.y"
+  case 517: /* type_specifier_nonarray: SUBPASSINPUTMS  */
+#line 3421 "MachineIndependent/glslang.y"
                      {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
     }
-#line 10107 "MachineIndependent/glslang_tab.cpp"
+#line 10581 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 512: /* type_specifier_nonarray: F16SUBPASSINPUT  */
-#line 3373 "MachineIndependent/glslang.y"
+  case 518: /* type_specifier_nonarray: F16SUBPASSINPUT  */
+#line 3427 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -10115,11 +10589,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
     }
-#line 10119 "MachineIndependent/glslang_tab.cpp"
+#line 10593 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 513: /* type_specifier_nonarray: F16SUBPASSINPUTMS  */
-#line 3380 "MachineIndependent/glslang.y"
+  case 519: /* type_specifier_nonarray: F16SUBPASSINPUTMS  */
+#line 3434 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -10127,98 +10601,107 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
     }
-#line 10131 "MachineIndependent/glslang_tab.cpp"
+#line 10605 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 514: /* type_specifier_nonarray: ISUBPASSINPUT  */
-#line 3387 "MachineIndependent/glslang.y"
+  case 520: /* type_specifier_nonarray: ISUBPASSINPUT  */
+#line 3441 "MachineIndependent/glslang.y"
                     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt);
     }
-#line 10142 "MachineIndependent/glslang_tab.cpp"
+#line 10616 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 515: /* type_specifier_nonarray: ISUBPASSINPUTMS  */
-#line 3393 "MachineIndependent/glslang.y"
+  case 521: /* type_specifier_nonarray: ISUBPASSINPUTMS  */
+#line 3447 "MachineIndependent/glslang.y"
                       {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt, true);
     }
-#line 10153 "MachineIndependent/glslang_tab.cpp"
+#line 10627 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 516: /* type_specifier_nonarray: USUBPASSINPUT  */
-#line 3399 "MachineIndependent/glslang.y"
+  case 522: /* type_specifier_nonarray: USUBPASSINPUT  */
+#line 3453 "MachineIndependent/glslang.y"
                     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint);
     }
-#line 10164 "MachineIndependent/glslang_tab.cpp"
+#line 10638 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 517: /* type_specifier_nonarray: USUBPASSINPUTMS  */
-#line 3405 "MachineIndependent/glslang.y"
+  case 523: /* type_specifier_nonarray: USUBPASSINPUTMS  */
+#line 3459 "MachineIndependent/glslang.y"
                       {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint, true);
     }
-#line 10175 "MachineIndependent/glslang_tab.cpp"
+#line 10649 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 518: /* type_specifier_nonarray: FCOOPMATNV  */
-#line 3411 "MachineIndependent/glslang.y"
+  case 524: /* type_specifier_nonarray: FCOOPMATNV  */
+#line 3465 "MachineIndependent/glslang.y"
                  {
         parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).coopmat = true;
     }
-#line 10186 "MachineIndependent/glslang_tab.cpp"
+#line 10660 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 519: /* type_specifier_nonarray: ICOOPMATNV  */
-#line 3417 "MachineIndependent/glslang.y"
+  case 525: /* type_specifier_nonarray: ICOOPMATNV  */
+#line 3471 "MachineIndependent/glslang.y"
                  {
         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).coopmat = true;
     }
-#line 10197 "MachineIndependent/glslang_tab.cpp"
+#line 10671 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 520: /* type_specifier_nonarray: UCOOPMATNV  */
-#line 3423 "MachineIndependent/glslang.y"
+  case 526: /* type_specifier_nonarray: UCOOPMATNV  */
+#line 3477 "MachineIndependent/glslang.y"
                  {
         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).coopmat = true;
     }
-#line 10208 "MachineIndependent/glslang_tab.cpp"
+#line 10682 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 521: /* type_specifier_nonarray: struct_specifier  */
-#line 3430 "MachineIndependent/glslang.y"
+  case 527: /* type_specifier_nonarray: spirv_type_specifier  */
+#line 3483 "MachineIndependent/glslang.y"
+                           {
+        parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
+        (yyval.interm.type) = (yyvsp[0].interm.type);
+    }
+#line 10691 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 528: /* type_specifier_nonarray: struct_specifier  */
+#line 3488 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type) = (yyvsp[0].interm.type);
         (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
     }
-#line 10218 "MachineIndependent/glslang_tab.cpp"
+#line 10701 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 522: /* type_specifier_nonarray: TYPE_NAME  */
-#line 3435 "MachineIndependent/glslang.y"
+  case 529: /* type_specifier_nonarray: TYPE_NAME  */
+#line 3493 "MachineIndependent/glslang.y"
                 {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -10232,47 +10715,47 @@ yyreduce:
         } else
             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
     }
-#line 10236 "MachineIndependent/glslang_tab.cpp"
+#line 10719 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 523: /* precision_qualifier: HIGH_PRECISION  */
-#line 3451 "MachineIndependent/glslang.y"
+  case 530: /* precision_qualifier: HIGH_PRECISION  */
+#line 3509 "MachineIndependent/glslang.y"
                      {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
     }
-#line 10246 "MachineIndependent/glslang_tab.cpp"
+#line 10729 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 524: /* precision_qualifier: MEDIUM_PRECISION  */
-#line 3456 "MachineIndependent/glslang.y"
+  case 531: /* precision_qualifier: MEDIUM_PRECISION  */
+#line 3514 "MachineIndependent/glslang.y"
                        {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
     }
-#line 10256 "MachineIndependent/glslang_tab.cpp"
+#line 10739 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 525: /* precision_qualifier: LOW_PRECISION  */
-#line 3461 "MachineIndependent/glslang.y"
+  case 532: /* precision_qualifier: LOW_PRECISION  */
+#line 3519 "MachineIndependent/glslang.y"
                     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
     }
-#line 10266 "MachineIndependent/glslang_tab.cpp"
+#line 10749 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 526: /* $@3: %empty  */
-#line 3469 "MachineIndependent/glslang.y"
+  case 533: /* $@3: %empty  */
+#line 3527 "MachineIndependent/glslang.y"
                                    { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
-#line 10272 "MachineIndependent/glslang_tab.cpp"
+#line 10755 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 527: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE  */
-#line 3469 "MachineIndependent/glslang.y"
+  case 534: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE  */
+#line 3527 "MachineIndependent/glslang.y"
                                                                                                                    {
         TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
         parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
@@ -10284,17 +10767,17 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 10288 "MachineIndependent/glslang_tab.cpp"
+#line 10771 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 528: /* $@4: %empty  */
-#line 3480 "MachineIndependent/glslang.y"
+  case 535: /* $@4: %empty  */
+#line 3538 "MachineIndependent/glslang.y"
                         { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
-#line 10294 "MachineIndependent/glslang_tab.cpp"
+#line 10777 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 529: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE  */
-#line 3480 "MachineIndependent/glslang.y"
+  case 536: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE  */
+#line 3538 "MachineIndependent/glslang.y"
                                                                                                         {
         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[-4].lex).loc);
@@ -10302,19 +10785,19 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 10306 "MachineIndependent/glslang_tab.cpp"
+#line 10789 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 530: /* struct_declaration_list: struct_declaration  */
-#line 3490 "MachineIndependent/glslang.y"
+  case 537: /* struct_declaration_list: struct_declaration  */
+#line 3548 "MachineIndependent/glslang.y"
                          {
         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
     }
-#line 10314 "MachineIndependent/glslang_tab.cpp"
+#line 10797 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 531: /* struct_declaration_list: struct_declaration_list struct_declaration  */
-#line 3493 "MachineIndependent/glslang.y"
+  case 538: /* struct_declaration_list: struct_declaration_list struct_declaration  */
+#line 3551 "MachineIndependent/glslang.y"
                                                  {
         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
         for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
@@ -10325,11 +10808,11 @@ yyreduce:
             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
         }
     }
-#line 10329 "MachineIndependent/glslang_tab.cpp"
+#line 10812 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 532: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON  */
-#line 3506 "MachineIndependent/glslang.y"
+  case 539: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON  */
+#line 3564 "MachineIndependent/glslang.y"
                                                       {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -10352,11 +10835,11 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 10356 "MachineIndependent/glslang_tab.cpp"
+#line 10839 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 533: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON  */
-#line 3528 "MachineIndependent/glslang.y"
+  case 540: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON  */
+#line 3586 "MachineIndependent/glslang.y"
                                                                      {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -10381,38 +10864,38 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 10385 "MachineIndependent/glslang_tab.cpp"
+#line 10868 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 534: /* struct_declarator_list: struct_declarator  */
-#line 3555 "MachineIndependent/glslang.y"
+  case 541: /* struct_declarator_list: struct_declarator  */
+#line 3613 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 10394 "MachineIndependent/glslang_tab.cpp"
+#line 10877 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 535: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator  */
-#line 3559 "MachineIndependent/glslang.y"
+  case 542: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator  */
+#line 3617 "MachineIndependent/glslang.y"
                                                      {
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 10402 "MachineIndependent/glslang_tab.cpp"
+#line 10885 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 536: /* struct_declarator: IDENTIFIER  */
-#line 3565 "MachineIndependent/glslang.y"
+  case 543: /* struct_declarator: IDENTIFIER  */
+#line 3623 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.typeLine).type = new TType(EbtVoid);
         (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
     }
-#line 10412 "MachineIndependent/glslang_tab.cpp"
+#line 10895 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 537: /* struct_declarator: IDENTIFIER array_specifier  */
-#line 3570 "MachineIndependent/glslang.y"
+  case 544: /* struct_declarator: IDENTIFIER array_specifier  */
+#line 3628 "MachineIndependent/glslang.y"
                                  {
         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
 
@@ -10421,246 +10904,246 @@ yyreduce:
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
     }
-#line 10425 "MachineIndependent/glslang_tab.cpp"
+#line 10908 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 538: /* initializer: assignment_expression  */
-#line 3581 "MachineIndependent/glslang.y"
+  case 545: /* initializer: assignment_expression  */
+#line 3639 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 10433 "MachineIndependent/glslang_tab.cpp"
+#line 10916 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 539: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE  */
-#line 3585 "MachineIndependent/glslang.y"
+  case 546: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE  */
+#line 3643 "MachineIndependent/glslang.y"
                                               {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
     }
-#line 10444 "MachineIndependent/glslang_tab.cpp"
+#line 10927 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 540: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE  */
-#line 3591 "MachineIndependent/glslang.y"
+  case 547: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE  */
+#line 3649 "MachineIndependent/glslang.y"
                                                     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 10455 "MachineIndependent/glslang_tab.cpp"
+#line 10938 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 541: /* initializer: LEFT_BRACE RIGHT_BRACE  */
-#line 3597 "MachineIndependent/glslang.y"
+  case 548: /* initializer: LEFT_BRACE RIGHT_BRACE  */
+#line 3655 "MachineIndependent/glslang.y"
                              {
         const char* initFeature = "empty { } initializer";
         parseContext.profileRequires((yyvsp[-1].lex).loc, EEsProfile, 0, E_GL_EXT_null_initializer, initFeature);
         parseContext.profileRequires((yyvsp[-1].lex).loc, ~EEsProfile, 0, E_GL_EXT_null_initializer, initFeature);
         (yyval.interm.intermTypedNode) = parseContext.intermediate.makeAggregate((yyvsp[-1].lex).loc);
     }
-#line 10466 "MachineIndependent/glslang_tab.cpp"
+#line 10949 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 542: /* initializer_list: initializer  */
-#line 3608 "MachineIndependent/glslang.y"
+  case 549: /* initializer_list: initializer  */
+#line 3666 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
     }
-#line 10474 "MachineIndependent/glslang_tab.cpp"
+#line 10957 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 543: /* initializer_list: initializer_list COMMA initializer  */
-#line 3611 "MachineIndependent/glslang.y"
+  case 550: /* initializer_list: initializer_list COMMA initializer  */
+#line 3669 "MachineIndependent/glslang.y"
                                          {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 10482 "MachineIndependent/glslang_tab.cpp"
+#line 10965 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 544: /* declaration_statement: declaration  */
-#line 3618 "MachineIndependent/glslang.y"
+  case 551: /* declaration_statement: declaration  */
+#line 3676 "MachineIndependent/glslang.y"
                   { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10488 "MachineIndependent/glslang_tab.cpp"
+#line 10971 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 545: /* statement: compound_statement  */
-#line 3622 "MachineIndependent/glslang.y"
+  case 552: /* statement: compound_statement  */
+#line 3680 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10494 "MachineIndependent/glslang_tab.cpp"
+#line 10977 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 546: /* statement: simple_statement  */
-#line 3623 "MachineIndependent/glslang.y"
+  case 553: /* statement: simple_statement  */
+#line 3681 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10500 "MachineIndependent/glslang_tab.cpp"
+#line 10983 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 547: /* simple_statement: declaration_statement  */
-#line 3629 "MachineIndependent/glslang.y"
+  case 554: /* simple_statement: declaration_statement  */
+#line 3687 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10506 "MachineIndependent/glslang_tab.cpp"
+#line 10989 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 548: /* simple_statement: expression_statement  */
-#line 3630 "MachineIndependent/glslang.y"
+  case 555: /* simple_statement: expression_statement  */
+#line 3688 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10512 "MachineIndependent/glslang_tab.cpp"
+#line 10995 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 549: /* simple_statement: selection_statement  */
-#line 3631 "MachineIndependent/glslang.y"
+  case 556: /* simple_statement: selection_statement  */
+#line 3689 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10518 "MachineIndependent/glslang_tab.cpp"
+#line 11001 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 550: /* simple_statement: switch_statement  */
-#line 3632 "MachineIndependent/glslang.y"
+  case 557: /* simple_statement: switch_statement  */
+#line 3690 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10524 "MachineIndependent/glslang_tab.cpp"
+#line 11007 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 551: /* simple_statement: case_label  */
-#line 3633 "MachineIndependent/glslang.y"
+  case 558: /* simple_statement: case_label  */
+#line 3691 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10530 "MachineIndependent/glslang_tab.cpp"
+#line 11013 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 552: /* simple_statement: iteration_statement  */
-#line 3634 "MachineIndependent/glslang.y"
+  case 559: /* simple_statement: iteration_statement  */
+#line 3692 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10536 "MachineIndependent/glslang_tab.cpp"
+#line 11019 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 553: /* simple_statement: jump_statement  */
-#line 3635 "MachineIndependent/glslang.y"
+  case 560: /* simple_statement: jump_statement  */
+#line 3693 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10542 "MachineIndependent/glslang_tab.cpp"
+#line 11025 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 554: /* simple_statement: demote_statement  */
-#line 3637 "MachineIndependent/glslang.y"
+  case 561: /* simple_statement: demote_statement  */
+#line 3695 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10548 "MachineIndependent/glslang_tab.cpp"
+#line 11031 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 555: /* demote_statement: DEMOTE SEMICOLON  */
-#line 3643 "MachineIndependent/glslang.y"
+  case 562: /* demote_statement: DEMOTE SEMICOLON  */
+#line 3701 "MachineIndependent/glslang.y"
                        {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote");
         parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc);
     }
-#line 10558 "MachineIndependent/glslang_tab.cpp"
+#line 11041 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 556: /* compound_statement: LEFT_BRACE RIGHT_BRACE  */
-#line 3652 "MachineIndependent/glslang.y"
+  case 563: /* compound_statement: LEFT_BRACE RIGHT_BRACE  */
+#line 3710 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermNode) = 0; }
-#line 10564 "MachineIndependent/glslang_tab.cpp"
+#line 11047 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 557: /* $@5: %empty  */
-#line 3653 "MachineIndependent/glslang.y"
+  case 564: /* $@5: %empty  */
+#line 3711 "MachineIndependent/glslang.y"
                  {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
-#line 10573 "MachineIndependent/glslang_tab.cpp"
+#line 11056 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 558: /* $@6: %empty  */
-#line 3657 "MachineIndependent/glslang.y"
+  case 565: /* $@6: %empty  */
+#line 3715 "MachineIndependent/glslang.y"
                      {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
-#line 10582 "MachineIndependent/glslang_tab.cpp"
+#line 11065 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 559: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE  */
-#line 3661 "MachineIndependent/glslang.y"
+  case 566: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE  */
+#line 3719 "MachineIndependent/glslang.y"
                   {
         if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate())
             (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
     }
-#line 10592 "MachineIndependent/glslang_tab.cpp"
+#line 11075 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 560: /* statement_no_new_scope: compound_statement_no_new_scope  */
-#line 3669 "MachineIndependent/glslang.y"
+  case 567: /* statement_no_new_scope: compound_statement_no_new_scope  */
+#line 3727 "MachineIndependent/glslang.y"
                                       { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10598 "MachineIndependent/glslang_tab.cpp"
+#line 11081 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 561: /* statement_no_new_scope: simple_statement  */
-#line 3670 "MachineIndependent/glslang.y"
+  case 568: /* statement_no_new_scope: simple_statement  */
+#line 3728 "MachineIndependent/glslang.y"
                                       { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 10604 "MachineIndependent/glslang_tab.cpp"
+#line 11087 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 562: /* $@7: %empty  */
-#line 3674 "MachineIndependent/glslang.y"
+  case 569: /* $@7: %empty  */
+#line 3732 "MachineIndependent/glslang.y"
       {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10612 "MachineIndependent/glslang_tab.cpp"
+#line 11095 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 563: /* statement_scoped: $@7 compound_statement  */
-#line 3677 "MachineIndependent/glslang.y"
+  case 570: /* statement_scoped: $@7 compound_statement  */
+#line 3735 "MachineIndependent/glslang.y"
                           {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10621 "MachineIndependent/glslang_tab.cpp"
+#line 11104 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 564: /* $@8: %empty  */
-#line 3681 "MachineIndependent/glslang.y"
+  case 571: /* $@8: %empty  */
+#line 3739 "MachineIndependent/glslang.y"
       {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10631 "MachineIndependent/glslang_tab.cpp"
+#line 11114 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 565: /* statement_scoped: $@8 simple_statement  */
-#line 3686 "MachineIndependent/glslang.y"
+  case 572: /* statement_scoped: $@8 simple_statement  */
+#line 3744 "MachineIndependent/glslang.y"
                        {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10642 "MachineIndependent/glslang_tab.cpp"
+#line 11125 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 566: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE  */
-#line 3695 "MachineIndependent/glslang.y"
+  case 573: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE  */
+#line 3753 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.intermNode) = 0;
     }
-#line 10650 "MachineIndependent/glslang_tab.cpp"
+#line 11133 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 567: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE  */
-#line 3698 "MachineIndependent/glslang.y"
+  case 574: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE  */
+#line 3756 "MachineIndependent/glslang.y"
                                             {
         if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate())
             (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
     }
-#line 10660 "MachineIndependent/glslang_tab.cpp"
+#line 11143 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 568: /* statement_list: statement  */
-#line 3706 "MachineIndependent/glslang.y"
+  case 575: /* statement_list: statement  */
+#line 3764 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
@@ -10669,11 +11152,11 @@ yyreduce:
             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
         }
     }
-#line 10673 "MachineIndependent/glslang_tab.cpp"
+#line 11156 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 569: /* statement_list: statement_list statement  */
-#line 3714 "MachineIndependent/glslang.y"
+  case 576: /* statement_list: statement_list statement  */
+#line 3772 "MachineIndependent/glslang.y"
                                {
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
@@ -10682,77 +11165,77 @@ yyreduce:
         } else
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 10686 "MachineIndependent/glslang_tab.cpp"
+#line 11169 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 570: /* expression_statement: SEMICOLON  */
-#line 3725 "MachineIndependent/glslang.y"
+  case 577: /* expression_statement: SEMICOLON  */
+#line 3783 "MachineIndependent/glslang.y"
                  { (yyval.interm.intermNode) = 0; }
-#line 10692 "MachineIndependent/glslang_tab.cpp"
+#line 11175 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 571: /* expression_statement: expression SEMICOLON  */
-#line 3726 "MachineIndependent/glslang.y"
+  case 578: /* expression_statement: expression SEMICOLON  */
+#line 3784 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
-#line 10698 "MachineIndependent/glslang_tab.cpp"
+#line 11181 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 572: /* selection_statement: selection_statement_nonattributed  */
-#line 3730 "MachineIndependent/glslang.y"
+  case 579: /* selection_statement: selection_statement_nonattributed  */
+#line 3788 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10706 "MachineIndependent/glslang_tab.cpp"
+#line 11189 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 573: /* selection_statement: attribute selection_statement_nonattributed  */
-#line 3734 "MachineIndependent/glslang.y"
+  case 580: /* selection_statement: attribute selection_statement_nonattributed  */
+#line 3792 "MachineIndependent/glslang.y"
                                                   {
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10716 "MachineIndependent/glslang_tab.cpp"
+#line 11199 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 574: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement  */
-#line 3742 "MachineIndependent/glslang.y"
+  case 581: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement  */
+#line 3800 "MachineIndependent/glslang.y"
                                                                     {
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
         (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
     }
-#line 10725 "MachineIndependent/glslang_tab.cpp"
+#line 11208 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 575: /* selection_rest_statement: statement_scoped ELSE statement_scoped  */
-#line 3749 "MachineIndependent/glslang.y"
+  case 582: /* selection_rest_statement: statement_scoped ELSE statement_scoped  */
+#line 3807 "MachineIndependent/glslang.y"
                                              {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
     }
-#line 10734 "MachineIndependent/glslang_tab.cpp"
+#line 11217 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 576: /* selection_rest_statement: statement_scoped  */
-#line 3753 "MachineIndependent/glslang.y"
+  case 583: /* selection_rest_statement: statement_scoped  */
+#line 3811 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 10743 "MachineIndependent/glslang_tab.cpp"
+#line 11226 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 577: /* condition: expression  */
-#line 3761 "MachineIndependent/glslang.y"
+  case 584: /* condition: expression  */
+#line 3819 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
     }
-#line 10752 "MachineIndependent/glslang_tab.cpp"
+#line 11235 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 578: /* condition: fully_specified_type IDENTIFIER EQUAL initializer  */
-#line 3765 "MachineIndependent/glslang.y"
+  case 585: /* condition: fully_specified_type IDENTIFIER EQUAL initializer  */
+#line 3823 "MachineIndependent/glslang.y"
                                                         {
         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
 
@@ -10763,29 +11246,29 @@ yyreduce:
         else
             (yyval.interm.intermTypedNode) = 0;
     }
-#line 10767 "MachineIndependent/glslang_tab.cpp"
+#line 11250 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 579: /* switch_statement: switch_statement_nonattributed  */
-#line 3778 "MachineIndependent/glslang.y"
+  case 586: /* switch_statement: switch_statement_nonattributed  */
+#line 3836 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10775 "MachineIndependent/glslang_tab.cpp"
+#line 11258 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 580: /* switch_statement: attribute switch_statement_nonattributed  */
-#line 3782 "MachineIndependent/glslang.y"
+  case 587: /* switch_statement: attribute switch_statement_nonattributed  */
+#line 3840 "MachineIndependent/glslang.y"
                                                {
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10785 "MachineIndependent/glslang_tab.cpp"
+#line 11268 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 581: /* $@9: %empty  */
-#line 3790 "MachineIndependent/glslang.y"
+  case 588: /* $@9: %empty  */
+#line 3848 "MachineIndependent/glslang.y"
                                                {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -10794,11 +11277,11 @@ yyreduce:
         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
         parseContext.symbolTable.push();
     }
-#line 10798 "MachineIndependent/glslang_tab.cpp"
+#line 11281 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 582: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE  */
-#line 3798 "MachineIndependent/glslang.y"
+  case 589: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE  */
+#line 3856 "MachineIndependent/glslang.y"
                                                  {
         (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
         delete parseContext.switchSequenceStack.back();
@@ -10808,27 +11291,27 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10812 "MachineIndependent/glslang_tab.cpp"
+#line 11295 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 583: /* switch_statement_list: %empty  */
-#line 3810 "MachineIndependent/glslang.y"
+  case 590: /* switch_statement_list: %empty  */
+#line 3868 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = 0;
     }
-#line 10820 "MachineIndependent/glslang_tab.cpp"
+#line 11303 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 584: /* switch_statement_list: statement_list  */
-#line 3813 "MachineIndependent/glslang.y"
+  case 591: /* switch_statement_list: statement_list  */
+#line 3871 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10828 "MachineIndependent/glslang_tab.cpp"
+#line 11311 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 585: /* case_label: CASE expression COLON  */
-#line 3819 "MachineIndependent/glslang.y"
+  case 592: /* case_label: CASE expression COLON  */
+#line 3877 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -10841,11 +11324,11 @@ yyreduce:
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
         }
     }
-#line 10845 "MachineIndependent/glslang_tab.cpp"
+#line 11328 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 586: /* case_label: DEFAULT COLON  */
-#line 3831 "MachineIndependent/glslang.y"
+  case 593: /* case_label: DEFAULT COLON  */
+#line 3889 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -10855,29 +11338,29 @@ yyreduce:
         else
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
     }
-#line 10859 "MachineIndependent/glslang_tab.cpp"
+#line 11342 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 587: /* iteration_statement: iteration_statement_nonattributed  */
-#line 3843 "MachineIndependent/glslang.y"
+  case 594: /* iteration_statement: iteration_statement_nonattributed  */
+#line 3901 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10867 "MachineIndependent/glslang_tab.cpp"
+#line 11350 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 588: /* iteration_statement: attribute iteration_statement_nonattributed  */
-#line 3847 "MachineIndependent/glslang.y"
+  case 595: /* iteration_statement: attribute iteration_statement_nonattributed  */
+#line 3905 "MachineIndependent/glslang.y"
                                                   {
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10877 "MachineIndependent/glslang_tab.cpp"
+#line 11360 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 589: /* $@10: %empty  */
-#line 3855 "MachineIndependent/glslang.y"
+  case 596: /* $@10: %empty  */
+#line 3913 "MachineIndependent/glslang.y"
                        {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
@@ -10886,11 +11369,11 @@ yyreduce:
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10890 "MachineIndependent/glslang_tab.cpp"
+#line 11373 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 590: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope  */
-#line 3863 "MachineIndependent/glslang.y"
+  case 597: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope  */
+#line 3921 "MachineIndependent/glslang.y"
                                                    {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc);
@@ -10898,21 +11381,21 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10902 "MachineIndependent/glslang_tab.cpp"
+#line 11385 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 591: /* $@11: %empty  */
-#line 3870 "MachineIndependent/glslang.y"
+  case 598: /* $@11: %empty  */
+#line 3928 "MachineIndependent/glslang.y"
          {
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10912 "MachineIndependent/glslang_tab.cpp"
+#line 11395 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 592: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON  */
-#line 3875 "MachineIndependent/glslang.y"
+  case 599: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON  */
+#line 3933 "MachineIndependent/glslang.y"
                                                                   {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
@@ -10924,22 +11407,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10928 "MachineIndependent/glslang_tab.cpp"
+#line 11411 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 593: /* $@12: %empty  */
-#line 3886 "MachineIndependent/glslang.y"
+  case 600: /* $@12: %empty  */
+#line 3944 "MachineIndependent/glslang.y"
                      {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10939 "MachineIndependent/glslang_tab.cpp"
+#line 11422 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 594: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope  */
-#line 3892 "MachineIndependent/glslang.y"
+  case 601: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope  */
+#line 3950 "MachineIndependent/glslang.y"
                                                                                {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
@@ -10952,81 +11435,81 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10956 "MachineIndependent/glslang_tab.cpp"
+#line 11439 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 595: /* for_init_statement: expression_statement  */
-#line 3907 "MachineIndependent/glslang.y"
+  case 602: /* for_init_statement: expression_statement  */
+#line 3965 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10964 "MachineIndependent/glslang_tab.cpp"
+#line 11447 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 596: /* for_init_statement: declaration_statement  */
-#line 3910 "MachineIndependent/glslang.y"
+  case 603: /* for_init_statement: declaration_statement  */
+#line 3968 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10972 "MachineIndependent/glslang_tab.cpp"
+#line 11455 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 597: /* conditionopt: condition  */
-#line 3916 "MachineIndependent/glslang.y"
+  case 604: /* conditionopt: condition  */
+#line 3974 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 10980 "MachineIndependent/glslang_tab.cpp"
+#line 11463 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 598: /* conditionopt: %empty  */
-#line 3919 "MachineIndependent/glslang.y"
+  case 605: /* conditionopt: %empty  */
+#line 3977 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.intermTypedNode) = 0;
     }
-#line 10988 "MachineIndependent/glslang_tab.cpp"
+#line 11471 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 599: /* for_rest_statement: conditionopt SEMICOLON  */
-#line 3925 "MachineIndependent/glslang.y"
+  case 606: /* for_rest_statement: conditionopt SEMICOLON  */
+#line 3983 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 10997 "MachineIndependent/glslang_tab.cpp"
+#line 11480 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 600: /* for_rest_statement: conditionopt SEMICOLON expression  */
-#line 3929 "MachineIndependent/glslang.y"
+  case 607: /* for_rest_statement: conditionopt SEMICOLON expression  */
+#line 3987 "MachineIndependent/glslang.y"
                                          {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
     }
-#line 11006 "MachineIndependent/glslang_tab.cpp"
+#line 11489 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 601: /* jump_statement: CONTINUE SEMICOLON  */
-#line 3936 "MachineIndependent/glslang.y"
+  case 608: /* jump_statement: CONTINUE SEMICOLON  */
+#line 3994 "MachineIndependent/glslang.y"
                          {
         if (parseContext.loopNestingLevel <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
     }
-#line 11016 "MachineIndependent/glslang_tab.cpp"
+#line 11499 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 602: /* jump_statement: BREAK SEMICOLON  */
-#line 3941 "MachineIndependent/glslang.y"
+  case 609: /* jump_statement: BREAK SEMICOLON  */
+#line 3999 "MachineIndependent/glslang.y"
                       {
         if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
     }
-#line 11026 "MachineIndependent/glslang_tab.cpp"
+#line 11509 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 603: /* jump_statement: RETURN SEMICOLON  */
-#line 3946 "MachineIndependent/glslang.y"
+  case 610: /* jump_statement: RETURN SEMICOLON  */
+#line 4004 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -11034,101 +11517,101 @@ yyreduce:
         if (parseContext.inMain)
             parseContext.postEntryPointReturn = true;
     }
-#line 11038 "MachineIndependent/glslang_tab.cpp"
+#line 11521 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 604: /* jump_statement: RETURN expression SEMICOLON  */
-#line 3953 "MachineIndependent/glslang.y"
+  case 611: /* jump_statement: RETURN expression SEMICOLON  */
+#line 4011 "MachineIndependent/glslang.y"
                                   {
         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 11046 "MachineIndependent/glslang_tab.cpp"
+#line 11529 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 605: /* jump_statement: DISCARD SEMICOLON  */
-#line 3956 "MachineIndependent/glslang.y"
+  case 612: /* jump_statement: DISCARD SEMICOLON  */
+#line 4014 "MachineIndependent/glslang.y"
                         {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
     }
-#line 11055 "MachineIndependent/glslang_tab.cpp"
+#line 11538 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 606: /* jump_statement: TERMINATE_INVOCATION SEMICOLON  */
-#line 3960 "MachineIndependent/glslang.y"
+  case 613: /* jump_statement: TERMINATE_INVOCATION SEMICOLON  */
+#line 4018 "MachineIndependent/glslang.y"
                                      {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc);
     }
-#line 11064 "MachineIndependent/glslang_tab.cpp"
+#line 11547 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 607: /* jump_statement: TERMINATE_RAY SEMICOLON  */
-#line 3965 "MachineIndependent/glslang.y"
+  case 614: /* jump_statement: TERMINATE_RAY SEMICOLON  */
+#line 4023 "MachineIndependent/glslang.y"
                               {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc);
     }
-#line 11073 "MachineIndependent/glslang_tab.cpp"
+#line 11556 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 608: /* jump_statement: IGNORE_INTERSECTION SEMICOLON  */
-#line 3969 "MachineIndependent/glslang.y"
+  case 615: /* jump_statement: IGNORE_INTERSECTION SEMICOLON  */
+#line 4027 "MachineIndependent/glslang.y"
                                     {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc);
     }
-#line 11082 "MachineIndependent/glslang_tab.cpp"
+#line 11565 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 609: /* translation_unit: external_declaration  */
-#line 3979 "MachineIndependent/glslang.y"
+  case 616: /* translation_unit: external_declaration  */
+#line 4037 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
-#line 11091 "MachineIndependent/glslang_tab.cpp"
+#line 11574 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 610: /* translation_unit: translation_unit external_declaration  */
-#line 3983 "MachineIndependent/glslang.y"
+  case 617: /* translation_unit: translation_unit external_declaration  */
+#line 4041 "MachineIndependent/glslang.y"
                                             {
         if ((yyvsp[0].interm.intermNode) != nullptr) {
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
             parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
         }
     }
-#line 11102 "MachineIndependent/glslang_tab.cpp"
+#line 11585 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 611: /* external_declaration: function_definition  */
-#line 3992 "MachineIndependent/glslang.y"
+  case 618: /* external_declaration: function_definition  */
+#line 4050 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11110 "MachineIndependent/glslang_tab.cpp"
+#line 11593 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 612: /* external_declaration: declaration  */
-#line 3995 "MachineIndependent/glslang.y"
+  case 619: /* external_declaration: declaration  */
+#line 4053 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11118 "MachineIndependent/glslang_tab.cpp"
+#line 11601 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 613: /* external_declaration: SEMICOLON  */
-#line 3999 "MachineIndependent/glslang.y"
+  case 620: /* external_declaration: SEMICOLON  */
+#line 4057 "MachineIndependent/glslang.y"
                 {
         parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
         parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
         (yyval.interm.intermNode) = nullptr;
     }
-#line 11128 "MachineIndependent/glslang_tab.cpp"
+#line 11611 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 614: /* $@13: %empty  */
-#line 4008 "MachineIndependent/glslang.y"
+  case 621: /* $@13: %empty  */
+#line 4066 "MachineIndependent/glslang.y"
                          {
         (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
         (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
@@ -11141,11 +11624,11 @@ yyreduce:
             ++parseContext.statementNestingLevel;
         }
     }
-#line 11145 "MachineIndependent/glslang_tab.cpp"
+#line 11628 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 615: /* function_definition: function_prototype $@13 compound_statement_no_new_scope  */
-#line 4020 "MachineIndependent/glslang.y"
+  case 622: /* function_definition: function_prototype $@13 compound_statement_no_new_scope  */
+#line 4078 "MachineIndependent/glslang.y"
                                     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -11172,51 +11655,563 @@ yyreduce:
             --parseContext.statementNestingLevel;
         }
     }
-#line 11176 "MachineIndependent/glslang_tab.cpp"
+#line 11659 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 616: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET  */
-#line 4050 "MachineIndependent/glslang.y"
+  case 623: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET  */
+#line 4108 "MachineIndependent/glslang.y"
                                                                            {
         (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
     }
-#line 11184 "MachineIndependent/glslang_tab.cpp"
+#line 11667 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 617: /* attribute_list: single_attribute  */
-#line 4055 "MachineIndependent/glslang.y"
+  case 624: /* attribute_list: single_attribute  */
+#line 4113 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
     }
-#line 11192 "MachineIndependent/glslang_tab.cpp"
+#line 11675 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 618: /* attribute_list: attribute_list COMMA single_attribute  */
-#line 4058 "MachineIndependent/glslang.y"
+  case 625: /* attribute_list: attribute_list COMMA single_attribute  */
+#line 4116 "MachineIndependent/glslang.y"
                                             {
         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
     }
-#line 11200 "MachineIndependent/glslang_tab.cpp"
+#line 11683 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 619: /* single_attribute: IDENTIFIER  */
-#line 4063 "MachineIndependent/glslang.y"
+  case 626: /* single_attribute: IDENTIFIER  */
+#line 4121 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
     }
-#line 11208 "MachineIndependent/glslang_tab.cpp"
+#line 11691 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 620: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN  */
-#line 4066 "MachineIndependent/glslang.y"
+  case 627: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN  */
+#line 4124 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 11216 "MachineIndependent/glslang_tab.cpp"
+#line 11699 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 628: /* spirv_requirements_list: spirv_requirements_parameter  */
+#line 4131 "MachineIndependent/glslang.y"
+                                   {
+        (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq);
+    }
+#line 11707 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 629: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter  */
+#line 4134 "MachineIndependent/glslang.y"
+                                                                 {
+        (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq));
+    }
+#line 11715 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 630: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET  */
+#line 4139 "MachineIndependent/glslang.y"
+                                                                       {
+        (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr);
+    }
+#line 11723 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 631: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET  */
+#line 4142 "MachineIndependent/glslang.y"
+                                                                        {
+        (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11731 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 632: /* spirv_extension_list: STRING_LITERAL  */
+#line 4147 "MachineIndependent/glslang.y"
+                     {
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
+    }
+#line 11739 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 633: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL  */
+#line 4150 "MachineIndependent/glslang.y"
+                                                {
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
+    }
+#line 11747 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 634: /* spirv_capability_list: INTCONSTANT  */
+#line 4155 "MachineIndependent/glslang.y"
+                  {
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true));
+    }
+#line 11755 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 635: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT  */
+#line 4158 "MachineIndependent/glslang.y"
+                                              {
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true));
+    }
+#line 11763 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 636: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4163 "MachineIndependent/glslang.y"
+                                                              {
+        parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i);
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11772 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 637: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4167 "MachineIndependent/glslang.y"
+                                                                                            {
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
+        parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i);
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11782 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 638: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
+#line 4172 "MachineIndependent/glslang.y"
+                                                                                                        {
+        parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11791 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 639: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
+#line 4176 "MachineIndependent/glslang.y"
+                                                                                                                                      {
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11801 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 640: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
+#line 4181 "MachineIndependent/glslang.y"
+                                                                                                              {
+        parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11810 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 641: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
+#line 4185 "MachineIndependent/glslang.y"
+                                                                                                                                            {
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+        (yyval.interm.intermNode) = 0;
+    }
+#line 11820 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 642: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter  */
+#line 4192 "MachineIndependent/glslang.y"
+                                     {
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
+    }
+#line 11828 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 643: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter  */
+#line 4195 "MachineIndependent/glslang.y"
+                                                                               {
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode));
+    }
+#line 11836 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 644: /* spirv_execution_mode_parameter: FLOATCONSTANT  */
+#line 4200 "MachineIndependent/glslang.y"
+                    {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
+    }
+#line 11844 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 645: /* spirv_execution_mode_parameter: INTCONSTANT  */
+#line 4203 "MachineIndependent/glslang.y"
+                  {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
+    }
+#line 11852 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 646: /* spirv_execution_mode_parameter: UINTCONSTANT  */
+#line 4206 "MachineIndependent/glslang.y"
+                   {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
+    }
+#line 11860 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 647: /* spirv_execution_mode_parameter: BOOLCONSTANT  */
+#line 4209 "MachineIndependent/glslang.y"
+                   {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
+    }
+#line 11868 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 648: /* spirv_execution_mode_parameter: STRING_LITERAL  */
+#line 4212 "MachineIndependent/glslang.y"
+                     {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
+    }
+#line 11876 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 649: /* spirv_execution_mode_id_parameter_list: constant_expression  */
+#line 4217 "MachineIndependent/glslang.y"
+                          {
+        if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtUint &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtBool &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtString)
+            parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode));
+    }
+#line 11890 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 650: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression  */
+#line 4226 "MachineIndependent/glslang.y"
+                                                                       {
+        if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtUint &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtBool &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtString)
+            parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode));
+    }
+#line 11904 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 651: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4237 "MachineIndependent/glslang.y"
+                                                             {
+        (yyval.interm.type).init((yyvsp[-3].lex).loc);
+        (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass;
+        (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i;
+    }
+#line 11914 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 652: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4242 "MachineIndependent/glslang.y"
+                                                                                           {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc);
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
+        (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass;
+        (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i;
+    }
+#line 11925 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 653: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4250 "MachineIndependent/glslang.y"
+                                                       {
+        (yyval.interm.type).init((yyvsp[-3].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i);
+    }
+#line 11934 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 654: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4254 "MachineIndependent/glslang.y"
+                                                                                     {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc);
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
+        (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i);
+    }
+#line 11944 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 655: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
+#line 4259 "MachineIndependent/glslang.y"
+                                                                                            {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11953 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 656: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
+#line 4263 "MachineIndependent/glslang.y"
+                                                                                                                          {
+        (yyval.interm.type).init((yyvsp[-7].lex).loc);
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11963 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 657: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
+#line 4268 "MachineIndependent/glslang.y"
+                                                                                                  {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11972 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 658: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
+#line 4272 "MachineIndependent/glslang.y"
+                                                                                                                                {
+        (yyval.interm.type).init((yyvsp[-7].lex).loc);
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11982 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 659: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
+#line 4277 "MachineIndependent/glslang.y"
+                                                                                                          {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc);
+        (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 11991 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 660: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
+#line 4281 "MachineIndependent/glslang.y"
+                                                                                                                                        {
+        (yyval.interm.type).init((yyvsp[-7].lex).loc);
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
+    }
+#line 12001 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 661: /* spirv_decorate_parameter_list: spirv_decorate_parameter  */
+#line 4288 "MachineIndependent/glslang.y"
+                               {
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
+    }
+#line 12009 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 662: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter  */
+#line 4291 "MachineIndependent/glslang.y"
+                                                                   {
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode));
+    }
+#line 12017 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 663: /* spirv_decorate_parameter: FLOATCONSTANT  */
+#line 4296 "MachineIndependent/glslang.y"
+                    {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
+    }
+#line 12025 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 664: /* spirv_decorate_parameter: INTCONSTANT  */
+#line 4299 "MachineIndependent/glslang.y"
+                  {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
+    }
+#line 12033 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 665: /* spirv_decorate_parameter: UINTCONSTANT  */
+#line 4302 "MachineIndependent/glslang.y"
+                   {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
+    }
+#line 12041 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 666: /* spirv_decorate_parameter: BOOLCONSTANT  */
+#line 4305 "MachineIndependent/glslang.y"
+                   {
+        (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
+    }
+#line 12049 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 667: /* spirv_decorate_id_parameter_list: constant_expression  */
+#line 4310 "MachineIndependent/glslang.y"
+                          {
+        if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtUint &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtBool)
+            parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode));
+    }
+#line 12062 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 668: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA constant_expression  */
+#line 4318 "MachineIndependent/glslang.y"
+                                                                 {
+        if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtUint &&
+            (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtBool)
+            parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode));
+    }
+#line 12075 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 669: /* spirv_decorate_string_parameter_list: STRING_LITERAL  */
+#line 4328 "MachineIndependent/glslang.y"
+                     {
+        (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(
+            parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
+    }
+#line 12084 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 670: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL  */
+#line 4332 "MachineIndependent/glslang.y"
+                                                                {
+        (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
+    }
+#line 12092 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 671: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
+#line 4337 "MachineIndependent/glslang.y"
+                                                                                                         {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams));
+    }
+#line 12101 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 672: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
+#line 4341 "MachineIndependent/glslang.y"
+                                                                                                                                       {
+        (yyval.interm.type).init((yyvsp[-7].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
+        (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams));
+    }
+#line 12111 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 673: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4346 "MachineIndependent/glslang.y"
+                                                                         {
+        (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst));
+    }
+#line 12120 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 674: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4350 "MachineIndependent/glslang.y"
+                                                                                                       {
+        (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
+        (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst));
+    }
+#line 12130 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 675: /* spirv_type_parameter_list: spirv_type_parameter  */
+#line 4357 "MachineIndependent/glslang.y"
+                           {
+        (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams);
+    }
+#line 12138 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 676: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter  */
+#line 4360 "MachineIndependent/glslang.y"
+                                                           {
+        (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams));
+    }
+#line 12146 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 677: /* spirv_type_parameter: constant_expression  */
+#line 4365 "MachineIndependent/glslang.y"
+                          {
+        (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion());
+    }
+#line 12154 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 678: /* spirv_type_parameter: type_specifier  */
+#line 4368 "MachineIndependent/glslang.y"
+                     {
+        (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type));
+    }
+#line 12162 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 679: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4373 "MachineIndependent/glslang.y"
+                                                                                {
+        (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst);
+    }
+#line 12170 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 680: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4376 "MachineIndependent/glslang.y"
+                                                                                                              {
+        parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
+        (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst);
+    }
+#line 12179 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 681: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id  */
+#line 4382 "MachineIndependent/glslang.y"
+                                     {
+        (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst);
+    }
+#line 12187 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 682: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id  */
+#line 4385 "MachineIndependent/glslang.y"
+                                                                            {
+        (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst));
+    }
+#line 12195 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 683: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL  */
+#line 4390 "MachineIndependent/glslang.y"
+                                      {
+        (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string);
+    }
+#line 12203 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 684: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT  */
+#line 4393 "MachineIndependent/glslang.y"
+                                   {
+        (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i);
+    }
+#line 12211 "MachineIndependent/glslang_tab.cpp"
     break;
 
 
-#line 11220 "MachineIndependent/glslang_tab.cpp"
+#line 12215 "MachineIndependent/glslang_tab.cpp"
 
       default: break;
     }
@@ -11441,5 +12436,5 @@ yyreturn:
   return yyresult;
 }
 
-#line 4071 "MachineIndependent/glslang.y"
+#line 4398 "MachineIndependent/glslang.y"
 

diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
index 7f69477..596a10e 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.7.5.  */
+/* A Bison parser, made by GNU Bison 3.7.4.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
    Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -368,134 +368,144 @@ extern int yydebug;
     USUBPASSINPUTMS = 569,         /* USUBPASSINPUTMS  */
     F16SUBPASSINPUT = 570,         /* F16SUBPASSINPUT  */
     F16SUBPASSINPUTMS = 571,       /* F16SUBPASSINPUTMS  */
-    LEFT_OP = 572,                 /* LEFT_OP  */
-    RIGHT_OP = 573,                /* RIGHT_OP  */
-    INC_OP = 574,                  /* INC_OP  */
-    DEC_OP = 575,                  /* DEC_OP  */
-    LE_OP = 576,                   /* LE_OP  */
-    GE_OP = 577,                   /* GE_OP  */
-    EQ_OP = 578,                   /* EQ_OP  */
-    NE_OP = 579,                   /* NE_OP  */
-    AND_OP = 580,                  /* AND_OP  */
-    OR_OP = 581,                   /* OR_OP  */
-    XOR_OP = 582,                  /* XOR_OP  */
-    MUL_ASSIGN = 583,              /* MUL_ASSIGN  */
-    DIV_ASSIGN = 584,              /* DIV_ASSIGN  */
-    ADD_ASSIGN = 585,              /* ADD_ASSIGN  */
-    MOD_ASSIGN = 586,              /* MOD_ASSIGN  */
-    LEFT_ASSIGN = 587,             /* LEFT_ASSIGN  */
-    RIGHT_ASSIGN = 588,            /* RIGHT_ASSIGN  */
-    AND_ASSIGN = 589,              /* AND_ASSIGN  */
-    XOR_ASSIGN = 590,              /* XOR_ASSIGN  */
-    OR_ASSIGN = 591,               /* OR_ASSIGN  */
-    SUB_ASSIGN = 592,              /* SUB_ASSIGN  */
-    STRING_LITERAL = 593,          /* STRING_LITERAL  */
-    LEFT_PAREN = 594,              /* LEFT_PAREN  */
-    RIGHT_PAREN = 595,             /* RIGHT_PAREN  */
-    LEFT_BRACKET = 596,            /* LEFT_BRACKET  */
-    RIGHT_BRACKET = 597,           /* RIGHT_BRACKET  */
-    LEFT_BRACE = 598,              /* LEFT_BRACE  */
-    RIGHT_BRACE = 599,             /* RIGHT_BRACE  */
-    DOT = 600,                     /* DOT  */
-    COMMA = 601,                   /* COMMA  */
-    COLON = 602,                   /* COLON  */
-    EQUAL = 603,                   /* EQUAL  */
-    SEMICOLON = 604,               /* SEMICOLON  */
-    BANG = 605,                    /* BANG  */
-    DASH = 606,                    /* DASH  */
-    TILDE = 607,                   /* TILDE  */
-    PLUS = 608,                    /* PLUS  */
-    STAR = 609,                    /* STAR  */
-    SLASH = 610,                   /* SLASH  */
-    PERCENT = 611,                 /* PERCENT  */
-    LEFT_ANGLE = 612,              /* LEFT_ANGLE  */
-    RIGHT_ANGLE = 613,             /* RIGHT_ANGLE  */
-    VERTICAL_BAR = 614,            /* VERTICAL_BAR  */
-    CARET = 615,                   /* CARET  */
-    AMPERSAND = 616,               /* AMPERSAND  */
-    QUESTION = 617,                /* QUESTION  */
-    INVARIANT = 618,               /* INVARIANT  */
-    HIGH_PRECISION = 619,          /* HIGH_PRECISION  */
-    MEDIUM_PRECISION = 620,        /* MEDIUM_PRECISION  */
-    LOW_PRECISION = 621,           /* LOW_PRECISION  */
-    PRECISION = 622,               /* PRECISION  */
-    PACKED = 623,                  /* PACKED  */
-    RESOURCE = 624,                /* RESOURCE  */
-    SUPERP = 625,                  /* SUPERP  */
-    FLOATCONSTANT = 626,           /* FLOATCONSTANT  */
-    INTCONSTANT = 627,             /* INTCONSTANT  */
-    UINTCONSTANT = 628,            /* UINTCONSTANT  */
-    BOOLCONSTANT = 629,            /* BOOLCONSTANT  */
-    IDENTIFIER = 630,              /* IDENTIFIER  */
-    TYPE_NAME = 631,               /* TYPE_NAME  */
-    CENTROID = 632,                /* CENTROID  */
-    IN = 633,                      /* IN  */
-    OUT = 634,                     /* OUT  */
-    INOUT = 635,                   /* INOUT  */
-    STRUCT = 636,                  /* STRUCT  */
-    VOID = 637,                    /* VOID  */
-    WHILE = 638,                   /* WHILE  */
-    BREAK = 639,                   /* BREAK  */
-    CONTINUE = 640,                /* CONTINUE  */
-    DO = 641,                      /* DO  */
-    ELSE = 642,                    /* ELSE  */
-    FOR = 643,                     /* FOR  */
-    IF = 644,                      /* IF  */
-    DISCARD = 645,                 /* DISCARD  */
-    RETURN = 646,                  /* RETURN  */
-    SWITCH = 647,                  /* SWITCH  */
-    CASE = 648,                    /* CASE  */
-    DEFAULT = 649,                 /* DEFAULT  */
-    TERMINATE_INVOCATION = 650,    /* TERMINATE_INVOCATION  */
-    TERMINATE_RAY = 651,           /* TERMINATE_RAY  */
-    IGNORE_INTERSECTION = 652,     /* IGNORE_INTERSECTION  */
-    UNIFORM = 653,                 /* UNIFORM  */
-    SHARED = 654,                  /* SHARED  */
-    BUFFER = 655,                  /* BUFFER  */
-    FLAT = 656,                    /* FLAT  */
-    SMOOTH = 657,                  /* SMOOTH  */
-    LAYOUT = 658,                  /* LAYOUT  */
-    DOUBLECONSTANT = 659,          /* DOUBLECONSTANT  */
-    INT16CONSTANT = 660,           /* INT16CONSTANT  */
-    UINT16CONSTANT = 661,          /* UINT16CONSTANT  */
-    FLOAT16CONSTANT = 662,         /* FLOAT16CONSTANT  */
-    INT32CONSTANT = 663,           /* INT32CONSTANT  */
-    UINT32CONSTANT = 664,          /* UINT32CONSTANT  */
-    INT64CONSTANT = 665,           /* INT64CONSTANT  */
-    UINT64CONSTANT = 666,          /* UINT64CONSTANT  */
-    SUBROUTINE = 667,              /* SUBROUTINE  */
-    DEMOTE = 668,                  /* DEMOTE  */
-    PAYLOADNV = 669,               /* PAYLOADNV  */
-    PAYLOADINNV = 670,             /* PAYLOADINNV  */
-    HITATTRNV = 671,               /* HITATTRNV  */
-    CALLDATANV = 672,              /* CALLDATANV  */
-    CALLDATAINNV = 673,            /* CALLDATAINNV  */
-    PAYLOADEXT = 674,              /* PAYLOADEXT  */
-    PAYLOADINEXT = 675,            /* PAYLOADINEXT  */
-    HITATTREXT = 676,              /* HITATTREXT  */
-    CALLDATAEXT = 677,             /* CALLDATAEXT  */
-    CALLDATAINEXT = 678,           /* CALLDATAINEXT  */
-    PATCH = 679,                   /* PATCH  */
-    SAMPLE = 680,                  /* SAMPLE  */
-    NONUNIFORM = 681,              /* NONUNIFORM  */
-    COHERENT = 682,                /* COHERENT  */
-    VOLATILE = 683,                /* VOLATILE  */
-    RESTRICT = 684,                /* RESTRICT  */
-    READONLY = 685,                /* READONLY  */
-    WRITEONLY = 686,               /* WRITEONLY  */
-    DEVICECOHERENT = 687,          /* DEVICECOHERENT  */
-    QUEUEFAMILYCOHERENT = 688,     /* QUEUEFAMILYCOHERENT  */
-    WORKGROUPCOHERENT = 689,       /* WORKGROUPCOHERENT  */
-    SUBGROUPCOHERENT = 690,        /* SUBGROUPCOHERENT  */
-    NONPRIVATE = 691,              /* NONPRIVATE  */
-    SHADERCALLCOHERENT = 692,      /* SHADERCALLCOHERENT  */
-    NOPERSPECTIVE = 693,           /* NOPERSPECTIVE  */
-    EXPLICITINTERPAMD = 694,       /* EXPLICITINTERPAMD  */
-    PERVERTEXNV = 695,             /* PERVERTEXNV  */
-    PERPRIMITIVENV = 696,          /* PERPRIMITIVENV  */
-    PERVIEWNV = 697,               /* PERVIEWNV  */
-    PERTASKNV = 698,               /* PERTASKNV  */
-    PRECISE = 699                  /* PRECISE  */
+    SPIRV_INSTRUCTION = 572,       /* SPIRV_INSTRUCTION  */
+    SPIRV_EXECUTION_MODE = 573,    /* SPIRV_EXECUTION_MODE  */
+    SPIRV_EXECUTION_MODE_ID = 574, /* SPIRV_EXECUTION_MODE_ID  */
+    SPIRV_DECORATE = 575,          /* SPIRV_DECORATE  */
+    SPIRV_DECORATE_ID = 576,       /* SPIRV_DECORATE_ID  */
+    SPIRV_DECORATE_STRING = 577,   /* SPIRV_DECORATE_STRING  */
+    SPIRV_TYPE = 578,              /* SPIRV_TYPE  */
+    SPIRV_STORAGE_CLASS = 579,     /* SPIRV_STORAGE_CLASS  */
+    SPIRV_BY_REFERENCE = 580,      /* SPIRV_BY_REFERENCE  */
+    SPIRV_LITERAL = 581,           /* SPIRV_LITERAL  */
+    LEFT_OP = 582,                 /* LEFT_OP  */
+    RIGHT_OP = 583,                /* RIGHT_OP  */
+    INC_OP = 584,                  /* INC_OP  */
+    DEC_OP = 585,                  /* DEC_OP  */
+    LE_OP = 586,                   /* LE_OP  */
+    GE_OP = 587,                   /* GE_OP  */
+    EQ_OP = 588,                   /* EQ_OP  */
+    NE_OP = 589,                   /* NE_OP  */
+    AND_OP = 590,                  /* AND_OP  */
+    OR_OP = 591,                   /* OR_OP  */
+    XOR_OP = 592,                  /* XOR_OP  */
+    MUL_ASSIGN = 593,              /* MUL_ASSIGN  */
+    DIV_ASSIGN = 594,              /* DIV_ASSIGN  */
+    ADD_ASSIGN = 595,              /* ADD_ASSIGN  */
+    MOD_ASSIGN = 596,              /* MOD_ASSIGN  */
+    LEFT_ASSIGN = 597,             /* LEFT_ASSIGN  */
+    RIGHT_ASSIGN = 598,            /* RIGHT_ASSIGN  */
+    AND_ASSIGN = 599,              /* AND_ASSIGN  */
+    XOR_ASSIGN = 600,              /* XOR_ASSIGN  */
+    OR_ASSIGN = 601,               /* OR_ASSIGN  */
+    SUB_ASSIGN = 602,              /* SUB_ASSIGN  */
+    STRING_LITERAL = 603,          /* STRING_LITERAL  */
+    LEFT_PAREN = 604,              /* LEFT_PAREN  */
+    RIGHT_PAREN = 605,             /* RIGHT_PAREN  */
+    LEFT_BRACKET = 606,            /* LEFT_BRACKET  */
+    RIGHT_BRACKET = 607,           /* RIGHT_BRACKET  */
+    LEFT_BRACE = 608,              /* LEFT_BRACE  */
+    RIGHT_BRACE = 609,             /* RIGHT_BRACE  */
+    DOT = 610,                     /* DOT  */
+    COMMA = 611,                   /* COMMA  */
+    COLON = 612,                   /* COLON  */
+    EQUAL = 613,                   /* EQUAL  */
+    SEMICOLON = 614,               /* SEMICOLON  */
+    BANG = 615,                    /* BANG  */
+    DASH = 616,                    /* DASH  */
+    TILDE = 617,                   /* TILDE  */
+    PLUS = 618,                    /* PLUS  */
+    STAR = 619,                    /* STAR  */
+    SLASH = 620,                   /* SLASH  */
+    PERCENT = 621,                 /* PERCENT  */
+    LEFT_ANGLE = 622,              /* LEFT_ANGLE  */
+    RIGHT_ANGLE = 623,             /* RIGHT_ANGLE  */
+    VERTICAL_BAR = 624,            /* VERTICAL_BAR  */
+    CARET = 625,                   /* CARET  */
+    AMPERSAND = 626,               /* AMPERSAND  */
+    QUESTION = 627,                /* QUESTION  */
+    INVARIANT = 628,               /* INVARIANT  */
+    HIGH_PRECISION = 629,          /* HIGH_PRECISION  */
+    MEDIUM_PRECISION = 630,        /* MEDIUM_PRECISION  */
+    LOW_PRECISION = 631,           /* LOW_PRECISION  */
+    PRECISION = 632,               /* PRECISION  */
+    PACKED = 633,                  /* PACKED  */
+    RESOURCE = 634,                /* RESOURCE  */
+    SUPERP = 635,                  /* SUPERP  */
+    FLOATCONSTANT = 636,           /* FLOATCONSTANT  */
+    INTCONSTANT = 637,             /* INTCONSTANT  */
+    UINTCONSTANT = 638,            /* UINTCONSTANT  */
+    BOOLCONSTANT = 639,            /* BOOLCONSTANT  */
+    IDENTIFIER = 640,              /* IDENTIFIER  */
+    TYPE_NAME = 641,               /* TYPE_NAME  */
+    CENTROID = 642,                /* CENTROID  */
+    IN = 643,                      /* IN  */
+    OUT = 644,                     /* OUT  */
+    INOUT = 645,                   /* INOUT  */
+    STRUCT = 646,                  /* STRUCT  */
+    VOID = 647,                    /* VOID  */
+    WHILE = 648,                   /* WHILE  */
+    BREAK = 649,                   /* BREAK  */
+    CONTINUE = 650,                /* CONTINUE  */
+    DO = 651,                      /* DO  */
+    ELSE = 652,                    /* ELSE  */
+    FOR = 653,                     /* FOR  */
+    IF = 654,                      /* IF  */
+    DISCARD = 655,                 /* DISCARD  */
+    RETURN = 656,                  /* RETURN  */
+    SWITCH = 657,                  /* SWITCH  */
+    CASE = 658,                    /* CASE  */
+    DEFAULT = 659,                 /* DEFAULT  */
+    TERMINATE_INVOCATION = 660,    /* TERMINATE_INVOCATION  */
+    TERMINATE_RAY = 661,           /* TERMINATE_RAY  */
+    IGNORE_INTERSECTION = 662,     /* IGNORE_INTERSECTION  */
+    UNIFORM = 663,                 /* UNIFORM  */
+    SHARED = 664,                  /* SHARED  */
+    BUFFER = 665,                  /* BUFFER  */
+    FLAT = 666,                    /* FLAT  */
+    SMOOTH = 667,                  /* SMOOTH  */
+    LAYOUT = 668,                  /* LAYOUT  */
+    DOUBLECONSTANT = 669,          /* DOUBLECONSTANT  */
+    INT16CONSTANT = 670,           /* INT16CONSTANT  */
+    UINT16CONSTANT = 671,          /* UINT16CONSTANT  */
+    FLOAT16CONSTANT = 672,         /* FLOAT16CONSTANT  */
+    INT32CONSTANT = 673,           /* INT32CONSTANT  */
+    UINT32CONSTANT = 674,          /* UINT32CONSTANT  */
+    INT64CONSTANT = 675,           /* INT64CONSTANT  */
+    UINT64CONSTANT = 676,          /* UINT64CONSTANT  */
+    SUBROUTINE = 677,              /* SUBROUTINE  */
+    DEMOTE = 678,                  /* DEMOTE  */
+    PAYLOADNV = 679,               /* PAYLOADNV  */
+    PAYLOADINNV = 680,             /* PAYLOADINNV  */
+    HITATTRNV = 681,               /* HITATTRNV  */
+    CALLDATANV = 682,              /* CALLDATANV  */
+    CALLDATAINNV = 683,            /* CALLDATAINNV  */
+    PAYLOADEXT = 684,              /* PAYLOADEXT  */
+    PAYLOADINEXT = 685,            /* PAYLOADINEXT  */
+    HITATTREXT = 686,              /* HITATTREXT  */
+    CALLDATAEXT = 687,             /* CALLDATAEXT  */
+    CALLDATAINEXT = 688,           /* CALLDATAINEXT  */
+    PATCH = 689,                   /* PATCH  */
+    SAMPLE = 690,                  /* SAMPLE  */
+    NONUNIFORM = 691,              /* NONUNIFORM  */
+    COHERENT = 692,                /* COHERENT  */
+    VOLATILE = 693,                /* VOLATILE  */
+    RESTRICT = 694,                /* RESTRICT  */
+    READONLY = 695,                /* READONLY  */
+    WRITEONLY = 696,               /* WRITEONLY  */
+    DEVICECOHERENT = 697,          /* DEVICECOHERENT  */
+    QUEUEFAMILYCOHERENT = 698,     /* QUEUEFAMILYCOHERENT  */
+    WORKGROUPCOHERENT = 699,       /* WORKGROUPCOHERENT  */
+    SUBGROUPCOHERENT = 700,        /* SUBGROUPCOHERENT  */
+    NONPRIVATE = 701,              /* NONPRIVATE  */
+    SHADERCALLCOHERENT = 702,      /* SHADERCALLCOHERENT  */
+    NOPERSPECTIVE = 703,           /* NOPERSPECTIVE  */
+    EXPLICITINTERPAMD = 704,       /* EXPLICITINTERPAMD  */
+    PERVERTEXNV = 705,             /* PERVERTEXNV  */
+    PERPRIMITIVENV = 706,          /* PERPRIMITIVENV  */
+    PERVIEWNV = 707,               /* PERVIEWNV  */
+    PERTASKNV = 708,               /* PERTASKNV  */
+    PRECISE = 709                  /* PRECISE  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -527,6 +537,9 @@ union YYSTYPE
             glslang::TIntermNodePair nodePair;
             glslang::TIntermTyped* intermTypedNode;
             glslang::TAttributes* attributes;
+            glslang::TSpirvRequirement* spirvReq;
+            glslang::TSpirvInstruction* spirvInst;
+            glslang::TSpirvTypeParameters* spirvTypeParams;
         };
         union {
             glslang::TPublicType type;
@@ -540,7 +553,7 @@ union YYSTYPE
         glslang::TArraySizes* typeParameters;
     } interm;
 
-#line 544 "MachineIndependent/glslang_tab.cpp.h"
+#line 557 "MachineIndependent/glslang_tab.cpp.h"
 
 };
 typedef union YYSTYPE YYSTYPE;

diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp
index 8e0db3d..105adc4 100644 (file)
--- a/glslang/MachineIndependent/intermOut.cpp
+++ b/glslang/MachineIndependent/intermOut.cpp
@@ -696,6 +696,10 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
 
     case EOpConstructReference: out.debug << "Construct reference type"; break;
 
+#ifndef GLSLANG_WEB
+    case EOpSpirvInst: out.debug << "spirv_instruction"; break;
+#endif
+
     default: out.debug.message(EPrefixError, "Bad unary op");
     }
 
@@ -1126,6 +1130,10 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break;
     case EOpDebugPrintf:  out.debug << "Debug printf";  break;
 
+#ifndef GLSLANG_WEB
+    case EOpSpirvInst: out.debug << "spirv_instruction"; break;
+#endif
+
     default: out.debug.message(EPrefixError, "Bad aggregation op");
     }
 

diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h
index f4f2cd9..5cc9930 100644 (file)
--- a/glslang/MachineIndependent/localintermediate.h
+++ b/glslang/MachineIndependent/localintermediate.h
@@ -330,6 +330,8 @@ public:
         binaryDoubleOutput(false),
         subgroupUniformControlFlow(false),
         usePhysicalStorageBuffer(false),
+        spirvRequirement(nullptr),
+        spirvExecutionMode(nullptr),
         uniformLocationBase(0)
 #endif
     {
@@ -868,6 +870,15 @@ public:
 
     void setSubgroupUniformControlFlow() { subgroupUniformControlFlow = true; }
     bool getSubgroupUniformControlFlow() const { return subgroupUniformControlFlow; }
+
+    // GL_EXT_spirv_intrinsics
+    void insertSpirvRequirement(const TSpirvRequirement* spirvReq);
+    bool hasSpirvRequirement() const { return spirvRequirement != nullptr; }
+    const TSpirvRequirement& getSpirvRequirement() const { return *spirvRequirement; }
+    void insertSpirvExecutionMode(int executionMode, const TIntermAggregate* args = nullptr);
+    void insertSpirvExecutionModeId(int executionMode, const TIntermAggregate* args);
+    bool hasSpirvExecutionMode() const { return spirvExecutionMode != nullptr; }
+    const TSpirvExecutionMode& getSpirvExecutionMode() const { return *spirvExecutionMode; }
 #endif // GLSLANG_WEB
 
     void addBlockStorageOverride(const char* nameStr, TBlockStorageClass backing)
@@ -1122,6 +1133,9 @@ protected:
     bool subgroupUniformControlFlow;
     bool usePhysicalStorageBuffer;
 
+    TSpirvRequirement* spirvRequirement;
+    TSpirvExecutionMode* spirvExecutionMode;
+
     std::unordered_map<std::string, int> uniformLocationOverrides;
     int uniformLocationBase;
     TNumericFeatures numericFeatures;

diff --git a/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/glslang/MachineIndependent/preprocessor/PpScanner.cpp
index e0f44f8..ac5bfaf 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/PpScanner.cpp
+++ b/glslang/MachineIndependent/preprocessor/PpScanner.cpp
@@ -1191,9 +1191,12 @@ int TPpContext::tokenize(TPpToken& ppToken)
             // HLSL allows string literals.
             // GLSL allows string literals with GL_EXT_debug_printf.
             if (ifdepth == 0 && parseContext.intermediate.getSource() != EShSourceHlsl) {
-                parseContext.requireExtensions(ppToken.loc, 1, &E_GL_EXT_debug_printf, "string literal");
-                if (!parseContext.extensionTurnedOn(E_GL_EXT_debug_printf))
-                    continue;
+              const char* const string_literal_EXTs[] = { E_GL_EXT_debug_printf, E_GL_EXT_spirv_intrinsics };
+              const int Num_string_literal_EXTs = sizeof(string_literal_EXTs) / sizeof(string_literal_EXTs[0]);
+              parseContext.requireExtensions(ppToken.loc, 2, string_literal_EXTs, "string literal");
+              if (!parseContext.extensionTurnedOn(E_GL_EXT_debug_printf) &&
+                  !parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
+                  continue;
             }
             break;
         case '\'':

diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp
index 68973ce..20683a6 100644 (file)
--- a/gtests/Spv.FromFile.cpp
+++ b/gtests/Spv.FromFile.cpp
@@ -356,6 +356,13 @@ INSTANTIATE_TEST_SUITE_P(
         "spv.int64.frag",
         "spv.intcoopmat.comp",
         "spv.intOps.vert",
+        "spv.intrinsicsSpirvByReference.vert",
+        "spv.intrinsicsSpirvDecorate.frag",
+        "spv.intrinsicsSpirvExecutionMode.frag",
+        "spv.intrinsicsSpirvInstruction.vert",
+        "spv.intrinsicsSpirvLiteral.vert",
+        "spv.intrinsicsSpirvStorageClass.rchit",
+        "spv.intrinsicsSpirvType.rgen",
         "spv.layer.tese",
         "spv.layoutNested.vert",
         "spv.length.frag",