Implement GL_NV_cooperative_matrix

diff --git a/SPIRV/GLSL.ext.NV.h b/SPIRV/GLSL.ext.NV.h
index 102d645..ede2c57 100644 (file)
--- a/SPIRV/GLSL.ext.NV.h
+++ b/SPIRV/GLSL.ext.NV.h
@@ -72,4 +72,7 @@ const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing";
 //SPV_NV_shading_rate
 const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate";
 
+//SPV_NV_cooperative_matrix
+const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix";
+
 #endif  // #ifndef GLSLextNV_H

diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 9bf3704..2ddece1
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -1330,6 +1330,10 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl
     }
     builder.setMemoryModel(addressingModel, memoryModel);
 
+    if (glslangIntermediate->usingVariablePointers()) {
+        builder.addCapability(spv::CapabilityVariablePointers);
+    }
+
     shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
     entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
 
@@ -1870,16 +1874,31 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
         // So, this has to be block.lastMember.length().
         // SPV wants "block" and member number as the operands, go get them.
 
-        glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
-        block->traverse(this);
-        unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()->getConstArray()[0].getUConst();
-        spv::Id length = builder.createArrayLength(builder.accessChainGetLValue(), member);
+        spv::Id length;
+        if (node->getOperand()->getType().isCoopMat()) {
+            spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
+
+            spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
+            assert(builder.isCooperativeMatrixType(typeId));
+
+            length = builder.createCooperativeMatrixLength(typeId);
+        } else {
+            glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
+            block->traverse(this);
+            unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()->getConstArray()[0].getUConst();
+            length = builder.createArrayLength(builder.accessChainGetLValue(), member);
+        }
 
         // GLSL semantics say the result of .length() is an int, while SPIR-V says
         // signedness must be 0. So, convert from SPIR-V unsigned back to GLSL's
         // AST expectation of a signed result.
-        if (glslangIntermediate->getSource() == glslang::EShSourceGlsl)
-            length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length);
+        if (glslangIntermediate->getSource() == glslang::EShSourceGlsl) {
+            if (builder.isInSpecConstCodeGenMode()) {
+                length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0));
+            } else {
+                length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length);
+            }
+        }
 
         builder.clearAccessChain();
         builder.setAccessChainRValue(length);
@@ -2222,6 +2241,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpConstructStruct:
     case glslang::EOpConstructTextureSampler:
     case glslang::EOpConstructReference:
+    case glslang::EOpConstructCooperativeMatrix:
     {
         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
         std::vector<spv::Id> arguments;
@@ -2229,7 +2249,9 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         spv::Id constructed;
         if (node->getOp() == glslang::EOpConstructTextureSampler)
             constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
-        else if (node->getOp() == glslang::EOpConstructStruct || node->getType().isArray()) {
+        else if (node->getOp() == glslang::EOpConstructStruct ||
+                 node->getOp() == glslang::EOpConstructCooperativeMatrix ||
+                 node->getType().isArray()) {
             std::vector<spv::Id> constituents;
             for (int c = 0; c < (int)arguments.size(); ++c)
                 constituents.push_back(arguments[c]);
@@ -2347,6 +2369,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         noReturnValue = true;
         break;
 #endif
+    case glslang::EOpCooperativeMatrixLoad:
+    case glslang::EOpCooperativeMatrixStore:
+        noReturnValue = true;
+        break;
 
     default:
         break;
@@ -2389,6 +2415,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     //
     glslang::TIntermSequence& glslangOperands = node->getSequence();
     std::vector<spv::Id> operands;
+    std::vector<spv::IdImmediate> memoryAccessOperands;
     for (int arg = 0; arg < (int)glslangOperands.size(); ++arg) {
         // special case l-value operands; there are just a few
         bool lvalue = false;
@@ -2445,6 +2472,14 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             if (arg >= 2)
                 lvalue = true;
             break;
+        case glslang::EOpCooperativeMatrixLoad:
+            if (arg == 0 || arg == 1)
+                lvalue = true;
+            break;
+        case glslang::EOpCooperativeMatrixStore:
+            if (arg == 1)
+                lvalue = true;
+            break;
         default:
             break;
         }
@@ -2453,6 +2488,50 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             glslangOperands[0]->getAsBinaryNode()->getLeft()->traverse(this);
         else
             glslangOperands[arg]->traverse(this);
+
+        if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
+            node->getOp() == glslang::EOpCooperativeMatrixStore) {
+
+            if (arg == 1) {
+                // fold "element" parameter into the access chain
+                spv::Builder::AccessChain save = builder.getAccessChain();
+                builder.clearAccessChain();
+                glslangOperands[2]->traverse(this);
+
+                spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType());
+
+                builder.setAccessChain(save);
+
+                // Point to the first element of the array.
+                builder.accessChainPush(elementId, TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()),
+                                                   getBufferReferenceAlignment(glslangOperands[arg]->getAsTyped()->getType()));
+
+                spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
+                unsigned int alignment = builder.getAccessChain().alignment;
+
+                int memoryAccess = TranslateMemoryAccess(coherentFlags);
+                if (node->getOp() == glslang::EOpCooperativeMatrixLoad)
+                    memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask;
+                if (node->getOp() == glslang::EOpCooperativeMatrixStore)
+                    memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask;
+                if (builder.getStorageClass(builder.getAccessChain().base) == spv::StorageClassPhysicalStorageBufferEXT) {
+                    memoryAccess = (spv::MemoryAccessMask)(memoryAccess | spv::MemoryAccessAlignedMask);
+                }
+
+                memoryAccessOperands.push_back(spv::IdImmediate(false, memoryAccess));
+
+                if (memoryAccess & spv::MemoryAccessAlignedMask) {
+                    memoryAccessOperands.push_back(spv::IdImmediate(false, alignment));
+                }
+
+                if (memoryAccess & (spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask)) {
+                    memoryAccessOperands.push_back(spv::IdImmediate(true, builder.makeUintConstant(TranslateMemoryScope(coherentFlags))));
+                }
+            } else if (arg == 2) {
+                continue;
+            }
+        }
+
         if (lvalue)
             operands.push_back(builder.accessChainGetLValue());
         else {
@@ -2462,7 +2541,33 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     }
 
     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
-    if (atomic) {
+    if (node->getOp() == glslang::EOpCooperativeMatrixLoad) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+        idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
+        // get the pointee type
+        spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
+        assert(builder.isCooperativeMatrixType(typeId));
+        // do the op
+        spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[0]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeMatrixStore) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+        idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
+
+        builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
+        result = 0;
+    } else if (atomic) {
         // Handle all atomics
         result = createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType());
     } else {
@@ -3090,6 +3195,19 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
             spvType = builder.makeVectorType(spvType, type.getVectorSize());
     }
 
+    if (type.isCoopMat()) {
+        builder.addCapability(spv::CapabilityCooperativeMatrixNV);
+        builder.addExtension(spv::E_SPV_NV_cooperative_matrix);
+        if (type.getBasicType() == glslang::EbtFloat16)
+            builder.addCapability(spv::CapabilityFloat16);
+
+        spv::Id scope = makeArraySizeId(*type.getTypeParameters(), 1);
+        spv::Id rows = makeArraySizeId(*type.getTypeParameters(), 2);
+        spv::Id cols = makeArraySizeId(*type.getTypeParameters(), 3);
+
+        spvType = builder.makeCooperativeMatrixType(spvType, scope, rows, cols);
+    }
+
     if (type.isArray()) {
         int stride = 0;  // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride
 
@@ -4847,7 +4965,8 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD
     // handle mapped binary operations (should be non-comparison)
     if (binOp != spv::OpNop) {
         assert(comparison == false);
-        if (builder.isMatrix(left) || builder.isMatrix(right))
+        if (builder.isMatrix(left) || builder.isMatrix(right) ||
+            builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
             return createBinaryMatrixOperation(binOp, decorations, typeId, left, right);
 
         // No matrix involved; make both operands be the same number of components, if needed
@@ -4968,7 +5087,7 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora
             firstClass = false;
         break;
     case spv::OpMatrixTimesScalar:
-        if (builder.isMatrix(right))
+        if (builder.isMatrix(right) || builder.isCooperativeMatrix(right))
             std::swap(left, right);
         assert(builder.isScalar(right));
         break;
@@ -4989,6 +5108,9 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora
         break;
     }
 
+    if (builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
+        firstClass = true;
+
     if (firstClass) {
         spv::Id result = builder.createBinOp(op, typeId, left, right);
         builder.addDecoration(result, decorations.noContraction);
@@ -7030,6 +7152,10 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
         return 0;
 #endif
+    case glslang::EOpCooperativeMatrixMulAdd:
+        opCode = spv::OpCooperativeMatrixMulAddNV;
+        break;
+
     default:
         return 0;
     }
@@ -7486,6 +7612,9 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla
         glslang::TType vectorType(glslangType, 0);
         for (int col = 0; col < glslangType.getMatrixCols(); ++col)
             spvConsts.push_back(createSpvConstantFromConstUnionArray(vectorType, consts, nextConst, false));
+    } else if (glslangType.isCoopMat()) {
+        glslang::TType componentType(glslangType.getBasicType());
+        spvConsts.push_back(createSpvConstantFromConstUnionArray(componentType, consts, nextConst, false));
     } else if (glslangType.isStruct()) {
         glslang::TVector<glslang::TTypeLoc>::const_iterator iter;
         for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter)

diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 8355d83..138c41c
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -388,6 +388,33 @@ Id Builder::makeMatrixType(Id component, int cols, int rows)
     return type->getResultId();
 }
 
+Id Builder::makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols)
+{
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeMatrixNV].size(); ++t) {
+        type = groupedTypes[OpTypeCooperativeMatrixNV][t];
+        if (type->getIdOperand(0) == component &&
+            type->getIdOperand(1) == scope &&
+            type->getIdOperand(2) == rows &&
+            type->getIdOperand(3) == cols)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), NoType, OpTypeCooperativeMatrixNV);
+    type->addIdOperand(component);
+    type->addIdOperand(scope);
+    type->addIdOperand(rows);
+    type->addIdOperand(cols);
+    groupedTypes[OpTypeCooperativeMatrixNV].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+
 // TODO: performance: track arrays per stride
 // If a stride is supplied (non-zero) make an array.
 // If no stride (0), reuse previous array types.
@@ -623,6 +650,9 @@ int Builder::getNumTypeConstituents(Id typeId) const
     }
     case OpTypeStruct:
         return instr->getNumOperands();
+    case OpTypeCooperativeMatrixNV:
+        // has only one constituent when used with OpCompositeConstruct.
+        return 1;
     default:
         assert(0);
         return 1;
@@ -669,6 +699,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const
     case OpTypeMatrix:
     case OpTypeArray:
     case OpTypeRuntimeArray:
+    case OpTypeCooperativeMatrixNV:
         return instr->getIdOperand(0);
     case OpTypePointer:
         return instr->getIdOperand(1);
@@ -981,15 +1012,14 @@ Id Builder::makeFpConstant(Id type, double d, bool specConstant)
         return NoResult;
 }
 
-Id Builder::findCompositeConstant(Op typeClass, const std::vector<Id>& comps)
+Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
 {
     Instruction* constant = 0;
     bool found = false;
     for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) {
         constant = groupedConstants[typeClass][i];
 
-        // same shape?
-        if (constant->getNumOperands() != (int)comps.size())
+        if (constant->getTypeId() != typeId)
             continue;
 
         // same contents?
@@ -1044,8 +1074,9 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector<Id>& members, boo
     case OpTypeVector:
     case OpTypeArray:
     case OpTypeMatrix:
+    case OpTypeCooperativeMatrixNV:
         if (! specConstant) {
-            Id existing = findCompositeConstant(typeClass, members);
+            Id existing = findCompositeConstant(typeClass, typeId, members);
             if (existing)
                 return existing;
         }
@@ -1408,6 +1439,23 @@ Id Builder::createArrayLength(Id base, unsigned int member)
     return length->getResultId();
 }
 
+Id Builder::createCooperativeMatrixLength(Id type)
+{
+    spv::Id intType = makeUintType(32);
+
+    // Generate code for spec constants if in spec constant operation
+    // generation mode.
+    if (generatingOpCodeForSpecConst) {
+        return createSpecConstantOp(OpCooperativeMatrixLengthNV, intType, std::vector<Id>(1, type), std::vector<Id>());
+    }
+
+    Instruction* length = new Instruction(getUniqueId(), intType, OpCooperativeMatrixLengthNV);
+    length->addIdOperand(type);
+    buildPoint->addInstruction(std::unique_ptr<Instruction>(length));
+
+    return length->getResultId();
+}
+
 Id Builder::createCompositeExtract(Id composite, Id typeId, unsigned index)
 {
     // Generate code for spec constants if in spec constant operation
@@ -2598,9 +2646,9 @@ Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resu
                 }
             }
 
-            if (constant)
+            if (constant) {
                 id = createCompositeExtract(accessChain.base, swizzleBase, indexes);
-            else {
+            } else {
                 // make a new function variable for this r-value
                 Id lValue = createVariable(StorageClassFunction, getTypeId(accessChain.base), "indexable");
 

diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
old mode 100755 (executable)
new mode 100644 (file)
index edeac1b..52f7fba
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -155,6 +155,7 @@ public:
     Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format);
     Id makeSamplerType();
     Id makeSampledImageType(Id imageType);
+    Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols);
 
     // accelerationStructureNV type
     Id makeAccelerationStructureNVType();
@@ -178,6 +179,7 @@ public:
     bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
     bool isVector(Id resultId)       const { return isVectorType(getTypeId(resultId)); }
     bool isMatrix(Id resultId)       const { return isMatrixType(getTypeId(resultId)); }
+    bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); }
     bool isAggregate(Id resultId)    const { return isAggregateType(getTypeId(resultId)); }
     bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); }
 
@@ -191,7 +193,8 @@ public:
     bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == OpTypeMatrix; }
     bool isStructType(Id typeId)       const { return getTypeClass(typeId) == OpTypeStruct; }
     bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == OpTypeArray; }
-    bool isAggregateType(Id typeId)    const { return isArrayType(typeId) || isStructType(typeId); }
+    bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; }
+    bool isAggregateType(Id typeId)    const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
     bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
     bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == OpTypeSampler; }
     bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; }
@@ -314,6 +317,9 @@ public:
     // Create an OpArrayLength instruction
     Id createArrayLength(Id base, unsigned int member);
 
+    // Create an OpCooperativeMatrixLengthNV instruction
+    Id createCooperativeMatrixLength(Id type);
+
     // Create an OpCompositeExtract instruction
     Id createCompositeExtract(Id composite, Id typeId, unsigned index);
     Id createCompositeExtract(Id composite, Id typeId, const std::vector<unsigned>& indexes);
@@ -670,7 +676,7 @@ public:
     Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant);
     Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value);
     Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2);
-    Id findCompositeConstant(Op typeClass, const std::vector<Id>& comps);
+    Id findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps);
     Id findStructConstant(Id typeId, const std::vector<Id>& comps);
     Id collapseAccessChain();
     void remapDynamicSwizzle();

diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
index bd6df10..76e1df8 100644 (file)
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -930,6 +930,10 @@ const char* CapabilityString(int info)
 
     case CapabilityPhysicalStorageBufferAddressesEXT:   return "CapabilityPhysicalStorageBufferAddressesEXT";
 
+    case CapabilityVariablePointers:                    return "CapabilityVariablePointers";
+
+    case CapabilityCooperativeMatrixNV:     return "CapabilityCooperativeMatrixNV";
+
     default: return "Bad";
     }
 }
@@ -1333,6 +1337,12 @@ const char* OpcodeString(int op)
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
 #endif
 
+    case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
+    case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
+    case OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
+    case OpCooperativeMatrixMulAddNV:       return "OpCooperativeMatrixMulAddNV";
+    case OpCooperativeMatrixLengthNV:       return "OpCooperativeMatrixLengthNV";
+
     default:
         return "Bad";
     }
@@ -1444,6 +1454,8 @@ void Parameterize()
     InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
     InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
     InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
+    InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false);
+    InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false);
 
     // Specific additional context-dependent operands
 
@@ -2714,6 +2726,32 @@ void Parameterize()
     InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
     InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
 #endif
+
+    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
+    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
+    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
+    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'");
+
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'");
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'");
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'");
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true);
+    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true);
+
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'");
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'");
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'");
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'");
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true);
+    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true);
+
+    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'");
+    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'");
+    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'");
+
+    InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'");
 }
 
 }; // end spv namespace

diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index 44d0616..523f7bb 100644 (file)
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -811,6 +811,7 @@ enum Capability {
     CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
     CapabilityPhysicalStorageBufferAddressesEXT = 5347,
     CapabilityComputeDerivativeGroupLinearNV = 5350,
+    CapabilityCooperativeMatrixNV = 5357,\r
     CapabilitySubgroupShuffleINTEL = 5568,
     CapabilitySubgroupBufferBlockIOINTEL = 5569,
     CapabilitySubgroupImageBlockIOINTEL = 5570,
@@ -1183,6 +1184,11 @@ enum Op {
     OpTraceNV = 5337,
     OpTypeAccelerationStructureNV = 5341,
     OpExecuteCallableNV = 5344,
+    OpTypeCooperativeMatrixNV = 5358,\r
+    OpCooperativeMatrixLoadNV = 5359,\r
+    OpCooperativeMatrixStoreNV = 5360,\r
+    OpCooperativeMatrixMulAddNV = 5361,\r
+    OpCooperativeMatrixLengthNV = 5362,\r
     OpSubgroupShuffleINTEL = 5571,
     OpSubgroupShuffleDownINTEL = 5572,
     OpSubgroupShuffleUpINTEL = 5573,

diff --git a/SPIRV/spvIR.h b/SPIRV/spvIR.h
index 8c2d0b6..b3cd0b0 100755 (executable)
--- a/SPIRV/spvIR.h
+++ b/SPIRV/spvIR.h
@@ -83,6 +83,7 @@ const MemorySemanticsMask MemorySemanticsAllMemory =
 struct IdImmediate {
     bool isId;      // true if word is an Id, false if word is an immediate
     unsigned word;
+    IdImmediate(bool i, unsigned w) : isId(i), word(w) {}
 };
 
 //

diff --git a/Test/baseResults/420.vert.out b/Test/baseResults/420.vert.out
index 22577ab..740c8fe 100644 (file)
--- a/Test/baseResults/420.vert.out
+++ b/Test/baseResults/420.vert.out
@@ -8,7 +8,7 @@ ERROR: 0:12: '' : can only have one auxiliary qualifier (centroid, patch, and sa
 ERROR: 0:13: 'uniform' : too many storage qualifiers 
 ERROR: 0:18: '=' : global const initializers must be constant ' const int'
 ERROR: 0:20: 'const' : no qualifiers allowed for function return 
-ERROR: 0:27: '' : array size must be a constant integer expression 
+ERROR: 0:27: '' : array size must be a constant integer expression
 ERROR: 0:38: 'j' : undeclared identifier 
 ERROR: 0:38: '=' :  cannot convert from ' temp float' to ' temp int'
 ERROR: 0:39: 'k' : undeclared identifier 
@@ -31,7 +31,7 @@ ERROR: 0:85: 'patch' : not supported in this stage: vertex
 ERROR: 0:85: '' : vertex input cannot be further qualified 
 ERROR: 0:86: 'patch' : not supported in this stage: vertex
 ERROR: 0:100: '=' : global const initializers must be constant ' const int'
-ERROR: 0:101: '' : array size must be a constant integer expression 
+ERROR: 0:101: '' : array size must be a constant integer expression
 ERROR: 0:107: 'image variables not declared 'writeonly' and without a format layout qualifier' : not supported for this version or the enabled extensions 
 ERROR: 0:114: 'imageAtomicMin' : only supported on image with format r32i or r32ui 
 ERROR: 0:115: 'imageAtomicMax' : no matching overloaded function found 

diff --git a/Test/baseResults/constErrors.frag.out b/Test/baseResults/constErrors.frag.out
index 0b2dc62..2177484 100644 (file)
--- a/Test/baseResults/constErrors.frag.out
+++ b/Test/baseResults/constErrors.frag.out
@@ -1,8 +1,8 @@
 constErrors.frag
 ERROR: 0:14: 'non-constant initializer' : not supported for this version or the enabled extensions 
-ERROR: 0:17: '' : array size must be a constant integer expression 
-ERROR: 0:18: '' : array size must be a constant integer expression 
-ERROR: 0:19: '' : array size must be a constant integer expression 
+ERROR: 0:17: '' : array size must be a constant integer expression
+ERROR: 0:18: '' : array size must be a constant integer expression
+ERROR: 0:19: '' : array size must be a constant integer expression
 ERROR: 0:27: '=' : global const initializers must be constant ' const structure{ global 3-component vector of float v3,  global 2-component vector of int iv2}'
 ERROR: 0:33: '=' : global const initializers must be constant ' const structure{ global 3-component vector of float v3,  global 2-component vector of int iv2,  global 2X4 matrix of float m}'
 ERROR: 6 compilation errors.  No code generated.

diff --git a/Test/baseResults/negativeArraySize.comp.out b/Test/baseResults/negativeArraySize.comp.out
index 0a5ba31..5ae83dc 100644 (file)
--- a/Test/baseResults/negativeArraySize.comp.out
+++ b/Test/baseResults/negativeArraySize.comp.out
@@ -1,5 +1,5 @@
 negativeArraySize.comp
-ERROR: 0:9: '' : array size must be a positive integer 
+ERROR: 0:9: '' : array size must be a positive integer
 ERROR: 1 compilation errors.  No code generated.
 
 

diff --git a/Test/baseResults/spv.1.3.coopmat.comp.out b/Test/baseResults/spv.1.3.coopmat.comp.out
new file mode 100644 (file)
index 0000000..aa1b949
--- /dev/null
+++ b/Test/baseResults/spv.1.3.coopmat.comp.out
@@ -0,0 +1,95 @@
+spv.1.3.coopmat.comp
+// Module Version 10300
+// Generated by (magic number): 80007
+// Id's are bound by 52
+
+                              Capability Shader
+                              Capability CapabilityVariablePointers
+                              Capability CapabilityVulkanMemoryModelKHR
+                              Capability CapabilityCooperativeMatrixNV
+                              Extension  "SPV_KHR_vulkan_memory_model"
+                              Extension  "SPV_NV_cooperative_matrix"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical VulkanKHR
+                              EntryPoint GLCompute 4  "main"
+                              ExecutionMode 4 LocalSize 64 1 1
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_shader_explicit_arithmetic_types_float16"
+                              SourceExtension  "GL_KHR_memory_scope_semantics"
+                              SourceExtension  "GL_NV_cooperative_matrix"
+                              Name 4  "main"
+                              Name 13  "m"
+                              Name 29  "tempArg"
+                              Name 33  "Block"
+                              MemberName 33(Block) 0  "y"
+                              MemberName 33(Block) 1  "x"
+                              Name 35  "block"
+                              Decorate 31 ArrayStride 4
+                              Decorate 32 ArrayStride 4
+                              MemberDecorate 33(Block) 0 Offset 0
+                              MemberDecorate 33(Block) 1 Offset 4194304
+                              Decorate 33(Block) Block
+                              Decorate 35(block) DescriptorSet 0
+                              Decorate 35(block) Binding 0
+                              Decorate 51 BuiltIn WorkgroupSize
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeInt 32 0
+               8:      7(int) Constant 3
+               9:      7(int) Constant 16
+              10:      7(int) Constant 8
+              11:             TypeCooperativeMatrixNV 6(float) 8 9 10
+              12:             TypePointer Function 11
+              14:    6(float) Constant 0
+              15:          11 ConstantComposite 14
+              24:    6(float) Constant 1073741824
+              30:      7(int) Constant 1048576
+              31:             TypeArray 6(float) 30
+              32:             TypeRuntimeArray 6(float)
+       33(Block):             TypeStruct 31 32
+              34:             TypePointer StorageBuffer 33(Block)
+       35(block):     34(ptr) Variable StorageBuffer
+              36:             TypeInt 32 1
+              37:     36(int) Constant 1
+              38:      7(int) Constant 5
+              39:             TypePointer StorageBuffer 6(float)
+              41:      7(int) Constant 128
+              42:             TypeBool
+              43:    42(bool) ConstantFalse
+              48:             TypeVector 7(int) 3
+              49:      7(int) Constant 64
+              50:      7(int) Constant 1
+              51:   48(ivec3) ConstantComposite 49 50 50
+         4(main):           2 Function None 3
+               5:             Label
+           13(m):     12(ptr) Variable Function
+     29(tempArg):     12(ptr) Variable Function
+                              Store 13(m) 15
+              16:          11 Load 13(m)
+              17:          11 Load 13(m)
+              18:          11 FAdd 16 17
+                              Store 13(m) 18
+              19:          11 Load 13(m)
+              20:          11 Load 13(m)
+              21:          11 FSub 19 20
+                              Store 13(m) 21
+              22:          11 Load 13(m)
+              23:          11 FNegate 22
+                              Store 13(m) 23
+              25:          11 Load 13(m)
+              26:          11 MatrixTimesScalar 25 24
+                              Store 13(m) 26
+              27:          11 Load 13(m)
+              28:          11 MatrixTimesScalar 27 24
+                              Store 13(m) 28
+              40:     39(ptr) AccessChain 35(block) 37 9
+              44:          11 CooperativeMatrixLoadNV 40 41 43 MakePointerVisibleKHR NonPrivatePointerKHR 38
+                              Store 29(tempArg) 44
+              45:          11 Load 29(tempArg)
+                              Store 13(m) 45
+              46:          11 Load 13(m)
+              47:     39(ptr) AccessChain 35(block) 37 9
+                              CooperativeMatrixStoreNV 47 46 41 43 MakePointerAvailableKHR NonPrivatePointerKHR 38
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.coopmat.comp.out b/Test/baseResults/spv.coopmat.comp.out
new file mode 100644 (file)
index 0000000..5c00384
--- /dev/null
+++ b/Test/baseResults/spv.coopmat.comp.out
@@ -0,0 +1,375 @@
+spv.coopmat.comp
+// Module Version 10000
+// Generated by (magic number): 80007
+// Id's are bound by 228
+
+                              Capability Shader
+                              Capability Float16
+                              Capability StorageUniformBufferBlock16
+                              Capability CapabilityVulkanMemoryModelKHR
+                              Capability CapabilityPhysicalStorageBufferAddressesEXT
+                              Capability CapabilityCooperativeMatrixNV
+                              Extension  "SPV_EXT_physical_storage_buffer"
+                              Extension  "SPV_KHR_16bit_storage"
+                              Extension  "SPV_KHR_storage_buffer_storage_class"
+                              Extension  "SPV_KHR_vulkan_memory_model"
+                              Extension  "SPV_NV_cooperative_matrix"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel PhysicalStorageBuffer64EXT VulkanKHR
+                              EntryPoint GLCompute 4  "main"
+                              ExecutionMode 4 LocalSize 64 1 1
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_buffer_reference"
+                              SourceExtension  "GL_EXT_shader_explicit_arithmetic_types_float16"
+                              SourceExtension  "GL_KHR_memory_scope_semantics"
+                              SourceExtension  "GL_NV_cooperative_matrix"
+                              Name 4  "main"
+                              Name 14  "f16(f161;"
+                              Name 13  "m"
+                              Name 21  "f32(f1;"
+                              Name 20  "m"
+                              Name 34  "m"
+                              Name 52  "m2"
+                              Name 56  "x"
+                              Name 64  "tempArg"
+                              Name 68  "Block"
+                              MemberName 68(Block) 0  "y"
+                              MemberName 68(Block) 1  "x"
+                              Name 70  "block"
+                              Name 81  "tempArg"
+                              Name 86  "Block16"
+                              MemberName 86(Block16) 0  "y"
+                              MemberName 86(Block16) 1  "x"
+                              MemberName 86(Block16) 2  "b"
+                              Name 89  "Block"
+                              MemberName 89(Block) 0  "y"
+                              MemberName 89(Block) 1  "x"
+                              Name 91  "block16"
+                              Name 98  "tempArg"
+                              Name 111  "D"
+                              Name 112  "A"
+                              Name 114  "B"
+                              Name 116  "C"
+                              Name 120  "l"
+                              Name 124  "Y"
+                              Name 125  "Z"
+                              Name 128  "F"
+                              Name 133  "a"
+                              Name 137  "md1"
+                              Name 148  "mC2"
+                              Name 153  "tempArg"
+                              Name 159  "tempArg"
+                              Name 165  "p1"
+                              Name 166  "param"
+                              Name 169  "p2"
+                              Name 170  "param"
+                              Name 184  "tempArg"
+                              Name 189  "shmatrix"
+                              Name 194  "ms"
+                              Name 201  "mC"
+                              Name 206  "arr"
+                              Name 211  "arr2"
+                              Name 212  "F"
+                              Name 217  "S"
+                              MemberName 217(S) 0  "a"
+                              MemberName 217(S) 1  "b"
+                              MemberName 217(S) 2  "c"
+                              Name 222  "SC"
+                              Name 227  "scm"
+                              Decorate 66 ArrayStride 4
+                              Decorate 67 ArrayStride 4
+                              MemberDecorate 68(Block) 0 Offset 0
+                              MemberDecorate 68(Block) 1 Offset 4194304
+                              Decorate 68(Block) Block
+                              Decorate 70(block) DescriptorSet 0
+                              Decorate 70(block) Binding 0
+                              Decorate 82 ArrayStride 2
+                              Decorate 84 ArrayStride 2
+                              MemberDecorate 86(Block16) 0 Offset 0
+                              MemberDecorate 86(Block16) 1 Offset 2097152
+                              MemberDecorate 86(Block16) 2 Offset 2097160
+                              Decorate 86(Block16) Block
+                              Decorate 87 ArrayStride 4
+                              Decorate 88 ArrayStride 4
+                              MemberDecorate 89(Block) 0 Offset 0
+                              MemberDecorate 89(Block) 1 Offset 4194304
+                              Decorate 89(Block) Block
+                              Decorate 91(block16) DescriptorSet 0
+                              Decorate 91(block16) Binding 0
+                              Decorate 124(Y) SpecId 0
+                              Decorate 200 BuiltIn WorkgroupSize
+                              Decorate 212(F) SpecId 1
+                              Decorate 222(SC) SpecId 2
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 16
+               7:             TypeInt 32 0
+               8:      7(int) Constant 3
+               9:      7(int) Constant 8
+              10:             TypeCooperativeMatrixNV 6(float16_t) 8 9 9
+              11:             TypePointer Function 10
+              12:             TypeFunction 10 11(ptr)
+              16:             TypeFloat 32
+              17:             TypeCooperativeMatrixNV 16(float) 8 9 9
+              18:             TypePointer Function 17
+              19:             TypeFunction 17 18(ptr)
+              31:      7(int) Constant 16
+              32:             TypeCooperativeMatrixNV 16(float) 8 31 9
+              33:             TypePointer Function 32
+              35:   16(float) Constant 0
+              36:          32 ConstantComposite 35
+              45:   16(float) Constant 1073741824
+              50:             TypeCooperativeMatrixNV 6(float16_t) 8 31 9
+              51:             TypePointer Function 50
+              55:             TypePointer Function 16(float)
+              57:             TypeInt 32 1
+              58:     57(int) Constant 1
+              61:     57(int) Constant 0
+              65:      7(int) Constant 1048576
+              66:             TypeArray 16(float) 65
+              67:             TypeRuntimeArray 16(float)
+       68(Block):             TypeStruct 66 67
+              69:             TypePointer StorageBuffer 68(Block)
+       70(block):     69(ptr) Variable StorageBuffer
+              71:      7(int) Constant 5
+              72:             TypePointer StorageBuffer 16(float)
+              74:      7(int) Constant 128
+              75:             TypeBool
+              76:    75(bool) ConstantFalse
+              82:             TypeArray 6(float16_t) 65
+              83:      7(int) Constant 1
+              84:             TypeArray 6(float16_t) 83
+                              TypeForwardPointer 85 PhysicalStorageBufferEXT
+     86(Block16):             TypeStruct 82 84 85
+              87:             TypeArray 16(float) 65
+              88:             TypeRuntimeArray 16(float)
+       89(Block):             TypeStruct 87 88
+              85:             TypePointer PhysicalStorageBufferEXT 89(Block)
+              90:             TypePointer StorageBuffer 86(Block16)
+     91(block16):     90(ptr) Variable StorageBuffer
+              92:             TypePointer StorageBuffer 6(float16_t)
+              99:     57(int) Constant 2
+             100:             TypePointer StorageBuffer 85(ptr)
+             103:             TypePointer PhysicalStorageBufferEXT 16(float)
+             119:             TypePointer Function 57(int)
+             121:      7(int) SpecConstantOp 5362 32
+             122:     57(int) SpecConstantOp 128 121 61
+             123:     57(int) Constant 8
+          124(Y):     57(int) SpecConstant 2
+          125(Z):     57(int) SpecConstantOp 132 123 124(Y)
+             126:             TypeCooperativeMatrixNV 6(float16_t) 8 125(Z) 125(Z)
+             127:             TypePointer Function 126
+             129:6(float16_t) Constant 0
+             130:         126 ConstantComposite 129
+             131:             TypeArray 32 71
+             132:             TypePointer Function 131
+             134:     57(int) Constant 3
+             135:   16(float) Constant 1065353216
+             141:     57(int) Constant 1234
+             145:             TypeCooperativeMatrixNV 6(float16_t) 8 125(Z) 9
+             146:             TypeArray 145 8
+             147:             TypePointer Private 146
+        148(mC2):    147(ptr) Variable Private
+             149:             TypePointer Private 145
+             173:          10 ConstantComposite 129
+             174:          17 ConstantComposite 35
+             178:6(float16_t) Constant 16384
+             181:   16(float) Constant 1082130432
+             185:             TypeVector 7(int) 4
+             186:      7(int) Constant 32
+             187:             TypeArray 185(ivec4) 186
+             188:             TypePointer Workgroup 187
+   189(shmatrix):    188(ptr) Variable Workgroup
+             190:      7(int) Constant 2
+             191:             TypePointer Workgroup 185(ivec4)
+             198:             TypeVector 7(int) 3
+             199:      7(int) Constant 64
+             200:  198(ivec3) ConstantComposite 199 83 83
+         201(mC):    149(ptr) Variable Private
+             202:      7(int) SpecConstantOp 5362 145
+             203:     57(int) SpecConstantOp 128 202 61
+             204:             TypeArray 57(int) 203
+             205:             TypePointer Private 204
+        206(arr):    205(ptr) Variable Private
+             207:      7(int) SpecConstantOp 5362 145
+             208:     57(int) SpecConstantOp 128 207 61
+             209:             TypeArray 57(int) 208
+             210:             TypePointer Private 209
+       211(arr2):    210(ptr) Variable Private
+          212(F):   16(float) SpecConstant 1077936128
+             213:             TypeCooperativeMatrixNV 16(float) 8 125(Z) 9
+             214:         213 ConstantComposite 35
+             215:6(float16_t) Constant 15360
+             216:          10 ConstantComposite 215
+          217(S):             TypeStruct 57(int) 57(int) 57(int)
+             218:     57(int) Constant 12
+             219:     57(int) Constant 23
+             220:     57(int) Constant 34
+             221:      217(S) ConstantComposite 218 219 220
+         222(SC):     57(int) SpecConstant 1
+             223:             TypeCooperativeMatrixNV 6(float16_t) 8 222(SC) 222(SC)
+             224:             TypeArray 223 222(SC)
+             225:             TypeArray 224 222(SC)
+             226:             TypePointer Private 225
+        227(scm):    226(ptr) Variable Private
+         4(main):           2 Function None 3
+               5:             Label
+           34(m):     33(ptr) Variable Function
+          52(m2):     51(ptr) Variable Function
+           56(x):     55(ptr) Variable Function
+     64(tempArg):     33(ptr) Variable Function
+     81(tempArg):     51(ptr) Variable Function
+     98(tempArg):     33(ptr) Variable Function
+          111(D):     33(ptr) Variable Function
+          112(A):     51(ptr) Variable Function
+          114(B):     11(ptr) Variable Function
+          116(C):     33(ptr) Variable Function
+          120(l):    119(ptr) Variable Function
+          128(F):    127(ptr) Variable Function
+          133(a):    132(ptr) Variable Function
+        137(md1):     55(ptr) Variable Function
+    153(tempArg):     33(ptr) Variable Function
+    159(tempArg):     51(ptr) Variable Function
+         165(p1):     11(ptr) Variable Function
+      166(param):     11(ptr) Variable Function
+         169(p2):     18(ptr) Variable Function
+      170(param):     18(ptr) Variable Function
+    184(tempArg):     51(ptr) Variable Function
+         194(ms):     51(ptr) Variable Function
+                              Store 34(m) 36
+              37:          32 Load 34(m)
+              38:          32 Load 34(m)
+              39:          32 FAdd 37 38
+                              Store 34(m) 39
+              40:          32 Load 34(m)
+              41:          32 Load 34(m)
+              42:          32 FSub 40 41
+                              Store 34(m) 42
+              43:          32 Load 34(m)
+              44:          32 FNegate 43
+                              Store 34(m) 44
+              46:          32 Load 34(m)
+              47:          32 MatrixTimesScalar 46 45
+                              Store 34(m) 47
+              48:          32 Load 34(m)
+              49:          32 MatrixTimesScalar 48 45
+                              Store 34(m) 49
+              53:          32 Load 34(m)
+              54:          50 FConvert 53
+                              Store 52(m2) 54
+              59:     55(ptr) AccessChain 34(m) 58
+              60:   16(float) Load 59
+                              Store 56(x) 60
+              62:   16(float) Load 56(x)
+              63:     55(ptr) AccessChain 34(m) 61
+                              Store 63 62
+              73:     72(ptr) AccessChain 70(block) 58 31
+              77:          32 CooperativeMatrixLoadNV 73 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71
+                              Store 64(tempArg) 77
+              78:          32 Load 64(tempArg)
+                              Store 34(m) 78
+              79:          32 Load 34(m)
+              80:     72(ptr) AccessChain 70(block) 58 31
+                              CooperativeMatrixStoreNV 80 79 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71
+              93:     92(ptr) AccessChain 91(block16) 58 31
+              94:          50 CooperativeMatrixLoadNV 93 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71
+                              Store 81(tempArg) 94
+              95:          50 Load 81(tempArg)
+                              Store 52(m2) 95
+              96:          50 Load 52(m2)
+              97:     92(ptr) AccessChain 91(block16) 58 31
+                              CooperativeMatrixStoreNV 97 96 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71
+             101:    100(ptr) AccessChain 91(block16) 99
+             102:     85(ptr) Load 101 MakePointerVisibleKHR NonPrivatePointerKHR 71
+             104:    103(ptr) AccessChain 102 58 31
+             105:          32 CooperativeMatrixLoadNV 104 74 76 Aligned 16
+                              Store 98(tempArg) 105
+             106:          32 Load 98(tempArg)
+                              Store 34(m) 106
+             107:          32 Load 34(m)
+             108:    100(ptr) AccessChain 91(block16) 99
+             109:     85(ptr) Load 108 MakePointerVisibleKHR NonPrivatePointerKHR 71
+             110:    103(ptr) AccessChain 109 58 31
+                              CooperativeMatrixStoreNV 110 107 74 76 Aligned 16
+             113:          50 Load 112(A)
+             115:          10 Load 114(B)
+             117:          32 Load 116(C)
+             118:          32 CooperativeMatrixMulAddNV 113 115 117
+                              Store 111(D) 118
+                              Store 120(l) 122
+                              Store 128(F) 130
+             136:     55(ptr) AccessChain 133(a) 134 61
+                              Store 136 135
+                              Store 137(md1) 35
+             138:          32 Load 34(m)
+             139:          32 Load 34(m)
+             140:          32 FAdd 139 138
+                              Store 34(m) 140
+             142:   16(float) CompositeExtract 140 1234
+             143:   16(float) Load 137(md1)
+             144:   16(float) FAdd 143 142
+                              Store 137(md1) 144
+             150:    149(ptr) AccessChain 148(mC2) 99
+             151:         145 Load 150
+             152:    149(ptr) AccessChain 148(mC2) 58
+                              Store 152 151
+             154:     72(ptr) AccessChain 70(block) 61 31
+             155:          32 CooperativeMatrixLoadNV 154 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71
+                              Store 153(tempArg) 155
+             156:          32 Load 153(tempArg)
+                              Store 34(m) 156
+             157:          32 Load 34(m)
+             158:     72(ptr) AccessChain 70(block) 61 31
+                              CooperativeMatrixStoreNV 158 157 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71
+             160:     92(ptr) AccessChain 91(block16) 61 31
+             161:          50 CooperativeMatrixLoadNV 160 74 76 MakePointerVisibleKHR NonPrivatePointerKHR 71
+                              Store 159(tempArg) 161
+             162:          50 Load 159(tempArg)
+                              Store 52(m2) 162
+             163:          50 Load 52(m2)
+             164:     92(ptr) AccessChain 91(block16) 61 31
+                              CooperativeMatrixStoreNV 164 163 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71
+             167:          10 Load 165(p1)
+                              Store 166(param) 167
+             168:          10 FunctionCall 14(f16(f161;) 166(param)
+                              Store 165(p1) 168
+             171:          17 Load 169(p2)
+                              Store 170(param) 171
+             172:          17 FunctionCall 21(f32(f1;) 170(param)
+                              Store 169(p2) 172
+                              Store 165(p1) 173
+                              Store 169(p2) 174
+             175:          10 Load 165(p1)
+             176:          10 Load 165(p1)
+             177:          10 FDiv 176 175
+                              Store 165(p1) 177
+             179:          10 Load 165(p1)
+             180:          10 MatrixTimesScalar 179 178
+                              Store 165(p1) 180
+             182:          17 Load 169(p2)
+             183:          17 MatrixTimesScalar 182 181
+                              Store 169(p2) 183
+             192:    191(ptr) AccessChain 189(shmatrix) 83
+             193:          50 CooperativeMatrixLoadNV 192 190 76 MakePointerVisibleKHR NonPrivatePointerKHR 190
+                              Store 184(tempArg) 193
+             195:          50 Load 184(tempArg)
+                              Store 194(ms) 195
+             196:          50 Load 194(ms)
+             197:    191(ptr) AccessChain 189(shmatrix) 83
+                              CooperativeMatrixStoreNV 197 196 190 76 MakePointerAvailableKHR NonPrivatePointerKHR 190
+                              Return
+                              FunctionEnd
+   14(f16(f161;):          10 Function None 12
+           13(m):     11(ptr) FunctionParameter
+              15:             Label
+              23:          10 Load 13(m)
+              24:          10 FNegate 23
+                              ReturnValue 24
+                              FunctionEnd
+     21(f32(f1;):          17 Function None 19
+           20(m):     18(ptr) FunctionParameter
+              22:             Label
+              27:          17 Load 20(m)
+              28:          17 FNegate 27
+                              ReturnValue 28
+                              FunctionEnd

diff --git a/Test/baseResults/spv.coopmat_Error.comp.out b/Test/baseResults/spv.coopmat_Error.comp.out
new file mode 100644 (file)
index 0000000..49223b0
--- /dev/null
+++ b/Test/baseResults/spv.coopmat_Error.comp.out
@@ -0,0 +1,35 @@
+spv.coopmat_Error.comp
+ERROR: 0:8: 'ftemplate16' : unexpected type parameters 
+ERROR: 0:10: 'fnoparams' : expected four type parameters 
+ERROR: 0:12: 'fbadbits' : expected 16, 32, or 64 bits for first type parameter 
+ERROR: 0:14: 'fbadnumparams' : expected four type parameters 
+ERROR: 0:18: '' : type parameter must be a constant integer expression
+ERROR: 0:20: 'constant_id' : can only be applied to 'const'-qualified scalar 
+ERROR: 0:22: 'Cooperative matrix types must not be used in shared memory' : qualifier 
+ERROR: 0:25: 'bufmat' : member of block cannot be or contain a cooperative matrix type 
+ERROR: 0:34: 'assign' :  cannot convert from ' temp<16, 3, 16, 8> float16_t' to ' temp<32, 3, 16, 8> highp float'
+ERROR: 0:35: 'assign' :  cannot convert from ' temp<16, 3, 16, 8> float16_t' to ' temp<32, 3, 16, 8> highp float'
+ERROR: 0:40: 'assign' :  cannot convert from ' temp<16, 3, 8, 8> float16_t' to ' temp<16, 3, 16, 8> float16_t'
+ERROR: 0:46: 'assign' :  cannot convert from ' temp<16, 3, 8, 1> float16_t' to ' temp<16, 3, 8, 1> float16_t'
+ERROR: 0:49: 'constructor' : too many arguments 
+ERROR: 0:49: 'assign' :  cannot convert from ' const float' to ' temp<16, 3, 8, 8> float16_t'
+ERROR: 0:53: 'constructor' : Cooperative matrix constructor argument must be scalar or cooperative matrix 
+ERROR: 0:53: '=' :  cannot convert from ' const float' to ' temp<32, 3, 4, 4> highp float'
+ERROR: 0:56: 'expression' :  left of '[' is not of type array, matrix, or vector  
+ERROR: 0:59: '.' : cannot apply to a cooperative matrix type: x
+ERROR: 0:61: '*' :  wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' temp<16, 3, 16, 8> float16_t' (or there is no acceptable conversion)
+ERROR: 0:63: '+' :  wrong operand types: no operation '+' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion)
+ERROR: 0:64: '-' :  wrong operand types: no operation '-' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion)
+ERROR: 0:65: '/' :  wrong operand types: no operation '/' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion)
+ERROR: 0:66: 'assign' :  cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t'
+ERROR: 0:67: 'assign' :  cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t'
+ERROR: 0:68: 'assign' :  cannot convert from ' const float' to ' temp<16, 3, 16, 8> float16_t'
+ERROR: 0:70: '*' :  wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<16, 3, 16, 8> float16_t' and a right operand of type ' const float' (or there is no acceptable conversion)
+ERROR: 0:71: '*' :  wrong operand types: no operation '*' exists that takes a left-hand operand of type ' const float' and a right operand of type ' temp<16, 3, 16, 8> float16_t' (or there is no acceptable conversion)
+ERROR: 0:72: '*' :  wrong operand types: no operation '*' exists that takes a left-hand operand of type ' temp<32, 3, 16, 8> highp float' and a right operand of type ' const float16_t' (or there is no acceptable conversion)
+ERROR: 0:73: '*' :  wrong operand types: no operation '*' exists that takes a left-hand operand of type ' const float16_t' and a right operand of type ' temp<32, 3, 16, 8> highp float' (or there is no acceptable conversion)
+ERROR: 0:75: 'transpose' : no matching overloaded function found 
+ERROR: 30 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

diff --git a/Test/baseResults/vulkan.vert.out b/Test/baseResults/vulkan.vert.out
index 19fdade..6bfa188 100644 (file)
--- a/Test/baseResults/vulkan.vert.out
+++ b/Test/baseResults/vulkan.vert.out
@@ -30,14 +30,11 @@ ERROR: 0:32: 'initializer' : can't use with types containing arrays sized with a
 ERROR: 0:34: '=' : can't use with types containing arrays sized with a specialization constant 
 ERROR: 0:35: '==' : can't use with types containing arrays sized with a specialization constant 
 ERROR: 0:39: 'set' : cannot be used with push_constant 
-ERROR: 0:49: '[]' : only outermost dimension of an array of arrays can be a specialization constant 
-ERROR: 0:50: '[]' : only outermost dimension of an array of arrays can be a specialization constant 
-ERROR: 0:51: '[]' : only outermost dimension of an array of arrays can be a specialization constant 
 ERROR: 0:54: '[]' : only outermost dimension of an array of arrays can be a specialization constant 
 ERROR: 0:54: 'location' : SPIR-V requires location for user input/output 
 ERROR: 0:58: 'location' : SPIR-V requires location for user input/output 
 ERROR: 0:65: 'location' : overlapping use of location 10
-ERROR: 38 compilation errors.  No code generated.
+ERROR: 35 compilation errors.  No code generated.
 
 
 SPIR-V is not generated for failed compile or link

diff --git a/Test/spv.1.3.coopmat.comp b/Test/spv.1.3.coopmat.comp
new file mode 100644 (file)
index 0000000..23e0b78
--- /dev/null
+++ b/Test/spv.1.3.coopmat.comp
@@ -0,0 +1,28 @@
+#version 450 core
+#extension GL_KHR_memory_scope_semantics : enable\r
+#extension GL_NV_cooperative_matrix : enable\r
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable\r
+\r
+#pragma use_variable_pointers\r
+\r
+layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+\r
+layout(set = 0, binding = 0) coherent buffer Block {\r
+    float y[1024*1024];\r
+    float x[];\r
+} block;\r
+\r
+\r
+void main()
+{
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> m = fcoopmatNV<32, gl_ScopeSubgroup, 16, 8>(0.0);\r
+\r
+    m = m + m;\r
+    m = m - m;\r
+    m = -m;\r
+    m = 2.0*m;\r
+    m = m*2.0;\r
+\r
+    coopMatLoadNV(m, block.x, 16, 128, false);\r
+    coopMatStoreNV(m, block.x, 16, 128, false);\r
+}

diff --git a/Test/spv.coopmat.comp b/Test/spv.coopmat.comp
new file mode 100644 (file)
index 0000000..ab4292f
--- /dev/null
+++ b/Test/spv.coopmat.comp
@@ -0,0 +1,115 @@
+#version 450 core
+#extension GL_KHR_memory_scope_semantics : enable\r
+#extension GL_NV_cooperative_matrix : enable\r
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable\r
+#extension GL_EXT_buffer_reference : enable\r
+\r
+layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+\r
+const int X = 8;\r
+layout(constant_id = 0) const int Y = 2;\r
+const int Z = X*Y;\r
+\r
+fcoopmatNV<16, gl_ScopeSubgroup, Z, 8> mC;\r
+fcoopmatNV<16, gl_ScopeSubgroup, Z, 8> mC2[3];\r
+\r
+int arr[mC.length()];\r
+int arr2[mC2[1].length()];\r
+\r
+layout(constant_id = 1) const float F = 3.0;\r
+\r
+const fcoopmatNV<32, gl_ScopeSubgroup, Z, 8> mD = fcoopmatNV<32, gl_ScopeSubgroup, Z, 8>(0.0);\r
+const fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> mD2 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(1);\r
+\r
+struct S { int a; int b; int c; };\r
+\r
+const S s = S(12, 23, 34);\r
+\r
+layout(set = 0, binding = 0, buffer_reference) coherent buffer Block {\r
+    float y[1024*1024];\r
+    float x[];\r
+} block;\r
+\r
+layout(set = 0, binding = 0) coherent buffer Block16 {\r
+    float16_t y[1024*1024];\r
+    float16_t x[];\r
+\r
+    Block b;\r
+} block16;\r
+\r
+fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> f16(fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> m) { return -m; }\r
+fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> f32(fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> m) { return -m; }\r
+\r
+layout(constant_id = 2) const int SC = 1;\r
+fcoopmatNV<16, gl_ScopeSubgroup, SC, SC> scm[SC][SC];\r
+\r
+// sized for fcoopmatNV<16, gl_ScopeSubgroup, 16, 16>\r
+shared uvec4 shmatrix[16*16*2/16];\r
+\r
+void main()
+{
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)> m = fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)>(0.0);\r
+\r
+    m = m + m;\r
+    m = m - m;\r
+    m = -m;\r
+    m = 2.0*m;\r
+    m = m*2.0;\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> m2 = fcoopmatNV<16, gl_ScopeSubgroup, 16, 8>(m);\r
+\r
+    float x = m[1];\r
+    m[0] = x;\r
+\r
+    coopMatLoadNV(m, block.x, 16, 128, false);\r
+    coopMatStoreNV(m, block.x, 16, 128, false);\r
+    coopMatLoadNV(m2, block16.x, 16, 128, false);\r
+    coopMatStoreNV(m2, block16.x, 16, 128, false);\r
+    coopMatLoadNV(m, block16.b.x, 16, 128, false);\r
+    coopMatStoreNV(m, block16.b.x, 16, 128, false);\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> A;\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> B;\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> C;\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> D;\r
+    D = coopMatMulAddNV(A, B, C);\r
+\r
+    int l = D.length();\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> E;\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, Z, Z> F = fcoopmatNV<16, gl_ScopeSubgroup, Z, Z>(0.0);\r
+\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, (2>1?8:4)> a[5];\r
+    a[3][0] = 1.0;\r
+\r
+    float md1 = mD[1];\r
+\r
+    md1 += (m += m)[1234];\r
+\r
+    mC2[1] = mC2[2];\r
+\r
+    coopMatLoadNV(m, block.y, 16, 128, false);\r
+    coopMatStoreNV(m, block.y, 16, 128, false);\r
+    coopMatLoadNV(m2, block16.y, 16, 128, false);\r
+    coopMatStoreNV(m2, block16.y, 16, 128, false);\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> p1;\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 8, 8> p2;\r
+\r
+    p1 = f16(p1);\r
+    p2 = f32(p2);\r
+\r
+    p1 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(0.0);\r
+    p2 = fcoopmatNV<32, gl_ScopeSubgroup, 8, 8>(0.0);\r
+\r
+    p1 /= p1;\r
+\r
+    p1 *= float16_t(2.0);\r
+    p2 *= 4.0;\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> ms;\r
+    coopMatLoadNV(ms, shmatrix, 1, 2, false);\r
+    coopMatStoreNV(ms, shmatrix, 1, 2, false);\r
+\r
+}

diff --git a/Test/spv.coopmat_Error.comp b/Test/spv.coopmat_Error.comp
new file mode 100644 (file)
index 0000000..220aa98
--- /dev/null
+++ b/Test/spv.coopmat_Error.comp
@@ -0,0 +1,76 @@
+#version 450 core
+#extension GL_KHR_memory_scope_semantics : enable\r
+#extension GL_NV_cooperative_matrix : enable\r
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : enable\r
+\r
+layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+\r
+float<16> ftemplate16;\r
+\r
+fcoopmatNV fnoparams;\r
+\r
+fcoopmatNV<8, gl_ScopeSubgroup, 8, 8> fbadbits;\r
+\r
+fcoopmatNV<16, gl_ScopeSubgroup, 8> fbadnumparams;\r
+\r
+int X = 8;\r
+\r
+fcoopmatNV<16, gl_ScopeSubgroup, 8, X> fbadparam;\r
+\r
+layout(constant_id = 0) int Y = 1;\r
+\r
+shared fcoopmatNV<16, gl_ScopeSubgroup, 16, 16> sharedmat;\r
+\r
+layout(set = 0, binding = 0) buffer InvBlock {\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 16, 16> bufmat;\r
+} invblock;\r
+\r
+void main()
+{\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 16, 8> f32_16_8;\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 16, 8> f16_16_8;\r
+\r
+    // invalid implicit conversions\r
+    f32_16_8 = f16_16_8;\r
+    f32_16_8 = f16_16_8 + f16_16_8;\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, 8> f16_8_8;\r
+\r
+    // mismatching dimensions\r
+    f16_16_8 = f16_8_8;\r
+\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, Y> f16_8_Y;\r
+    fcoopmatNV<16, gl_ScopeSubgroup, 8, (Y+1)> f16_8_Y1;\r
+\r
+    // mismatching dimensions with specialization constants\r
+    f16_8_Y = f16_8_Y1;\r
+\r
+    // wrong arguments for constructor\r
+    f16_8_8 = fcoopmatNV<16, gl_ScopeSubgroup, 8, 8>(1, 1);\r
+\r
+    // can't construct from a builtin type\r
+    mat4 m4;\r
+    fcoopmatNV<32, gl_ScopeSubgroup, 4, 4> f32_4_4 = fcoopmatNV<32, gl_ScopeSubgroup, 4, 4>(m4);\r
+\r
+    // only support a single array subscript\r
+    f16_16_8[0][0];\r
+\r
+    // don't support scalar component selection\r
+    f16_16_8.x;\r
+\r
+    f16_16_8 * f16_16_8;\r
+\r
+    f16_16_8 + 1.0;\r
+    f16_16_8 - 1.0;\r
+    f16_16_8 / 1.0;\r
+    f16_16_8 += 1.0;\r
+    f16_16_8 -= 1.0;\r
+    f16_16_8 /= 1.0;\r
+\r
+    f16_16_8*2.0;\r
+    2.0*f16_16_8;\r
+    f32_16_8*float16_t(2.0);\r
+    float16_t(2.0)*f32_16_8;\r
+\r
+    transpose(f16_8_8);\r
+}

diff --git a/Test/vulkan.vert b/Test/vulkan.vert
index a6af2d5..0fad1de 100644 (file)
--- a/Test/vulkan.vert
+++ b/Test/vulkan.vert
@@ -46,9 +46,9 @@ layout(set = 1, push_constant) uniform badpc { int a; } badpcI;  // ERROR, no de
 #error VULKAN should be 100\r
 #endif\r
 \r
-float AofA0[2][arraySize];              // ERROR, only outer dimension\r
-float AofA1[arraySize][arraySize];      // ERROR, only outer dimension\r
-float AofA2[arraySize][2 + arraySize];  // ERROR, only outer dimension\r
+float AofA0[2][arraySize];\r
+float AofA1[arraySize][arraySize];\r
+float AofA2[arraySize][2 + arraySize];\r
 float AofA3[arraySize][2];\r
 \r
 out ban1 {                              // ERROR, only outer dimension\r

diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h
index 4663a35..1cbecab 100644 (file)
--- a/glslang/Include/Types.h
+++ b/glslang/Include/Types.h
@@ -1235,9 +1235,11 @@ public:
     int vectorSize : 4;
     int matrixCols : 4;
     int matrixRows : 4;
+    bool coopmat   : 1;
     TArraySizes* arraySizes;
     const TType* userDef;
     TSourceLoc loc;
+    TArraySizes* typeParameters;
 
     void initType(const TSourceLoc& l)
     {
@@ -1248,6 +1250,8 @@ public:
         arraySizes = nullptr;
         userDef = nullptr;
         loc = l;
+        typeParameters = nullptr;
+        coopmat = false;
     }
 
     void initQualifiers(bool global = false)
@@ -1299,8 +1303,8 @@ public:
     // for "empty" type (no args) or simple scalar/vector/matrix
     explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0,
                    bool isVector = false) :
-                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr)
+                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false),
+                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1310,8 +1314,8 @@ public:
     // for explicit precision qualifier
     TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0,
           bool isVector = false) :
-                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr)
+                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false),
+                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1323,8 +1327,8 @@ public:
     // for turning a TPublicType into a TType, using a shallow copy
     explicit TType(const TPublicType& p) :
                             basicType(p.basicType),
-                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false),
-                            arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr)
+                            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)
                             {
                                 if (basicType == EbtSampler)
                                     sampler = p.sampler;
@@ -1340,12 +1344,18 @@ public:
                                     }
                                     typeName = NewPoolTString(p.userDef->getTypeName().c_str());
                                 }
+                                if (p.coopmat && p.basicType == EbtFloat &&
+                                    p.typeParameters && p.typeParameters->getNumDims() > 0 &&
+                                    p.typeParameters->getDimSize(0) == 16) {
+                                    basicType = EbtFloat16;
+                                    qualifier.precision = EpqNone;
+                                }
                             }
     // for construction of sampler types
     TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) :
-        basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false),
+        basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
         arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
-        sampler(sampler)
+        sampler(sampler), typeParameters(nullptr)
     {
         qualifier.clear();
         qualifier.storage = q;
@@ -1386,13 +1396,16 @@ public:
                                         // dereference from vector to scalar
                                         vectorSize = 1;
                                         vector1 = false;
+                                    } else if (isCoopMat()) {
+                                        coopmat = false;
+                                        typeParameters = nullptr;
                                     }
                                 }
                             }
     // for making structures, ...
     TType(TTypeList* userDef, const TString& n) :
-                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false),
-                            arraySizes(nullptr), structure(userDef), fieldName(nullptr)
+                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
+                            arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -1400,8 +1413,8 @@ public:
                             }
     // For interface blocks
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) :
-                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false),
-                            qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr)
+                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false),
+                            qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr)
                             {
                                 sampler.clear();
                                 typeName = NewPoolTString(n.c_str());
@@ -1439,6 +1452,8 @@ public:
         } else {
             referentType = copyOf.referentType;
         }
+        typeParameters = copyOf.typeParameters;
+        coopmat = copyOf.coopmat;
     }
 
     // Make complete copy of the whole type graph rooted at 'copyOf'.
@@ -1502,6 +1517,8 @@ public:
     virtual const TArraySizes* getArraySizes() const { return arraySizes; }
     virtual       TArraySizes* getArraySizes()       { return arraySizes; }
     virtual TType* getReferentType() const { return referentType; }
+    virtual const TArraySizes* getTypeParameters() const { return typeParameters; }
+    virtual       TArraySizes* getTypeParameters()       { return typeParameters; }
 
     virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); }
     virtual bool isScalarOrVec1() const { return isScalar() || vector1; }
@@ -1544,6 +1561,8 @@ public:
     virtual bool isImage()   const { return basicType == EbtSampler && getSampler().isImage(); }
     virtual bool isSubpass() const { return basicType == EbtSampler && getSampler().isSubpass(); }
     virtual bool isTexture() const { return basicType == EbtSampler && getSampler().isTexture(); }
+    virtual bool isParameterized()  const { return typeParameters != nullptr; }
+    virtual bool isCoopMat() const { return coopmat; }
 
     // return true if this type contains any subtype which satisfies the given predicate.
     template <typename P>
@@ -1633,6 +1652,11 @@ public:
         return containsBasicType(EbtInt8) || containsBasicType(EbtUint8);
     }
 
+    virtual bool containsCoopMat() const
+    {
+        return contains([](const TType* t) { return t->coopmat; } );
+    }
+
     // Array editing methods.  Array descriptors can be shared across
     // type instances.  This allows all uses of the same array
     // to be updated at once.  E.g., all nodes can be explicitly sized
@@ -1705,6 +1729,46 @@ public:
         }
     }
 
+
+    void updateTypeParameters(const TType& type)
+    {
+        // For when we may already be sharing existing array descriptors,
+        // keeping the pointers the same, just updating the contents.
+        assert(typeParameters != nullptr);
+        assert(type.typeParameters != nullptr);
+        *typeParameters = *type.typeParameters;
+    }
+    void copyTypeParameters(const TArraySizes& s)
+    {
+        // For setting a fresh new set of type parameters, not yet worrying about sharing.
+        typeParameters = new TArraySizes;
+        *typeParameters = s;
+    }
+    void transferTypeParameters(TArraySizes* s)
+    {
+        // For setting an already allocated set of sizes that this type can use
+        // (no copy made).
+        typeParameters = s;
+    }
+    void clearTypeParameters()
+    {
+        typeParameters = nullptr;
+    }
+
+    // Add inner array sizes, to any existing sizes, via copy; the
+    // sizes passed in can still be reused for other purposes.
+    void copyTypeParametersInnerSizes(const TArraySizes* s)
+    {
+        if (s != nullptr) {
+            if (typeParameters == nullptr)
+                copyTypeParameters(*s);
+            else
+                typeParameters->addInnerSizes(*s);
+        }
+    }
+
+
+
     const char* getBasicString() const
     {
         return TType::getBasicString(basicType);
@@ -1919,6 +1983,15 @@ public:
                 }
             }
         }
+        if (isParameterized()) {
+            appendStr("<");
+            for(int i = 0; i < (int)typeParameters->getNumDims(); ++i) {
+                appendInt(typeParameters->getDimSize(i));
+                if (i != (int)typeParameters->getNumDims() - 1)
+                    appendStr(", ");
+            }
+            appendStr(">");
+        }
         if (qualifier.precision != EpqNone) {
             appendStr(" ");
             appendStr(getPrecisionQualifierString());
@@ -2075,6 +2148,13 @@ public:
         return arraySizes->sameInnerArrayness(*right.arraySizes);
     }
 
+    // See if two type's parameters match
+    bool sameTypeParameters(const TType& right) const
+    {
+        return ((typeParameters == nullptr && right.typeParameters == nullptr) ||
+                (typeParameters != nullptr && right.typeParameters != nullptr && *typeParameters == *right.typeParameters));
+    }
+
     // See if two type's elements match in all ways except basic type
     bool sameElementShape(const TType& right) const
     {
@@ -2083,14 +2163,23 @@ public:
                matrixCols == right.matrixCols &&
                matrixRows == right.matrixRows &&
                   vector1 == right.vector1    &&
+                  coopmat == right.coopmat    &&
                sameStructType(right)          &&
                sameReferenceType(right);
     }
 
+    // See if a cooperative matrix type parameter with unspecified parameters is
+    // an OK function parameter
+    bool coopMatParameterOK(const TType& right) const
+    {
+        return coopmat && right.coopmat &&
+               typeParameters == nullptr && right.typeParameters != nullptr;
+    }
+
     // See if two types match in all ways (just the actual type, not qualification)
     bool operator==(const TType& right) const
     {
-        return sameElementType(right) && sameArrayness(right);
+        return sameElementType(right) && sameArrayness(right) && sameTypeParameters(right);
     }
 
     bool operator!=(const TType& right) const
@@ -2115,6 +2204,11 @@ protected:
             *arraySizes = *copyOf.arraySizes;
         }
 
+        if (copyOf.typeParameters) {
+            typeParameters = new TArraySizes;
+            *typeParameters = *copyOf.typeParameters;
+        }
+
         if (copyOf.isStruct() && copyOf.structure) {
             auto prevCopy = copiedMap.find(copyOf.structure);
             if (prevCopy != copiedMap.end())
@@ -2150,6 +2244,7 @@ protected:
                                // functionality is added.
                                // HLSL does have a 1-component vectors, so this will be true to disambiguate
                                // from a scalar.
+    bool coopmat         : 1;
     TQualifier qualifier;
 
     TArraySizes* arraySizes;    // nullptr unless an array; can be shared across types
@@ -2162,6 +2257,7 @@ protected:
     TString *fieldName;         // for structure field names
     TString *typeName;          // for structure type name
     TSampler sampler;
+    TArraySizes* typeParameters;// nullptr unless a parameterized type; can be shared across types
 };
 
 } // end namespace glslang

diff --git a/glslang/Include/arrays.h b/glslang/Include/arrays.h
index af8f560..7f047d9 100644 (file)
--- a/glslang/Include/arrays.h
+++ b/glslang/Include/arrays.h
@@ -254,7 +254,9 @@ struct TArraySizes {
     void addInnerSize() { addInnerSize((unsigned)UnsizedArraySize); }
     void addInnerSize(int s) { addInnerSize((unsigned)s, nullptr); }
     void addInnerSize(int s, TIntermTyped* n) { sizes.push_back((unsigned)s, n); }
-    void addInnerSize(TArraySize pair) { sizes.push_back(pair.size, pair.node); }
+    void addInnerSize(TArraySize pair) {
+        sizes.push_back(pair.size, pair.node);
+    }
     void addInnerSizes(const TArraySizes& s) { sizes.push_back(s.sizes); }
     void changeOuterSize(int s) { sizes.changeFront((unsigned)s); }
     int getImplicitSize() const { return implicitArraySize; }
@@ -318,8 +320,8 @@ struct TArraySizes {
     void setVariablyIndexed() { variablyIndexed = true; }
     bool isVariablyIndexed() const { return variablyIndexed; }
 
-    bool operator==(const TArraySizes& rhs) { return sizes == rhs.sizes; }
-    bool operator!=(const TArraySizes& rhs) { return sizes != rhs.sizes; }
+    bool operator==(const TArraySizes& rhs) const { return sizes == rhs.sizes; }
+    bool operator!=(const TArraySizes& rhs) const { return sizes != rhs.sizes; }
 
 protected:
     TSmallArrayVector sizes;

diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
index 4b6bcb7..32e684c 100644 (file)
--- a/glslang/Include/intermediate.h
+++ b/glslang/Include/intermediate.h
@@ -615,6 +615,10 @@ enum TOperator {
     EOpAny,
     EOpAll,
 
+    EOpCooperativeMatrixLoad,
+    EOpCooperativeMatrixStore,
+    EOpCooperativeMatrixMulAdd,
+
     //
     // Branch
     //
@@ -737,6 +741,7 @@ enum TOperator {
     EOpConstructTextureSampler,
     EOpConstructNonuniform,     // expected to be transformed away, not present in final AST
     EOpConstructReference,
+    EOpConstructCooperativeMatrix,
     EOpConstructGuardEnd,
 
     //

diff --git a/glslang/MachineIndependent/Constant.cpp b/glslang/MachineIndependent/Constant.cpp
old mode 100755 (executable)
new mode 100644 (file)
index a6adab1..1cf6565
--- a/glslang/MachineIndependent/Constant.cpp
+++ b/glslang/MachineIndependent/Constant.cpp
@@ -1354,7 +1354,9 @@ TIntermTyped* TIntermediate::foldDereference(TIntermTyped* node, int index, cons
     // arrays, vectors, matrices, all use simple multiplicative math
     // while structures need to add up heterogeneous members
     int start;
-    if (node->isArray() || ! node->isStruct())
+    if (node->getType().isCoopMat())
+        start = 0;
+    else if (node->isArray() || ! node->isStruct())
         start = size * index;
     else {
         // it is a structure

diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp
old mode 100755 (executable)
new mode 100644 (file)
index e399ead..f4df3e7
--- a/glslang/MachineIndependent/Initialize.cpp
+++ b/glslang/MachineIndependent/Initialize.cpp
@@ -4928,6 +4928,34 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
     commonBuiltins.append("void controlBarrier(int, int, int, int);\n"
                           "void memoryBarrier(int, int, int);\n");
 
+    if (profile != EEsProfile && version >= 450) {
+        // coopMatStoreNV perhaps ought to have "out" on the buf parameter, but
+        // adding it introduces undesirable tempArgs on the stack. What we want
+        // is more like "buf" thought of as a pointer value being an in parameter.
+        stageBuiltins[EShLangCompute].append(
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent float16_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent float[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint8_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint16_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uint64_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uvec2[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatLoadNV(out fcoopmatNV m, volatile coherent uvec4[] buf, uint element, uint stride, bool colMajor);\n"
+
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent float16_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent float[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent float64_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint8_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint16_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uint64_t[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uvec2[] buf, uint element, uint stride, bool colMajor);\n"
+            "void coopMatStoreNV(fcoopmatNV m, volatile coherent uvec4[] buf, uint element, uint stride, bool colMajor);\n"
+
+            "fcoopmatNV coopMatMulAddNV(fcoopmatNV A, fcoopmatNV B, fcoopmatNV C);\n"
+            );
+    }
+
     //============================================================================
     //
     // Prototypes for built-in functions seen by fragment shaders only.
@@ -8658,6 +8686,11 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
 
             symbolTable.setFunctionExtensions("subgroupMemoryBarrierShared", 1, &E_GL_KHR_shader_subgroup_basic);
         }
+
+        symbolTable.setFunctionExtensions("coopMatLoadNV",              1, &E_GL_NV_cooperative_matrix);
+        symbolTable.setFunctionExtensions("coopMatStoreNV",             1, &E_GL_NV_cooperative_matrix);
+        symbolTable.setFunctionExtensions("coopMatMulAddNV",            1, &E_GL_NV_cooperative_matrix);
+
         break;
 #ifdef NV_EXTENSIONS
     case EShLangRayGenNV:
@@ -9462,6 +9495,9 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
             symbolTable.relateToOperator("fwidthCoarse",EOpFwidthCoarse);
         }
 #endif
+        symbolTable.relateToOperator("coopMatLoadNV",              EOpCooperativeMatrixLoad);
+        symbolTable.relateToOperator("coopMatStoreNV",             EOpCooperativeMatrixStore);
+        symbolTable.relateToOperator("coopMatMulAddNV",            EOpCooperativeMatrixMulAdd);
         break;
 
 #ifdef NV_EXTENSIONS

diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 32b38a0..8ab4af9
--- a/glslang/MachineIndependent/Intermediate.cpp
+++ b/glslang/MachineIndependent/Intermediate.cpp
@@ -725,6 +725,11 @@ TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped
     return newNode;
 }
 
+TIntermTyped* TIntermediate::addConversion(TBasicType convertTo, TIntermTyped* node) const
+{
+    return createConversion(convertTo, node);
+}
+
 // For converting a pair of operands to a binary operation to compatible
 // types with each other, relative to the operation in 'op'.
 // This does not cover assignment operations, which is asymmetric in that the
@@ -751,6 +756,10 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
         // If differing arrays, then no conversions.
         if (node0->getType().isArray() || node1->getType().isArray())
             return std::make_tuple(nullptr, nullptr);
+
+        // No implicit conversions for operations involving cooperative matrices
+        if (node0->getType().isCoopMat() || node1->getType().isCoopMat())
+            return std::make_tuple(node0, node1);
     }
 
     auto promoteTo = std::make_tuple(EbtNumTypes, EbtNumTypes);
@@ -983,6 +992,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
 
     case EOpSequence:
     case EOpConstructStruct:
+    case EOpConstructCooperativeMatrix:
 
         if (type.getBasicType() == EbtReference || node->getType().getBasicType() == EbtReference) {
             // types must match to assign a reference
@@ -998,7 +1008,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         if (canImplicitlyPromote(node->getBasicType(), type.getBasicType(), op))
             promoteTo = type.getBasicType();
         else
-           return nullptr;
+            return nullptr;
         break;
 
     // For GLSL, there are no conversions needed; the shift amount just needs to be an
@@ -1847,6 +1857,9 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
     if (type.getQualifier().nonUniform)
         return EOpConstructNonuniform;
 
+    if (type.isCoopMat())
+        return EOpConstructCooperativeMatrix;
+
     switch (type.getBasicType()) {
     case EbtStruct:
         op = EOpConstructStruct;
@@ -3319,6 +3332,40 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
         break;
     }
 
+    if (left->getType().isCoopMat() || right->getType().isCoopMat()) {
+        if (left->getType().isCoopMat() && right->getType().isCoopMat() &&
+            *left->getType().getTypeParameters() != *right->getType().getTypeParameters()) {
+            return false;
+        }
+        switch (op) {
+        case EOpMul:
+        case EOpMulAssign:
+            if (left->getType().isCoopMat() && right->getType().isCoopMat()) {
+                return false;
+            }
+            if (op == EOpMulAssign && right->getType().isCoopMat()) {
+                return false;
+            }
+            node.setOp(op == EOpMulAssign ? EOpMatrixTimesScalarAssign : EOpMatrixTimesScalar);
+            if (right->getType().isCoopMat()) {
+                node.setType(right->getType());
+            }
+            return true;
+        case EOpAdd:
+        case EOpSub:
+        case EOpDiv:
+        case EOpAssign:
+            // These require both to be cooperative matrices
+            if (!left->getType().isCoopMat() || !right->getType().isCoopMat()) {
+                return false;
+            }
+            return true;
+        default:
+            break;
+        }
+        return false;
+    }
+
     // Finish handling the case, for all ops, where both operands are scalars.
     if (left->isScalar() && right->isScalar())
         return true;

diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
old mode 100755 (executable)
new mode 100644 (file)
index cf40baa..f0dbec2
--- a/glslang/MachineIndependent/ParseHelper.cpp
+++ b/glslang/MachineIndependent/ParseHelper.cpp
@@ -275,6 +275,12 @@ void TParseContext::handlePragma(const TSourceLoc& loc, const TVector<TString>&
         if (tokens.size() != 1)
             error(loc, "extra tokens", "#pragma", "");
         intermediate.setUseVulkanMemoryModel();
+    } else if (spvVersion.spv > 0 && tokens[0].compare("use_variable_pointers") == 0) {
+        if (tokens.size() != 1)
+            error(loc, "extra tokens", "#pragma", "");
+        if (spvVersion.spv < glslang::EShTargetSpv_1_3)
+            error(loc, "requires SPIR-V 1.3", "#pragma use_variable_pointers", "");
+        intermediate.setUseVariablePointers();
     } else if (tokens[0].compare("once") == 0) {
         warn(loc, "not implemented", "#pragma once", "");
     } else if (tokens[0].compare("glslang_binary_double_output") == 0)
@@ -371,7 +377,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn
     // basic type checks...
     variableCheck(base);
 
-    if (! base->isArray() && ! base->isMatrix() && ! base->isVector()) {
+    if (! base->isArray() && ! base->isMatrix() && ! base->isVector() && ! base->getType().isCoopMat()) {
         if (base->getAsSymbolNode())
             error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), "");
         else
@@ -767,7 +773,7 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm
             const char* feature = ".length() on vectors and matrices";
             requireProfile(loc, ~EEsProfile, feature);
             profileRequires(loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, feature);
-        } else {
+        } else if (!base->getType().isCoopMat()) {
             error(loc, "does not operate on this type:", field.c_str(), base->getType().getCompleteString().c_str());
 
             return base;
@@ -784,6 +790,11 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm
         return base;
     }
 
+    if (base->getType().isCoopMat()) {
+        error(loc, "cannot apply to a cooperative matrix type:", ".", field.c_str());
+        return base;
+    }
+
     // It's neither an array nor .length() if we get here,
     // leaving swizzles and struct/block dereferences.
 
@@ -1204,6 +1215,13 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                 }
                 result = addOutputArgumentConversions(*fnCandidate, *result->getAsAggregate());
             }
+
+            if (result->getAsTyped()->getType().isCoopMat() &&
+               !result->getAsTyped()->getType().isParameterized()) {
+                assert(fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAdd);
+
+                result->setType(result->getAsAggregate()->getSequence()[2]->getAsTyped()->getType());
+            }
         }
     }
 
@@ -1430,6 +1448,8 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction
             length = type.getMatrixCols();
         else if (type.isVector())
             length = type.getVectorSize();
+        else if (type.isCoopMat())
+            return intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, intermNode, TType(EbtInt));
         else {
             // we should not get here, because earlier semantic checking should have prevented this path
             error(loc, ".length()", "unexpected use of .length()", "");
@@ -1456,7 +1476,8 @@ void TParseContext::addInputArgumentConversions(const TFunction& function, TInte
         // means take 'arguments' itself as the one argument.
         TIntermTyped* arg = function.getParamCount() == 1 ? arguments->getAsTyped() : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped());
         if (*function[i].type != arg->getType()) {
-            if (function[i].type->getQualifier().isParamInput()) {
+            if (function[i].type->getQualifier().isParamInput() &&
+               !function[i].type->isCoopMat()) {
                 // In-qualified arguments just need an extra node added above the argument to
                 // convert to the correct type.
                 arg = intermediate.addConversion(EOpFunctionCall, *function[i].type, arg);
@@ -1524,7 +1545,14 @@ TIntermTyped* TParseContext::addOutputArgumentConversions(const TFunction& funct
             if (function[i].type->getQualifier().isParamOutput()) {
                 // Out-qualified arguments need to use the topology set up above.
                 // do the " ...(tempArg, ...), arg = tempArg" bit from above
-                TVariable* tempArg = makeInternalVariable("tempArg", *function[i].type);
+                TType paramType;
+                paramType.shallowCopy(*function[i].type);
+                if (arguments[i]->getAsTyped()->getType().isParameterized() &&
+                    !paramType.isParameterized()) {
+                    paramType.shallowCopy(arguments[i]->getAsTyped()->getType());
+                    paramType.copyTypeParameters(*arguments[i]->getAsTyped()->getType().getTypeParameters());
+                }
+                TVariable* tempArg = makeInternalVariable("tempArg", paramType);
                 tempArg->getWritableType().getQualifier().makeTemporary();
                 TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, intermNode.getLoc());
                 TIntermTyped* tempAssign = intermediate.addAssign(EOpAssign, arguments[i]->getAsTyped(), tempArgNode, arguments[i]->getLoc());
@@ -2913,6 +2941,16 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T
         return true;
     }
 
+    if (type.isCoopMat() && function.getParamCount() != 1) {
+        error(loc, "wrong number of arguments", "constructor", "");
+        return true;
+    }
+    if (type.isCoopMat() &&
+        !(function[0].type->isScalar() || function[0].type->isCoopMat())) {
+        error(loc, "Cooperative matrix constructor argument must be scalar or cooperative matrix", "constructor", "");
+        return true;
+    }
+
     TIntermTyped* typed = node->getAsTyped();
     if (typed == nullptr) {
         error(loc, "constructor argument does not have a type", "constructor", "");
@@ -3534,7 +3572,7 @@ bool TParseContext::containsFieldWithBasicType(const TType& type, TBasicType bas
 //
 // Do size checking for an array type's size.
 //
-void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair)
+void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair, const char *sizeType)
 {
     bool isConst = false;
     sizePair.node = nullptr;
@@ -3554,18 +3592,24 @@ void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TA
             TIntermSymbol* symbol = expr->getAsSymbolNode();
             if (symbol && symbol->getConstArray().size() > 0)
                 size = symbol->getConstArray()[0].getIConst();
+        } else if (expr->getAsUnaryNode() &&
+                   expr->getAsUnaryNode()->getOp() == glslang::EOpArrayLength &&
+                   expr->getAsUnaryNode()->getOperand()->getType().isCoopMat()) {
+            isConst = true;
+            size = 1;
+            sizePair.node = expr->getAsUnaryNode();
         }
     }
 
     sizePair.size = size;
 
     if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) {
-        error(loc, "array size must be a constant integer expression", "", "");
+        error(loc, sizeType, "", "must be a constant integer expression");
         return;
     }
 
     if (size <= 0) {
-        error(loc, "array size must be a positive integer", "", "");
+        error(loc, sizeType, "", "must be a positive integer");
         return;
     }
 }
@@ -3623,7 +3667,7 @@ bool TParseContext::arrayError(const TSourceLoc& loc, const TType& type)
 //
 void TParseContext::arraySizeRequiredCheck(const TSourceLoc& loc, const TArraySizes& arraySizes)
 {
-    if (arraySizes.hasUnsized())
+    if (!parsingBuiltins && arraySizes.hasUnsized())
         error(loc, "array size required", "", "");
 }
 
@@ -3660,7 +3704,8 @@ void TParseContext::arraySizesCheck(const TSourceLoc& loc, const TQualifier& qua
         arraySizes->clearInnerUnsized();
     }
 
-    if (arraySizes->isInnerSpecialization())
+    if (arraySizes->isInnerSpecialization() &&
+        (qualifier.storage != EvqTemporary && qualifier.storage != EvqGlobal && qualifier.storage != EvqShared && qualifier.storage != EvqConst))
         error(loc, "only outermost dimension of an array of arrays can be a specialization constant", "[]", "");
 
     // desktop always allows outer-dimension-unsized variable arrays,
@@ -6035,9 +6080,18 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu
     symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn);
 
     // can 'from' convert to 'to'?
-    const auto convertible = [this](const TType& from, const TType& to, TOperator, int) -> bool {
+    const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool {
         if (from == to)
             return true;
+        if (from.coopMatParameterOK(to))
+            return true;
+        // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions
+        if (builtIn && from.isArray() && to.isUnsizedArray()) {
+            TType fromElementType(from, 0);
+            TType toElementType(to, 0);
+            if (fromElementType == toElementType)
+                return true;
+        }
         if (from.isArray() || to.isArray() || ! from.sameElementShape(to))
             return false;
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
@@ -6100,9 +6154,18 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc,
     symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn);
 
     // can 'from' convert to 'to'?
-    const auto convertible = [this](const TType& from, const TType& to, TOperator, int) -> bool {
+    const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool {
         if (from == to)
             return true;
+        if (from.coopMatParameterOK(to))
+            return true;
+        // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions
+        if (builtIn && from.isArray() && to.isUnsizedArray()) {
+            TType fromElementType(from, 0);
+            TType toElementType(to, 0);
+            if (fromElementType == toElementType)
+                return true;
+        }
         if (from.isArray() || to.isArray() || ! from.sameElementShape(to))
             return false;
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
@@ -6194,6 +6257,25 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
     type.copyArrayInnerSizes(publicType.arraySizes);
     arrayOfArrayVersionCheck(loc, type.getArraySizes());
 
+    if (type.isCoopMat()) {
+        intermediate.setUseVulkanMemoryModel();
+        intermediate.setUseStorageBuffer();
+
+        if (!publicType.typeParameters || publicType.typeParameters->getNumDims() != 4) {
+            error(loc, "expected four type parameters", identifier.c_str(), "");
+        }
+        if (publicType.typeParameters &&
+            publicType.typeParameters->getDimSize(0) != 16 &&
+            publicType.typeParameters->getDimSize(0) != 32 &&
+            publicType.typeParameters->getDimSize(0) != 64) {
+            error(loc, "expected 16, 32, or 64 bits for first type parameter", identifier.c_str(), "");
+        }
+    } else {
+        if (publicType.typeParameters && publicType.typeParameters->getNumDims() != 0) {
+            error(loc, "unexpected type parameters", identifier.c_str(), "");
+        }
+    }
+
     if (voidErrorCheck(loc, identifier, type.getBasicType()))
         return nullptr;
 
@@ -6218,6 +6300,10 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
             requireInt8Arithmetic(loc, "qualifier", "(u)int8 types can only be in uniform block or buffer storage");
     }
 
+    if (type.getQualifier().storage == EvqShared &&
+        type.containsCoopMat())
+        error(loc, "qualifier", "Cooperative matrix types must not be used in shared memory", "");
+
     if (identifier != "gl_FragCoord" && (publicType.shaderQualifiers.originUpperLeft || publicType.shaderQualifiers.pixelCenterInteger))
         error(loc, "can only apply origin_upper_left and pixel_center_origin to gl_FragCoord", "layout qualifier", "");
     if (identifier != "gl_FragDepth" && publicType.shaderQualifiers.layoutDepth != EldNone)
@@ -6809,6 +6895,33 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
             return nullptr;
         }
 
+    case EOpConstructCooperativeMatrix:
+        if (!node->getType().isCoopMat()) {
+            if (type.getBasicType() != node->getType().getBasicType()) {
+                node = intermediate.addConversion(type.getBasicType(), node);
+            }
+            node = intermediate.setAggregateOperator(node, EOpConstructCooperativeMatrix, type, node->getLoc());
+        } else {
+            switch (type.getBasicType()) {
+            default:
+                assert(0);
+                break;
+            case EbtFloat:
+                assert(node->getType().getBasicType() == EbtFloat16);
+                node = intermediate.addUnaryNode(EOpConvFloat16ToFloat, node, node->getLoc(), type);
+                break;
+            case EbtFloat16:
+                assert(node->getType().getBasicType() == EbtFloat);
+                node = intermediate.addUnaryNode(EOpConvFloatToFloat16, node, node->getLoc(), type);
+                break;
+            }
+            // If it's a (non-specialization) constant, it must be folded.
+            if (node->getAsUnaryNode()->getOperand()->getAsConstantUnion())
+                return node->getAsUnaryNode()->getOperand()->getAsConstantUnion()->fold(op, node->getType());
+        }
+
+        return node;
+
     default:
         error(loc, "unsupported construction", "", "");
 
@@ -6895,6 +7008,9 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con
 
         if (memberType.containsOpaque())
             error(memberLoc, "member of block cannot be or contain a sampler, image, or atomic_uint type", typeList[member].type->getFieldName().c_str(), "");
+
+        if (memberType.containsCoopMat())
+            error(memberLoc, "member of block cannot be or contain a cooperative matrix type", typeList[member].type->getFieldName().c_str(), "");
     }
 
     // This might be a redeclaration of a built-in block.  If so, redeclareBuiltinBlock() will

diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h
old mode 100755 (executable)
new mode 100644 (file)
index f61345d..0b21798
--- a/glslang/MachineIndependent/ParseHelper.h
+++ b/glslang/MachineIndependent/ParseHelper.h
@@ -337,7 +337,7 @@ public:
     void globalCheck(const TSourceLoc&, const char* token);
     bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
     bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
-    void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&);
+    void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType);
     bool arrayQualifierError(const TSourceLoc&, const TQualifier&);
     bool arrayError(const TSourceLoc&, const TType&);
     void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);

diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
index 49ce077..482f6ba 100644 (file)
--- a/glslang/MachineIndependent/Scan.cpp
+++ b/glslang/MachineIndependent/Scan.cpp
@@ -714,6 +714,8 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["taskNV"] =                  PERTASKNV;
 #endif
 
+    (*KeywordMap)["fcoopmatNV"] =              FCOOPMATNV;
+
     ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
 
     ReservedSet->insert("common");
@@ -1612,6 +1614,13 @@ int TScanContext::tokenizeIdentifier()
         return identifierOrType();
 #endif
 
+    case FCOOPMATNV:
+        afterType = true;
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix))
+            return keyword;
+        return identifierOrType();
+
     default:
         parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc);
         return 0;

diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
old mode 100755 (executable)
new mode 100644 (file)
index f78ffd0..0d4b994
--- a/glslang/MachineIndependent/Versions.cpp
+++ b/glslang/MachineIndependent/Versions.cpp
@@ -248,6 +248,8 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_NV_mesh_shader]                           = EBhDisable;
 #endif
 
+    extensionBehavior[E_GL_NV_cooperative_matrix]                    = EBhDisable;
+
     // AEP
     extensionBehavior[E_GL_ANDROID_extension_pack_es31a]             = EBhDisable;
     extensionBehavior[E_GL_KHR_blend_equation_advanced]              = EBhDisable;
@@ -427,6 +429,8 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_NV_shader_texture_footprint 1\n"
             "#define GL_NV_mesh_shader 1\n"
 #endif
+            "#define GL_NV_cooperative_matrix 1\n"
+
             "#define GL_EXT_shader_explicit_arithmetic_types 1\n"
             "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
             "#define GL_EXT_shader_explicit_arithmetic_types_int16 1\n"
@@ -1083,6 +1087,14 @@ void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool buil
     }
 }
 
+void TParseVersions::fcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_NV_cooperative_matrix};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
 // Call for any operation removed because SPIR-V is in use.
 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
 {

diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
index 72018d8..e571b51 100755 (executable)
--- a/glslang/MachineIndependent/Versions.h
+++ b/glslang/MachineIndependent/Versions.h
@@ -225,6 +225,8 @@ const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_
 const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
 #endif
 
+const char* const E_GL_NV_cooperative_matrix                    = "GL_NV_cooperative_matrix";
+
 // AEP
 const char* const E_GL_ANDROID_extension_pack_es31a             = "GL_ANDROID_extension_pack_es31a";
 const char* const E_GL_KHR_blend_equation_advanced              = "GL_KHR_blend_equation_advanced";

diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
old mode 100755 (executable)
new mode 100644 (file)
index 90be7a7..92229d2
--- a/glslang/MachineIndependent/glslang.y
+++ b/glslang/MachineIndependent/glslang.y
@@ -100,6 +100,7 @@ using namespace glslang;
             glslang::TArraySizes* arraySizes;
             glslang::TIdentifierList* identifierList;
         };
+        glslang::TArraySizes* typeParameters;
     } interm;
 }
 
@@ -166,6 +167,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> F64MAT4X2 F64MAT4X3 F64MAT4X4
 %token <lex> ATOMIC_UINT
 %token <lex> ACCSTRUCTNV
+%token <lex> FCOOPMATNV
 
 // combined image/sampler
 %token <lex> SAMPLER1D SAMPLER2D SAMPLER3D SAMPLERCUBE SAMPLER1DSHADOW SAMPLER2DSHADOW
@@ -273,6 +275,10 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %type <interm.type> layout_qualifier layout_qualifier_id_list layout_qualifier_id
 %type <interm.type> non_uniform_qualifier
 
+%type <interm.typeParameters> type_parameter_specifier
+%type <interm.typeParameters> type_parameter_specifier_opt
+%type <interm.typeParameters> type_parameter_specifier_list
+
 %type <interm.type> type_qualifier fully_specified_type type_specifier
 %type <interm.type> single_type_qualifier
 %type <interm.type> type_specifier_nonarray
@@ -1487,15 +1493,17 @@ type_name_list
     ;
 
 type_specifier
-    : type_specifier_nonarray {
+    : type_specifier_nonarray type_parameter_specifier_opt {
         $$ = $1;
         $$.qualifier.precision = parseContext.getDefaultPrecision($$);
+        $$.typeParameters = $2;
     }
-    | type_specifier_nonarray array_specifier {
-        parseContext.arrayOfArrayVersionCheck($2.loc, $2.arraySizes);
+    | type_specifier_nonarray type_parameter_specifier_opt array_specifier {
+        parseContext.arrayOfArrayVersionCheck($3.loc, $3.arraySizes);
         $$ = $1;
         $$.qualifier.precision = parseContext.getDefaultPrecision($$);
-        $$.arraySizes = $2.arraySizes;
+        $$.typeParameters = $2;
+        $$.arraySizes = $3.arraySizes;
     }
     ;
 
@@ -1510,7 +1518,7 @@ array_specifier
         $$.arraySizes = new TArraySizes;
 
         TArraySize size;
-        parseContext.arraySizeCheck($2->getLoc(), $2, size);
+        parseContext.arraySizeCheck($2->getLoc(), $2, size, "array size");
         $$.arraySizes->addInnerSize(size);
     }
     | array_specifier LEFT_BRACKET RIGHT_BRACKET {
@@ -1521,11 +1529,43 @@ array_specifier
         $$ = $1;
 
         TArraySize size;
-        parseContext.arraySizeCheck($3->getLoc(), $3, size);
+        parseContext.arraySizeCheck($3->getLoc(), $3, size, "array size");
         $$.arraySizes->addInnerSize(size);
     }
     ;
 
+type_parameter_specifier_opt
+    : type_parameter_specifier {
+        $$ = $1;
+    }
+    | /* May be null */ {
+        $$ = 0;
+    }
+    ;
+
+type_parameter_specifier
+    : LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE {
+        $$ = $2;
+    }
+    ;
+
+type_parameter_specifier_list
+    : unary_expression {
+        $$ = new TArraySizes;
+
+        TArraySize size;
+        parseContext.arraySizeCheck($1->getLoc(), $1, size, "type parameter");
+        $$->addInnerSize(size);
+    }
+    | type_parameter_specifier_list COMMA unary_expression {
+        $$ = $1;
+
+        TArraySize size;
+        parseContext.arraySizeCheck($3->getLoc(), $3, size, "type parameter");
+        $$->addInnerSize(size);
+    }
+    ;
+
 type_specifier_nonarray
     : VOID {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
@@ -3172,6 +3212,12 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setSubpass(EbtUint, true);
     }
+    | FCOOPMATNV {
+        parseContext.fcoopmatCheck($1.loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtFloat;
+        $$.coopmat = true;
+    }
     | struct_specifier {
         $$ = $1;
         $$.qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;

diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
index 6a2eb40..0ab355f 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp
+++ b/glslang/MachineIndependent/glslang_tab.cpp
@@ -298,235 +298,236 @@ extern int yydebug;
     F64MAT4X4 = 430,
     ATOMIC_UINT = 431,
     ACCSTRUCTNV = 432,
-    SAMPLER1D = 433,
-    SAMPLER2D = 434,
-    SAMPLER3D = 435,
-    SAMPLERCUBE = 436,
-    SAMPLER1DSHADOW = 437,
-    SAMPLER2DSHADOW = 438,
-    SAMPLERCUBESHADOW = 439,
-    SAMPLER1DARRAY = 440,
-    SAMPLER2DARRAY = 441,
-    SAMPLER1DARRAYSHADOW = 442,
-    SAMPLER2DARRAYSHADOW = 443,
-    ISAMPLER1D = 444,
-    ISAMPLER2D = 445,
-    ISAMPLER3D = 446,
-    ISAMPLERCUBE = 447,
-    ISAMPLER1DARRAY = 448,
-    ISAMPLER2DARRAY = 449,
-    USAMPLER1D = 450,
-    USAMPLER2D = 451,
-    USAMPLER3D = 452,
-    USAMPLERCUBE = 453,
-    USAMPLER1DARRAY = 454,
-    USAMPLER2DARRAY = 455,
-    SAMPLER2DRECT = 456,
-    SAMPLER2DRECTSHADOW = 457,
-    ISAMPLER2DRECT = 458,
-    USAMPLER2DRECT = 459,
-    SAMPLERBUFFER = 460,
-    ISAMPLERBUFFER = 461,
-    USAMPLERBUFFER = 462,
-    SAMPLERCUBEARRAY = 463,
-    SAMPLERCUBEARRAYSHADOW = 464,
-    ISAMPLERCUBEARRAY = 465,
-    USAMPLERCUBEARRAY = 466,
-    SAMPLER2DMS = 467,
-    ISAMPLER2DMS = 468,
-    USAMPLER2DMS = 469,
-    SAMPLER2DMSARRAY = 470,
-    ISAMPLER2DMSARRAY = 471,
-    USAMPLER2DMSARRAY = 472,
-    SAMPLEREXTERNALOES = 473,
-    SAMPLEREXTERNAL2DY2YEXT = 474,
-    F16SAMPLER1D = 475,
-    F16SAMPLER2D = 476,
-    F16SAMPLER3D = 477,
-    F16SAMPLER2DRECT = 478,
-    F16SAMPLERCUBE = 479,
-    F16SAMPLER1DARRAY = 480,
-    F16SAMPLER2DARRAY = 481,
-    F16SAMPLERCUBEARRAY = 482,
-    F16SAMPLERBUFFER = 483,
-    F16SAMPLER2DMS = 484,
-    F16SAMPLER2DMSARRAY = 485,
-    F16SAMPLER1DSHADOW = 486,
-    F16SAMPLER2DSHADOW = 487,
-    F16SAMPLER1DARRAYSHADOW = 488,
-    F16SAMPLER2DARRAYSHADOW = 489,
-    F16SAMPLER2DRECTSHADOW = 490,
-    F16SAMPLERCUBESHADOW = 491,
-    F16SAMPLERCUBEARRAYSHADOW = 492,
-    SAMPLER = 493,
-    SAMPLERSHADOW = 494,
-    TEXTURE1D = 495,
-    TEXTURE2D = 496,
-    TEXTURE3D = 497,
-    TEXTURECUBE = 498,
-    TEXTURE1DARRAY = 499,
-    TEXTURE2DARRAY = 500,
-    ITEXTURE1D = 501,
-    ITEXTURE2D = 502,
-    ITEXTURE3D = 503,
-    ITEXTURECUBE = 504,
-    ITEXTURE1DARRAY = 505,
-    ITEXTURE2DARRAY = 506,
-    UTEXTURE1D = 507,
-    UTEXTURE2D = 508,
-    UTEXTURE3D = 509,
-    UTEXTURECUBE = 510,
-    UTEXTURE1DARRAY = 511,
-    UTEXTURE2DARRAY = 512,
-    TEXTURE2DRECT = 513,
-    ITEXTURE2DRECT = 514,
-    UTEXTURE2DRECT = 515,
-    TEXTUREBUFFER = 516,
-    ITEXTUREBUFFER = 517,
-    UTEXTUREBUFFER = 518,
-    TEXTURECUBEARRAY = 519,
-    ITEXTURECUBEARRAY = 520,
-    UTEXTURECUBEARRAY = 521,
-    TEXTURE2DMS = 522,
-    ITEXTURE2DMS = 523,
-    UTEXTURE2DMS = 524,
-    TEXTURE2DMSARRAY = 525,
-    ITEXTURE2DMSARRAY = 526,
-    UTEXTURE2DMSARRAY = 527,
-    F16TEXTURE1D = 528,
-    F16TEXTURE2D = 529,
-    F16TEXTURE3D = 530,
-    F16TEXTURE2DRECT = 531,
-    F16TEXTURECUBE = 532,
-    F16TEXTURE1DARRAY = 533,
-    F16TEXTURE2DARRAY = 534,
-    F16TEXTURECUBEARRAY = 535,
-    F16TEXTUREBUFFER = 536,
-    F16TEXTURE2DMS = 537,
-    F16TEXTURE2DMSARRAY = 538,
-    SUBPASSINPUT = 539,
-    SUBPASSINPUTMS = 540,
-    ISUBPASSINPUT = 541,
-    ISUBPASSINPUTMS = 542,
-    USUBPASSINPUT = 543,
-    USUBPASSINPUTMS = 544,
-    F16SUBPASSINPUT = 545,
-    F16SUBPASSINPUTMS = 546,
-    IMAGE1D = 547,
-    IIMAGE1D = 548,
-    UIMAGE1D = 549,
-    IMAGE2D = 550,
-    IIMAGE2D = 551,
-    UIMAGE2D = 552,
-    IMAGE3D = 553,
-    IIMAGE3D = 554,
-    UIMAGE3D = 555,
-    IMAGE2DRECT = 556,
-    IIMAGE2DRECT = 557,
-    UIMAGE2DRECT = 558,
-    IMAGECUBE = 559,
-    IIMAGECUBE = 560,
-    UIMAGECUBE = 561,
-    IMAGEBUFFER = 562,
-    IIMAGEBUFFER = 563,
-    UIMAGEBUFFER = 564,
-    IMAGE1DARRAY = 565,
-    IIMAGE1DARRAY = 566,
-    UIMAGE1DARRAY = 567,
-    IMAGE2DARRAY = 568,
-    IIMAGE2DARRAY = 569,
-    UIMAGE2DARRAY = 570,
-    IMAGECUBEARRAY = 571,
-    IIMAGECUBEARRAY = 572,
-    UIMAGECUBEARRAY = 573,
-    IMAGE2DMS = 574,
-    IIMAGE2DMS = 575,
-    UIMAGE2DMS = 576,
-    IMAGE2DMSARRAY = 577,
-    IIMAGE2DMSARRAY = 578,
-    UIMAGE2DMSARRAY = 579,
-    F16IMAGE1D = 580,
-    F16IMAGE2D = 581,
-    F16IMAGE3D = 582,
-    F16IMAGE2DRECT = 583,
-    F16IMAGECUBE = 584,
-    F16IMAGE1DARRAY = 585,
-    F16IMAGE2DARRAY = 586,
-    F16IMAGECUBEARRAY = 587,
-    F16IMAGEBUFFER = 588,
-    F16IMAGE2DMS = 589,
-    F16IMAGE2DMSARRAY = 590,
-    STRUCT = 591,
-    VOID = 592,
-    WHILE = 593,
-    IDENTIFIER = 594,
-    TYPE_NAME = 595,
-    FLOATCONSTANT = 596,
-    DOUBLECONSTANT = 597,
-    INT16CONSTANT = 598,
-    UINT16CONSTANT = 599,
-    INT32CONSTANT = 600,
-    UINT32CONSTANT = 601,
-    INTCONSTANT = 602,
-    UINTCONSTANT = 603,
-    INT64CONSTANT = 604,
-    UINT64CONSTANT = 605,
-    BOOLCONSTANT = 606,
-    FLOAT16CONSTANT = 607,
-    LEFT_OP = 608,
-    RIGHT_OP = 609,
-    INC_OP = 610,
-    DEC_OP = 611,
-    LE_OP = 612,
-    GE_OP = 613,
-    EQ_OP = 614,
-    NE_OP = 615,
-    AND_OP = 616,
-    OR_OP = 617,
-    XOR_OP = 618,
-    MUL_ASSIGN = 619,
-    DIV_ASSIGN = 620,
-    ADD_ASSIGN = 621,
-    MOD_ASSIGN = 622,
-    LEFT_ASSIGN = 623,
-    RIGHT_ASSIGN = 624,
-    AND_ASSIGN = 625,
-    XOR_ASSIGN = 626,
-    OR_ASSIGN = 627,
-    SUB_ASSIGN = 628,
-    LEFT_PAREN = 629,
-    RIGHT_PAREN = 630,
-    LEFT_BRACKET = 631,
-    RIGHT_BRACKET = 632,
-    LEFT_BRACE = 633,
-    RIGHT_BRACE = 634,
-    DOT = 635,
-    COMMA = 636,
-    COLON = 637,
-    EQUAL = 638,
-    SEMICOLON = 639,
-    BANG = 640,
-    DASH = 641,
-    TILDE = 642,
-    PLUS = 643,
-    STAR = 644,
-    SLASH = 645,
-    PERCENT = 646,
-    LEFT_ANGLE = 647,
-    RIGHT_ANGLE = 648,
-    VERTICAL_BAR = 649,
-    CARET = 650,
-    AMPERSAND = 651,
-    QUESTION = 652,
-    INVARIANT = 653,
-    PRECISE = 654,
-    HIGH_PRECISION = 655,
-    MEDIUM_PRECISION = 656,
-    LOW_PRECISION = 657,
-    PRECISION = 658,
-    PACKED = 659,
-    RESOURCE = 660,
-    SUPERP = 661
+    FCOOPMATNV = 433,
+    SAMPLER1D = 434,
+    SAMPLER2D = 435,
+    SAMPLER3D = 436,
+    SAMPLERCUBE = 437,
+    SAMPLER1DSHADOW = 438,
+    SAMPLER2DSHADOW = 439,
+    SAMPLERCUBESHADOW = 440,
+    SAMPLER1DARRAY = 441,
+    SAMPLER2DARRAY = 442,
+    SAMPLER1DARRAYSHADOW = 443,
+    SAMPLER2DARRAYSHADOW = 444,
+    ISAMPLER1D = 445,
+    ISAMPLER2D = 446,
+    ISAMPLER3D = 447,
+    ISAMPLERCUBE = 448,
+    ISAMPLER1DARRAY = 449,
+    ISAMPLER2DARRAY = 450,
+    USAMPLER1D = 451,
+    USAMPLER2D = 452,
+    USAMPLER3D = 453,
+    USAMPLERCUBE = 454,
+    USAMPLER1DARRAY = 455,
+    USAMPLER2DARRAY = 456,
+    SAMPLER2DRECT = 457,
+    SAMPLER2DRECTSHADOW = 458,
+    ISAMPLER2DRECT = 459,
+    USAMPLER2DRECT = 460,
+    SAMPLERBUFFER = 461,
+    ISAMPLERBUFFER = 462,
+    USAMPLERBUFFER = 463,
+    SAMPLERCUBEARRAY = 464,
+    SAMPLERCUBEARRAYSHADOW = 465,
+    ISAMPLERCUBEARRAY = 466,
+    USAMPLERCUBEARRAY = 467,
+    SAMPLER2DMS = 468,
+    ISAMPLER2DMS = 469,
+    USAMPLER2DMS = 470,
+    SAMPLER2DMSARRAY = 471,
+    ISAMPLER2DMSARRAY = 472,
+    USAMPLER2DMSARRAY = 473,
+    SAMPLEREXTERNALOES = 474,
+    SAMPLEREXTERNAL2DY2YEXT = 475,
+    F16SAMPLER1D = 476,
+    F16SAMPLER2D = 477,
+    F16SAMPLER3D = 478,
+    F16SAMPLER2DRECT = 479,
+    F16SAMPLERCUBE = 480,
+    F16SAMPLER1DARRAY = 481,
+    F16SAMPLER2DARRAY = 482,
+    F16SAMPLERCUBEARRAY = 483,
+    F16SAMPLERBUFFER = 484,
+    F16SAMPLER2DMS = 485,
+    F16SAMPLER2DMSARRAY = 486,
+    F16SAMPLER1DSHADOW = 487,
+    F16SAMPLER2DSHADOW = 488,
+    F16SAMPLER1DARRAYSHADOW = 489,
+    F16SAMPLER2DARRAYSHADOW = 490,
+    F16SAMPLER2DRECTSHADOW = 491,
+    F16SAMPLERCUBESHADOW = 492,
+    F16SAMPLERCUBEARRAYSHADOW = 493,
+    SAMPLER = 494,
+    SAMPLERSHADOW = 495,
+    TEXTURE1D = 496,
+    TEXTURE2D = 497,
+    TEXTURE3D = 498,
+    TEXTURECUBE = 499,
+    TEXTURE1DARRAY = 500,
+    TEXTURE2DARRAY = 501,
+    ITEXTURE1D = 502,
+    ITEXTURE2D = 503,
+    ITEXTURE3D = 504,
+    ITEXTURECUBE = 505,
+    ITEXTURE1DARRAY = 506,
+    ITEXTURE2DARRAY = 507,
+    UTEXTURE1D = 508,
+    UTEXTURE2D = 509,
+    UTEXTURE3D = 510,
+    UTEXTURECUBE = 511,
+    UTEXTURE1DARRAY = 512,
+    UTEXTURE2DARRAY = 513,
+    TEXTURE2DRECT = 514,
+    ITEXTURE2DRECT = 515,
+    UTEXTURE2DRECT = 516,
+    TEXTUREBUFFER = 517,
+    ITEXTUREBUFFER = 518,
+    UTEXTUREBUFFER = 519,
+    TEXTURECUBEARRAY = 520,
+    ITEXTURECUBEARRAY = 521,
+    UTEXTURECUBEARRAY = 522,
+    TEXTURE2DMS = 523,
+    ITEXTURE2DMS = 524,
+    UTEXTURE2DMS = 525,
+    TEXTURE2DMSARRAY = 526,
+    ITEXTURE2DMSARRAY = 527,
+    UTEXTURE2DMSARRAY = 528,
+    F16TEXTURE1D = 529,
+    F16TEXTURE2D = 530,
+    F16TEXTURE3D = 531,
+    F16TEXTURE2DRECT = 532,
+    F16TEXTURECUBE = 533,
+    F16TEXTURE1DARRAY = 534,
+    F16TEXTURE2DARRAY = 535,
+    F16TEXTURECUBEARRAY = 536,
+    F16TEXTUREBUFFER = 537,
+    F16TEXTURE2DMS = 538,
+    F16TEXTURE2DMSARRAY = 539,
+    SUBPASSINPUT = 540,
+    SUBPASSINPUTMS = 541,
+    ISUBPASSINPUT = 542,
+    ISUBPASSINPUTMS = 543,
+    USUBPASSINPUT = 544,
+    USUBPASSINPUTMS = 545,
+    F16SUBPASSINPUT = 546,
+    F16SUBPASSINPUTMS = 547,
+    IMAGE1D = 548,
+    IIMAGE1D = 549,
+    UIMAGE1D = 550,
+    IMAGE2D = 551,
+    IIMAGE2D = 552,
+    UIMAGE2D = 553,
+    IMAGE3D = 554,
+    IIMAGE3D = 555,
+    UIMAGE3D = 556,
+    IMAGE2DRECT = 557,
+    IIMAGE2DRECT = 558,
+    UIMAGE2DRECT = 559,
+    IMAGECUBE = 560,
+    IIMAGECUBE = 561,
+    UIMAGECUBE = 562,
+    IMAGEBUFFER = 563,
+    IIMAGEBUFFER = 564,
+    UIMAGEBUFFER = 565,
+    IMAGE1DARRAY = 566,
+    IIMAGE1DARRAY = 567,
+    UIMAGE1DARRAY = 568,
+    IMAGE2DARRAY = 569,
+    IIMAGE2DARRAY = 570,
+    UIMAGE2DARRAY = 571,
+    IMAGECUBEARRAY = 572,
+    IIMAGECUBEARRAY = 573,
+    UIMAGECUBEARRAY = 574,
+    IMAGE2DMS = 575,
+    IIMAGE2DMS = 576,
+    UIMAGE2DMS = 577,
+    IMAGE2DMSARRAY = 578,
+    IIMAGE2DMSARRAY = 579,
+    UIMAGE2DMSARRAY = 580,
+    F16IMAGE1D = 581,
+    F16IMAGE2D = 582,
+    F16IMAGE3D = 583,
+    F16IMAGE2DRECT = 584,
+    F16IMAGECUBE = 585,
+    F16IMAGE1DARRAY = 586,
+    F16IMAGE2DARRAY = 587,
+    F16IMAGECUBEARRAY = 588,
+    F16IMAGEBUFFER = 589,
+    F16IMAGE2DMS = 590,
+    F16IMAGE2DMSARRAY = 591,
+    STRUCT = 592,
+    VOID = 593,
+    WHILE = 594,
+    IDENTIFIER = 595,
+    TYPE_NAME = 596,
+    FLOATCONSTANT = 597,
+    DOUBLECONSTANT = 598,
+    INT16CONSTANT = 599,
+    UINT16CONSTANT = 600,
+    INT32CONSTANT = 601,
+    UINT32CONSTANT = 602,
+    INTCONSTANT = 603,
+    UINTCONSTANT = 604,
+    INT64CONSTANT = 605,
+    UINT64CONSTANT = 606,
+    BOOLCONSTANT = 607,
+    FLOAT16CONSTANT = 608,
+    LEFT_OP = 609,
+    RIGHT_OP = 610,
+    INC_OP = 611,
+    DEC_OP = 612,
+    LE_OP = 613,
+    GE_OP = 614,
+    EQ_OP = 615,
+    NE_OP = 616,
+    AND_OP = 617,
+    OR_OP = 618,
+    XOR_OP = 619,
+    MUL_ASSIGN = 620,
+    DIV_ASSIGN = 621,
+    ADD_ASSIGN = 622,
+    MOD_ASSIGN = 623,
+    LEFT_ASSIGN = 624,
+    RIGHT_ASSIGN = 625,
+    AND_ASSIGN = 626,
+    XOR_ASSIGN = 627,
+    OR_ASSIGN = 628,
+    SUB_ASSIGN = 629,
+    LEFT_PAREN = 630,
+    RIGHT_PAREN = 631,
+    LEFT_BRACKET = 632,
+    RIGHT_BRACKET = 633,
+    LEFT_BRACE = 634,
+    RIGHT_BRACE = 635,
+    DOT = 636,
+    COMMA = 637,
+    COLON = 638,
+    EQUAL = 639,
+    SEMICOLON = 640,
+    BANG = 641,
+    DASH = 642,
+    TILDE = 643,
+    PLUS = 644,
+    STAR = 645,
+    SLASH = 646,
+    PERCENT = 647,
+    LEFT_ANGLE = 648,
+    RIGHT_ANGLE = 649,
+    VERTICAL_BAR = 650,
+    CARET = 651,
+    AMPERSAND = 652,
+    QUESTION = 653,
+    INVARIANT = 654,
+    PRECISE = 655,
+    HIGH_PRECISION = 656,
+    MEDIUM_PRECISION = 657,
+    LOW_PRECISION = 658,
+    PRECISION = 659,
+    PACKED = 660,
+    RESOURCE = 661,
+    SUPERP = 662
   };
 #endif
 
@@ -568,9 +569,10 @@ union YYSTYPE
             glslang::TArraySizes* arraySizes;
             glslang::TIdentifierList* identifierList;
         };
+        glslang::TArraySizes* typeParameters;
     } interm;
 
-#line 574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
+#line 576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
 };
 
 typedef union YYSTYPE YYSTYPE;
@@ -585,7 +587,7 @@ int yyparse (glslang::TParseContext* pParseContext);
 #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
 
 /* Copy the second part of user declarations.  */
-#line 106 "MachineIndependent/glslang.y" /* yacc.c:358  */
+#line 107 "MachineIndependent/glslang.y" /* yacc.c:358  */
 
 
 /* windows only pragma */
@@ -601,7 +603,7 @@ int yyparse (glslang::TParseContext* pParseContext);
 extern int yylex(YYSTYPE*, TParseContext&);
 
 
-#line 605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
+#line 607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -841,23 +843,23 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  382
+#define YYFINAL  384
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   9317
+#define YYLAST   9348
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  407
+#define YYNTOKENS  408
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  107
+#define YYNNTS  110
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  572
+#define YYNRULES  578
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  713
+#define YYNSTATES  722
 
 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
    by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   661
+#define YYMAXUTOK   662
 
 #define YYTRANSLATE(YYX)                                                \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -932,71 +934,71 @@ static const yytype_uint16 yytranslate[] =
      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406
+     405,   406,   407
 };
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   296,   296,   302,   305,   309,   313,   316,   320,   324,
-     328,   332,   336,   339,   343,   347,   350,   358,   361,   364,
-     367,   370,   375,   383,   390,   397,   403,   407,   414,   417,
-     423,   430,   440,   448,   453,   480,   488,   494,   498,   502,
-     522,   523,   524,   525,   531,   532,   537,   542,   551,   552,
-     557,   565,   566,   572,   581,   582,   587,   592,   597,   605,
-     606,   614,   625,   626,   635,   636,   645,   646,   655,   656,
-     664,   665,   673,   674,   682,   683,   683,   701,   702,   718,
-     722,   726,   730,   735,   739,   743,   747,   751,   755,   759,
-     766,   769,   780,   787,   792,   797,   805,   809,   813,   817,
-     822,   827,   836,   836,   847,   851,   858,   865,   868,   875,
-     883,   903,   926,   941,   966,   977,   987,   997,  1007,  1016,
-    1019,  1023,  1027,  1032,  1040,  1045,  1050,  1055,  1060,  1069,
-    1080,  1107,  1116,  1123,  1130,  1141,  1150,  1160,  1172,  1181,
-    1193,  1199,  1202,  1209,  1213,  1217,  1225,  1234,  1237,  1248,
-    1251,  1254,  1258,  1262,  1266,  1270,  1276,  1280,  1292,  1306,
-    1311,  1317,  1323,  1330,  1336,  1341,  1346,  1351,  1361,  1371,
-    1381,  1391,  1400,  1412,  1416,  1421,  1426,  1431,  1436,  1441,
-    1445,  1449,  1453,  1457,  1463,  1472,  1479,  1482,  1490,  1494,
-    1503,  1508,  1516,  1520,  1530,  1534,  1538,  1543,  1548,  1553,
-    1558,  1562,  1567,  1572,  1577,  1582,  1587,  1592,  1597,  1602,
-    1607,  1611,  1616,  1621,  1626,  1632,  1638,  1644,  1650,  1656,
-    1662,  1668,  1674,  1680,  1686,  1692,  1698,  1703,  1708,  1713,
-    1718,  1723,  1728,  1734,  1740,  1746,  1752,  1758,  1764,  1770,
-    1776,  1782,  1788,  1794,  1800,  1806,  1812,  1818,  1824,  1830,
-    1836,  1842,  1848,  1854,  1860,  1866,  1872,  1878,  1884,  1890,
-    1895,  1900,  1905,  1910,  1915,  1920,  1925,  1930,  1935,  1940,
-    1945,  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,  2130,  2136,  2142,  2148,  2154,  2160,  2166,  2172,  2178,
-    2184,  2190,  2196,  2202,  2208,  2214,  2220,  2226,  2232,  2238,
-    2244,  2249,  2254,  2259,  2264,  2269,  2274,  2279,  2284,  2289,
-    2294,  2299,  2304,  2309,  2314,  2322,  2330,  2338,  2346,  2354,
-    2362,  2370,  2378,  2386,  2394,  2402,  2410,  2418,  2423,  2428,
-    2433,  2438,  2443,  2448,  2453,  2458,  2463,  2468,  2473,  2478,
-    2483,  2488,  2493,  2498,  2506,  2514,  2519,  2524,  2529,  2537,
-    2542,  2547,  2552,  2560,  2565,  2570,  2575,  2583,  2588,  2593,
-    2598,  2603,  2608,  2616,  2621,  2629,  2634,  2642,  2647,  2655,
-    2660,  2668,  2673,  2681,  2686,  2694,  2699,  2704,  2709,  2714,
-    2719,  2724,  2729,  2734,  2739,  2744,  2749,  2754,  2759,  2764,
-    2769,  2777,  2782,  2787,  2792,  2800,  2805,  2810,  2815,  2823,
-    2828,  2833,  2838,  2846,  2851,  2856,  2861,  2869,  2874,  2879,
-    2884,  2892,  2897,  2902,  2907,  2915,  2920,  2925,  2930,  2938,
-    2943,  2948,  2953,  2961,  2966,  2971,  2976,  2984,  2989,  2994,
-    2999,  3007,  3012,  3017,  3022,  3030,  3035,  3040,  3045,  3053,
-    3058,  3063,  3068,  3076,  3081,  3086,  3091,  3099,  3104,  3109,
-    3115,  3121,  3127,  3133,  3142,  3151,  3157,  3163,  3169,  3175,
-    3180,  3196,  3201,  3206,  3214,  3214,  3225,  3225,  3235,  3238,
-    3251,  3273,  3300,  3304,  3310,  3315,  3326,  3329,  3335,  3344,
-    3347,  3353,  3357,  3358,  3364,  3365,  3366,  3367,  3368,  3369,
-    3370,  3374,  3375,  3379,  3375,  3391,  3392,  3396,  3396,  3403,
-    3403,  3417,  3420,  3428,  3436,  3447,  3448,  3452,  3455,  3461,
-    3468,  3472,  3480,  3484,  3497,  3500,  3506,  3506,  3526,  3529,
-    3535,  3547,  3559,  3562,  3568,  3568,  3583,  3583,  3599,  3599,
-    3620,  3623,  3629,  3632,  3638,  3642,  3649,  3654,  3659,  3666,
-    3669,  3678,  3682,  3691,  3694,  3697,  3705,  3705,  3727,  3733,
-    3736,  3741,  3744
+       0,   302,   302,   308,   311,   315,   319,   322,   326,   330,
+     334,   338,   342,   345,   349,   353,   356,   364,   367,   370,
+     373,   376,   381,   389,   396,   403,   409,   413,   420,   423,
+     429,   436,   446,   454,   459,   486,   494,   500,   504,   508,
+     528,   529,   530,   531,   537,   538,   543,   548,   557,   558,
+     563,   571,   572,   578,   587,   588,   593,   598,   603,   611,
+     612,   620,   631,   632,   641,   642,   651,   652,   661,   662,
+     670,   671,   679,   680,   688,   689,   689,   707,   708,   724,
+     728,   732,   736,   741,   745,   749,   753,   757,   761,   765,
+     772,   775,   786,   793,   798,   803,   811,   815,   819,   823,
+     828,   833,   842,   842,   853,   857,   864,   871,   874,   881,
+     889,   909,   932,   947,   972,   983,   993,  1003,  1013,  1022,
+    1025,  1029,  1033,  1038,  1046,  1051,  1056,  1061,  1066,  1075,
+    1086,  1113,  1122,  1129,  1136,  1147,  1156,  1166,  1178,  1187,
+    1199,  1205,  1208,  1215,  1219,  1223,  1231,  1240,  1243,  1254,
+    1257,  1260,  1264,  1268,  1272,  1276,  1282,  1286,  1298,  1312,
+    1317,  1323,  1329,  1336,  1342,  1347,  1352,  1357,  1367,  1377,
+    1387,  1397,  1406,  1418,  1422,  1427,  1432,  1437,  1442,  1447,
+    1451,  1455,  1459,  1463,  1469,  1478,  1485,  1488,  1496,  1501,
+    1511,  1516,  1524,  1528,  1538,  1541,  1547,  1553,  1560,  1570,
+    1574,  1578,  1583,  1588,  1593,  1598,  1602,  1607,  1612,  1617,
+    1622,  1627,  1632,  1637,  1642,  1647,  1651,  1656,  1661,  1666,
+    1672,  1678,  1684,  1690,  1696,  1702,  1708,  1714,  1720,  1726,
+    1732,  1738,  1743,  1748,  1753,  1758,  1763,  1768,  1774,  1780,
+    1786,  1792,  1798,  1804,  1810,  1816,  1822,  1828,  1834,  1840,
+    1846,  1852,  1858,  1864,  1870,  1876,  1882,  1888,  1894,  1900,
+    1906,  1912,  1918,  1924,  1930,  1935,  1940,  1945,  1950,  1955,
+    1960,  1965,  1970,  1975,  1980,  1985,  1990,  1996,  2002,  2008,
+    2014,  2020,  2026,  2032,  2038,  2044,  2050,  2056,  2062,  2068,
+    2074,  2080,  2086,  2092,  2098,  2104,  2110,  2116,  2122,  2128,
+    2134,  2140,  2146,  2152,  2158,  2164,  2170,  2176,  2182,  2188,
+    2194,  2200,  2206,  2212,  2218,  2224,  2230,  2236,  2242,  2248,
+    2254,  2260,  2266,  2272,  2278,  2284,  2289,  2294,  2299,  2304,
+    2309,  2314,  2319,  2324,  2329,  2334,  2339,  2344,  2349,  2354,
+    2362,  2370,  2378,  2386,  2394,  2402,  2410,  2418,  2426,  2434,
+    2442,  2450,  2458,  2463,  2468,  2473,  2478,  2483,  2488,  2493,
+    2498,  2503,  2508,  2513,  2518,  2523,  2528,  2533,  2538,  2546,
+    2554,  2559,  2564,  2569,  2577,  2582,  2587,  2592,  2600,  2605,
+    2610,  2615,  2623,  2628,  2633,  2638,  2643,  2648,  2656,  2661,
+    2669,  2674,  2682,  2687,  2695,  2700,  2708,  2713,  2721,  2726,
+    2734,  2739,  2744,  2749,  2754,  2759,  2764,  2769,  2774,  2779,
+    2784,  2789,  2794,  2799,  2804,  2809,  2817,  2822,  2827,  2832,
+    2840,  2845,  2850,  2855,  2863,  2868,  2873,  2878,  2886,  2891,
+    2896,  2901,  2909,  2914,  2919,  2924,  2932,  2937,  2942,  2947,
+    2955,  2960,  2965,  2970,  2978,  2983,  2988,  2993,  3001,  3006,
+    3011,  3016,  3024,  3029,  3034,  3039,  3047,  3052,  3057,  3062,
+    3070,  3075,  3080,  3085,  3093,  3098,  3103,  3108,  3116,  3121,
+    3126,  3131,  3139,  3144,  3149,  3155,  3161,  3167,  3173,  3182,
+    3191,  3197,  3203,  3209,  3215,  3221,  3226,  3242,  3247,  3252,
+    3260,  3260,  3271,  3271,  3281,  3284,  3297,  3319,  3346,  3350,
+    3356,  3361,  3372,  3375,  3381,  3390,  3393,  3399,  3403,  3404,
+    3410,  3411,  3412,  3413,  3414,  3415,  3416,  3420,  3421,  3425,
+    3421,  3437,  3438,  3442,  3442,  3449,  3449,  3463,  3466,  3474,
+    3482,  3493,  3494,  3498,  3501,  3507,  3514,  3518,  3526,  3530,
+    3543,  3546,  3552,  3552,  3572,  3575,  3581,  3593,  3605,  3608,
+    3614,  3614,  3629,  3629,  3645,  3645,  3666,  3669,  3675,  3678,
+    3684,  3688,  3695,  3700,  3705,  3712,  3715,  3724,  3728,  3737,
+    3740,  3743,  3751,  3751,  3773,  3779,  3782,  3787,  3790
 };
 #endif
 
@@ -1035,48 +1037,49 @@ static const char *const yytname[] =
   "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2",
   "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4",
   "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV",
-  "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW",
-  "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER1DARRAY",
-  "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", "SAMPLER2DARRAYSHADOW",
-  "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE",
-  "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", "USAMPLER2D",
-  "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", "USAMPLER2DARRAY",
-  "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT",
-  "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER",
-  "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY",
-  "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS",
-  "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY",
-  "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "F16SAMPLER1D",
-  "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
-  "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY",
-  "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY",
-  "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
-  "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW",
-  "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER",
-  "SAMPLERSHADOW", "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE",
-  "TEXTURE1DARRAY", "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D",
-  "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY",
-  "UTEXTURE1D", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE",
-  "UTEXTURE1DARRAY", "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT",
-  "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER",
-  "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY",
-  "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS", "TEXTURE2DMSARRAY",
-  "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D",
-  "F16TEXTURE3D", "F16TEXTURE2DRECT", "F16TEXTURECUBE",
-  "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY",
-  "F16TEXTUREBUFFER", "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY",
-  "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS",
-  "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT",
-  "F16SUBPASSINPUTMS", "IMAGE1D", "IIMAGE1D", "UIMAGE1D", "IMAGE2D",
-  "IIMAGE2D", "UIMAGE2D", "IMAGE3D", "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT",
-  "IIMAGE2DRECT", "UIMAGE2DRECT", "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE",
-  "IMAGEBUFFER", "IIMAGEBUFFER", "UIMAGEBUFFER", "IMAGE1DARRAY",
-  "IIMAGE1DARRAY", "UIMAGE1DARRAY", "IMAGE2DARRAY", "IIMAGE2DARRAY",
-  "UIMAGE2DARRAY", "IMAGECUBEARRAY", "IIMAGECUBEARRAY", "UIMAGECUBEARRAY",
-  "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS", "IMAGE2DMSARRAY",
-  "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "F16IMAGE1D", "F16IMAGE2D",
-  "F16IMAGE3D", "F16IMAGE2DRECT", "F16IMAGECUBE", "F16IMAGE1DARRAY",
-  "F16IMAGE2DARRAY", "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS",
+  "FCOOPMATNV", "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE",
+  "SAMPLER1DSHADOW", "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW",
+  "SAMPLER1DARRAY", "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW",
+  "SAMPLER2DARRAYSHADOW", "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D",
+  "ISAMPLERCUBE", "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D",
+  "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY",
+  "USAMPLER2DARRAY", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW",
+  "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER",
+  "USAMPLERBUFFER", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW",
+  "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS",
+  "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY",
+  "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT",
+  "F16SAMPLER1D", "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT",
+  "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY",
+  "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", "F16SAMPLER2DMS",
+  "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW",
+  "F16SAMPLER1DARRAYSHADOW", "F16SAMPLER2DARRAYSHADOW",
+  "F16SAMPLER2DRECTSHADOW", "F16SAMPLERCUBESHADOW",
+  "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER", "SAMPLERSHADOW", "TEXTURE1D",
+  "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE1DARRAY",
+  "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", "ITEXTURE3D",
+  "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", "UTEXTURE1D",
+  "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", "UTEXTURE1DARRAY",
+  "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT", "UTEXTURE2DRECT",
+  "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER", "TEXTURECUBEARRAY",
+  "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY", "TEXTURE2DMS", "ITEXTURE2DMS",
+  "UTEXTURE2DMS", "TEXTURE2DMSARRAY", "ITEXTURE2DMSARRAY",
+  "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D", "F16TEXTURE3D",
+  "F16TEXTURE2DRECT", "F16TEXTURECUBE", "F16TEXTURE1DARRAY",
+  "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY", "F16TEXTUREBUFFER",
+  "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY", "SUBPASSINPUT",
+  "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS", "USUBPASSINPUT",
+  "USUBPASSINPUTMS", "F16SUBPASSINPUT", "F16SUBPASSINPUTMS", "IMAGE1D",
+  "IIMAGE1D", "UIMAGE1D", "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D",
+  "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", "IIMAGE2DRECT", "UIMAGE2DRECT",
+  "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", "IMAGEBUFFER", "IIMAGEBUFFER",
+  "UIMAGEBUFFER", "IMAGE1DARRAY", "IIMAGE1DARRAY", "UIMAGE1DARRAY",
+  "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBEARRAY",
+  "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS",
+  "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY",
+  "F16IMAGE1D", "F16IMAGE2D", "F16IMAGE3D", "F16IMAGE2DRECT",
+  "F16IMAGECUBE", "F16IMAGE1DARRAY", "F16IMAGE2DARRAY",
+  "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS",
   "F16IMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER",
   "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", "INT16CONSTANT",
   "UINT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INTCONSTANT",
@@ -1111,9 +1114,10 @@ static const char *const yytname[] =
   "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id",
   "precise_qualifier", "type_qualifier", "single_type_qualifier",
   "storage_qualifier", "non_uniform_qualifier", "type_name_list",
-  "type_specifier", "array_specifier", "type_specifier_nonarray",
-  "precision_qualifier", "struct_specifier", "$@3", "$@4",
-  "struct_declaration_list", "struct_declaration",
+  "type_specifier", "array_specifier", "type_parameter_specifier_opt",
+  "type_parameter_specifier", "type_parameter_specifier_list",
+  "type_specifier_nonarray", "precision_qualifier", "struct_specifier",
+  "$@3", "$@4", "struct_declaration_list", "struct_declaration",
   "struct_declarator_list", "struct_declarator", "initializer",
   "initializer_list", "declaration_statement", "statement",
   "simple_statement", "compound_statement", "$@5", "$@6",
@@ -1176,16 +1180,16 @@ static const yytype_uint16 yytoknum[] =
      625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
      635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
      645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
-     655,   656,   657,   658,   659,   660,   661
+     655,   656,   657,   658,   659,   660,   661,   662
 };
 # endif
 
-#define YYPACT_NINF -657
+#define YYPACT_NINF -659
 
 #define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-657)))
+  (!!((Yystate) == (-659)))
 
-#define YYTABLE_NINF -518
+#define YYTABLE_NINF -524
 
 #define yytable_value_is_error(Yytable_value) \
   0
@@ -1194,78 +1198,79 @@ static const yytype_uint16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    3519,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -338,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -331,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -657,  -318,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -258,  -657,  -319,  -344,  -303,  -257,  5920,  -281,
-    -657,  -286,  -657,  -657,  -657,  -657,  4320,  -657,  -657,  -657,
-    -657,  -227,  -657,  -657,   712,  -657,  -657,  -224,   -68,  -246,
-    -657,  8977,  -339,  -657,  -657,  -220,  -657,  5920,  -657,  -657,
-    -657,  5920,  -201,  -175,  -657,  -341,  -315,  -657,  -657,  -657,
-    6673,  -206,  -657,  -657,  -657,  -308,  -657,  -214,  -307,  -657,
-    -657,  5920,  -213,  -657,  -337,  1113,  -657,  -657,  -657,  -657,
-    -227,  -322,  -657,  7057,  -321,  -657,  -167,  -657,  -261,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  8209,  8209,  8209,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -328,  -657,  -657,  -657,  -202,  -285,  8593,  -200,
-    -657,  8209,  -244,  -238,  -266,  -334,  -207,  -219,  -217,  -218,
-    -186,  -183,  -340,  -196,  -657,  -657,  7441,  -657,  -157,  8209,
-    -657,   -68,  5920,  5920,  -156,  4720,  -657,  -657,  -657,  -199,
-    -195,  -657,  -190,  -184,  -192,  7825,  -181,  8209,  -194,  -180,
-    -179,  -178,  -657,  -657,  -288,  -657,  -657,  -259,  -657,  -344,
-    -174,  -172,  -657,  -657,  -657,  -657,  1514,  -657,  -657,  -657,
-    -657,  -657,  -657,  -657,  -657,  -657,   -19,  -206,  7057,  -312,
-    7057,  -657,  -657,  7057,  5920,  -657,  -144,  -657,  -657,  -657,
-    -284,  -657,  -657,  8209,  -143,  -657,  -657,  8209,  -171,  -657,
-    -657,  -657,  8209,  8209,  8209,  8209,  8209,  8209,  8209,  8209,
-    8209,  8209,  8209,  8209,  8209,  8209,  8209,  8209,  8209,  8209,
-    8209,  -657,  -657,  -657,  -169,  -657,  -657,  -657,  -657,  5120,
-    -156,  -227,  -255,  -657,  -657,  -657,  -657,  -657,  1915,  -657,
-    8209,  -657,  -657,  -253,  8209,  -225,  -657,  -657,  -136,  -657,
-    1915,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  8209,  8209,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  7057,  -657,  -240,  -657,  5520,  -657,  -657,  -168,  -166,
-    -657,  -657,  -657,  -657,  -657,  -244,  -244,  -238,  -238,  -266,
-    -266,  -266,  -266,  -334,  -334,  -207,  -219,  -217,  -218,  -186,
-    -183,  8209,  -657,  -657,  -247,  -206,  -156,  -657,  -132,  3118,
-    -282,  -657,  -277,  -657,  3920,  -164,  -276,  -657,  1915,  -657,
-    -657,  -657,  -657,  6289,  -657,  -657,  -221,  -657,  -657,  -162,
-    -657,  -657,  3920,  -165,  -657,  -166,  -125,  5920,  -159,  8209,
-    -160,  -136,  -161,  -657,  -657,  8209,  8209,  -657,  -163,  -155,
-     194,  -153,  2717,  -657,  -152,  -134,  2316,  -128,  -657,  -657,
-    -657,  -657,  -273,  8209,  2316,  -165,  -657,  -657,  1915,  7057,
-    -657,  -657,  -657,  -657,  -133,  -166,  -657,  -657,  1915,  -129,
-    -657,  -657,  -657
+    3535,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -331,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -324,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -319,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -256,  -659,  -314,  -351,  -309,  -306,  5942,
+    -257,  -659,  -217,  -659,  -659,  -659,  -659,  4338,  -659,  -659,
+    -659,  -659,  -241,  -659,  -659,   721,  -659,  -659,  -204,   -71,
+    -219,  -659,  9007,  -349,  -659,  -659,  -215,  -659,  5942,  -659,
+    -659,  -659,  5942,  -178,  -172,  -659,  -337,  -267,  -659,  -659,
+    -659,  8237,  -207,  -659,  -659,  -659,  -659,  -341,  -659,  -211,
+    -330,  -659,  -659,  5942,  -210,  6697,  -659,  -322,  1123,  -659,
+    -659,  -659,  -659,  -207,  -328,  -659,  7082,  -304,  -659,  -163,
+    -659,  -252,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,  -659,  8237,  8237,  8237,  -659,  -659,
+    -659,  -659,  -659,  -659,  -303,  -659,  -659,  -659,  -196,  -299,
+    8622,  -194,  -659,  8237,  -659,  -659,  -355,  -195,  -659,  -157,
+    8237,  -659,   -71,  5942,  5942,  -155,  4739,  -659,  -659,  -659,
+    -659,  -242,  -236,  -249,  -335,  -206,  -191,  -187,  -209,  -149,
+    -150,  -333,  -162,  7467,  -659,  -170,  -168,  -659,  -154,  -153,
+    -167,  7852,  -152,  8237,  -159,  -148,  -151,  -160,  -659,  -659,
+    -274,  -659,  -659,  -251,  -659,  -351,  -147,  -144,  -659,  -659,
+    -659,  -659,  1525,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,   -19,  -195,  7082,  -302,  7082,  -659,  -659,  7082,
+    5942,  -659,  -115,  -659,  -659,  -659,  -292,  -659,  -659,  8237,
+    -108,  -659,  -659,  8237,  -143,  -659,  -659,  -659,  8237,  -659,
+    -659,  -659,  -659,  -659,  5140,  -155,  -207,  -250,  -659,  -659,
+    -659,  8237,  8237,  8237,  8237,  8237,  8237,  8237,  8237,  8237,
+    8237,  8237,  8237,  8237,  8237,  8237,  8237,  8237,  8237,  8237,
+    -659,  -659,  -659,  -142,  -659,  -659,  1927,  -659,  8237,  -659,
+    -659,  -245,  8237,  -226,  -659,  -659,  -106,  -659,  1927,  -659,
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    8237,  8237,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  7082,
+    -659,  -238,  -659,  5541,  -659,  -659,  -141,  -140,  -659,  -659,
+    -659,  -659,  -244,  -195,  -155,  -659,  -659,  -659,  -659,  -242,
+    -242,  -236,  -236,  -249,  -249,  -249,  -249,  -335,  -335,  -206,
+    -191,  -187,  -209,  -149,  -150,  8237,  -659,  -104,  3133,  -263,
+    -659,  -260,  -659,  3937,  -136,  -297,  -659,  1927,  -659,  -659,
+    -659,  -659,  6312,  -659,  -659,  -659,  -659,  -224,  -135,  -659,
+    -659,  3937,  -138,  -659,  -140,   -97,  5942,  -132,  8237,  -133,
+    -106,  -134,  -659,  -659,  8237,  8237,  -659,  -137,  -129,   224,
+    -128,  2731,  -659,  -127,  -131,  2329,  -126,  -659,  -659,  -659,
+    -659,  -255,  8237,  2329,  -138,  -659,  -659,  1927,  7082,  -659,
+    -659,  -659,  -659,  -130,  -140,  -659,  -659,  1927,  -123,  -659,
+    -659,  -659
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1273,110 +1278,111 @@ static const yytype_int16 yypact[] =
      means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-       0,   157,   158,   197,   195,   198,   196,   199,   156,   210,
-     200,   201,   208,   209,   206,   207,   204,   205,   202,   203,
-     183,   226,   227,   228,   229,   230,   231,   244,   245,   246,
-     241,   242,   243,   256,   257,   258,   238,   239,   240,   253,
-     254,   255,   235,   236,   237,   250,   251,   252,   232,   233,
-     234,   247,   248,   249,   211,   212,   213,   259,   260,   261,
+       0,   157,   158,   202,   200,   203,   201,   204,   156,   215,
+     205,   206,   213,   214,   211,   212,   209,   210,   207,   208,
+     183,   231,   232,   233,   234,   235,   236,   249,   250,   251,
+     246,   247,   248,   261,   262,   263,   243,   244,   245,   258,
+     259,   260,   240,   241,   242,   255,   256,   257,   237,   238,
+     239,   252,   253,   254,   216,   217,   218,   264,   265,   266,
      162,   160,   161,   159,   165,   163,   164,   166,   172,   185,
      168,   169,   167,   170,   171,   173,   179,   180,   181,   182,
-     174,   175,   176,   177,   178,   214,   215,   216,   271,   272,
-     273,   217,   218,   219,   283,   284,   285,   220,   221,   222,
-     295,   296,   297,   223,   224,   225,   307,   308,   309,   134,
-     133,   132,     0,   135,   136,   137,   138,   139,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   286,   287,   288,   289,
-     290,   291,   292,   293,   294,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   320,   319,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,   347,   348,   349,   350,
-     351,   352,   354,   355,   356,   357,   358,   359,   361,   362,
-     365,   366,   367,   369,   370,   332,   333,   353,   360,   371,
-     373,   374,   375,   377,   378,   469,   470,   334,   335,   336,
-     363,   337,   341,   342,   345,   368,   372,   376,   338,   339,
-     343,   344,   364,   340,   346,   379,   380,   381,   383,   385,
-     387,   389,   391,   395,   396,   397,   398,   399,   400,   402,
-     403,   404,   405,   406,   407,   409,   411,   412,   413,   415,
-     416,   393,   401,   408,   417,   419,   420,   421,   423,   424,
-     382,   384,   386,   410,   388,   390,   392,   394,   414,   418,
-     422,   471,   472,   475,   476,   477,   478,   473,   474,   425,
-     427,   428,   429,   431,   432,   433,   435,   436,   437,   439,
-     440,   441,   443,   444,   445,   447,   448,   449,   451,   452,
-     453,   455,   456,   457,   459,   460,   461,   463,   464,   465,
-     467,   468,   426,   430,   434,   438,   442,   450,   454,   458,
-     446,   462,   466,     0,   194,   480,   565,   131,   146,   481,
-     482,   483,     0,   564,     0,   566,     0,   108,   107,     0,
-     119,   124,   153,   152,   150,   154,     0,   147,   149,   155,
-     129,   188,   151,   479,     0,   561,   563,     0,     0,     0,
-     486,     0,     0,    96,    93,     0,   106,     0,   115,   109,
-     117,     0,   118,     0,    94,   125,     0,    99,   148,   130,
-       0,   189,     1,   562,   186,     0,   145,   143,     0,   141,
-     484,     0,     0,    97,     0,     0,   567,   110,   114,   116,
-     112,   120,   111,     0,   126,   102,     0,   100,     0,     2,
-      12,    13,    10,    11,     4,     5,     6,     7,     8,     9,
-      15,    14,     0,     0,     0,   190,    42,    41,    43,    40,
-       3,    17,    36,    19,    24,    25,     0,     0,    29,     0,
-      44,     0,    48,    51,    54,    59,    62,    64,    66,    68,
-      70,    72,    74,     0,    35,    33,     0,   184,     0,     0,
-     140,     0,     0,     0,     0,     0,   488,    95,    98,     0,
-       0,   546,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   512,   521,   525,    44,    77,    90,     0,   501,     0,
-     155,   129,   504,   523,   503,   502,     0,   505,   506,   527,
-     507,   534,   508,   509,   542,   510,     0,   113,     0,   121,
-       0,   496,   128,     0,     0,   104,     0,   101,    37,    38,
-       0,    21,    22,     0,     0,    27,    26,     0,   194,    30,
-      32,    39,     0,     0,     0,     0,     0,     0,     0,     0,
+     174,   175,   176,   177,   178,   219,   220,   221,   276,   277,
+     278,   222,   223,   224,   288,   289,   290,   225,   226,   227,
+     300,   301,   302,   228,   229,   230,   312,   313,   314,   134,
+     133,   132,     0,   135,   136,   137,   138,   139,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   303,   304,   305,   306,   307,
+     308,   309,   310,   311,   315,   316,   317,   318,   319,   320,
+     321,   322,   323,   325,   324,   484,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   352,   353,   354,
+     355,   356,   357,   359,   360,   361,   362,   363,   364,   366,
+     367,   370,   371,   372,   374,   375,   337,   338,   358,   365,
+     376,   378,   379,   380,   382,   383,   474,   475,   339,   340,
+     341,   368,   342,   346,   347,   350,   373,   377,   381,   343,
+     344,   348,   349,   369,   345,   351,   384,   385,   386,   388,
+     390,   392,   394,   396,   400,   401,   402,   403,   404,   405,
+     407,   408,   409,   410,   411,   412,   414,   416,   417,   418,
+     420,   421,   398,   406,   413,   422,   424,   425,   426,   428,
+     429,   387,   389,   391,   415,   393,   395,   397,   399,   419,
+     423,   427,   476,   477,   480,   481,   482,   483,   478,   479,
+     430,   432,   433,   434,   436,   437,   438,   440,   441,   442,
+     444,   445,   446,   448,   449,   450,   452,   453,   454,   456,
+     457,   458,   460,   461,   462,   464,   465,   466,   468,   469,
+     470,   472,   473,   431,   435,   439,   443,   447,   455,   459,
+     463,   451,   467,   471,     0,   199,   486,   571,   131,   146,
+     487,   488,   489,     0,   570,     0,   572,     0,   108,   107,
+       0,   119,   124,   153,   152,   150,   154,     0,   147,   149,
+     155,   129,   195,   151,   485,     0,   567,   569,     0,     0,
+       0,   492,     0,     0,    96,    93,     0,   106,     0,   115,
+     109,   117,     0,   118,     0,    94,   125,     0,    99,   148,
+     130,     0,   188,   194,     1,   568,   186,     0,   145,   143,
+       0,   141,   490,     0,     0,     0,    97,     0,     0,   573,
+     110,   114,   116,   112,   120,   111,     0,   126,   102,     0,
+     100,     0,     2,    12,    13,    10,    11,     4,     5,     6,
+       7,     8,     9,    15,    14,     0,     0,     0,    42,    41,
+      43,    40,     3,    17,    36,    19,    24,    25,     0,     0,
+      29,     0,   197,     0,    35,    33,     0,   189,   184,     0,
+       0,   140,     0,     0,     0,     0,     0,   494,    95,   190,
+      44,    48,    51,    54,    59,    62,    64,    66,    68,    70,
+      72,    74,     0,     0,    98,     0,     0,   552,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   518,   527,   531,
+      44,    77,    90,     0,   507,     0,   155,   129,   510,   529,
+     509,   508,     0,   511,   512,   533,   513,   540,   514,   515,
+     548,   516,     0,   113,     0,   121,     0,   502,   128,     0,
+       0,   104,     0,   101,    37,    38,     0,    21,    22,     0,
+       0,    27,    26,     0,   199,    30,    32,    39,     0,   196,
+     187,    92,   144,   142,     0,     0,   500,     0,   498,   493,
+     495,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    75,   191,   192,     0,   187,    92,   144,   142,     0,
-       0,   494,     0,   492,   487,   489,   557,   556,     0,   548,
-       0,   560,   558,     0,     0,     0,   541,   544,     0,   511,
-       0,    80,    81,    83,    82,    85,    86,    87,    88,    89,
-      84,    79,     0,     0,   526,   522,   524,   528,   535,   543,
-     123,     0,   499,     0,   127,     0,   105,    16,     0,    23,
-      20,    31,    45,    46,    47,    50,    49,    52,    53,    57,
-      58,    55,    56,    60,    61,    63,    65,    67,    69,    71,
-      73,     0,   193,   485,     0,   495,     0,   490,     0,     0,
-       0,   559,     0,   540,     0,   571,     0,   569,   513,    78,
-      91,   122,   497,     0,   103,    18,     0,   491,   493,     0,
-     551,   550,   553,   519,   536,   532,     0,     0,     0,     0,
-       0,     0,     0,   498,   500,     0,     0,   552,     0,     0,
-     531,     0,     0,   529,     0,     0,     0,     0,   568,   570,
-     514,    76,     0,   554,     0,   519,   518,   520,   538,     0,
-     516,   545,   515,   572,     0,   555,   549,   530,   539,     0,
-     533,   547,   537
+      75,   191,   192,     0,   563,   562,     0,   554,     0,   566,
+     564,     0,     0,     0,   547,   550,     0,   517,     0,    80,
+      81,    83,    82,    85,    86,    87,    88,    89,    84,    79,
+       0,     0,   532,   528,   530,   534,   541,   549,   123,     0,
+     505,     0,   127,     0,   105,    16,     0,    23,    20,    31,
+     198,   491,     0,   501,     0,   496,    45,    46,    47,    50,
+      49,    52,    53,    57,    58,    55,    56,    60,    61,    63,
+      65,    67,    69,    71,    73,     0,   193,     0,     0,     0,
+     565,     0,   546,     0,   577,     0,   575,   519,    78,    91,
+     122,   503,     0,   103,    18,   497,   499,     0,     0,   557,
+     556,   559,   525,   542,   538,     0,     0,     0,     0,     0,
+       0,     0,   504,   506,     0,     0,   558,     0,     0,   537,
+       0,     0,   535,     0,     0,     0,     0,   574,   576,   520,
+      76,     0,   560,     0,   525,   524,   526,   544,     0,   522,
+     551,   521,   578,     0,   561,   555,   536,   545,     0,   539,
+     553,   543
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,  -657,  -305,  -657,  -373,  -372,  -429,  -376,  -323,  -294,
-    -324,  -295,  -293,  -296,  -657,  -370,  -657,  -394,  -657,  -383,
-    -414,     1,  -657,  -657,  -657,     2,  -657,  -657,  -657,  -114,
-    -109,  -111,  -657,  -657,  -613,  -657,  -657,  -657,  -657,  -198,
-    -657,  -335,  -342,  -657,     6,  -657,     0,  -350,  -657,   -70,
-    -657,  -657,  -657,  -444,  -450,  -292,  -371,  -494,  -657,  -375,
-    -462,  -656,  -415,  -657,  -657,  -427,  -426,  -657,  -657,   -93,
-    -563,  -366,  -657,  -232,  -657,  -387,  -657,  -230,  -657,  -657,
-    -657,  -657,  -229,  -657,  -657,  -657,  -657,  -657,  -657,  -657,
-    -657,   -76,  -657,  -657,  -657,  -657,  -391
+    -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,  -659,
+    -659,  -659,  -364,  -659,  -389,  -385,  -457,  -384,  -310,  -307,
+    -305,  -308,  -301,  -298,  -659,  -386,  -659,  -390,  -659,  -415,
+    -418,     1,  -659,  -659,  -659,     2,  -659,  -659,  -659,  -110,
+    -105,  -107,  -659,  -659,  -628,  -659,  -659,  -659,  -659,  -188,
+    -659,  -336,  -343,  -659,     6,  -659,     0,  -334,  -659,  -659,
+    -659,  -659,   -67,  -659,  -659,  -659,  -431,  -437,  -277,  -350,
+    -501,  -659,  -375,  -488,  -658,  -414,  -659,  -659,  -428,  -426,
+    -659,  -659,   -87,  -568,  -368,  -659,  -231,  -659,  -388,  -659,
+    -230,  -659,  -659,  -659,  -659,  -228,  -659,  -659,  -659,  -659,
+    -659,  -659,  -659,  -659,   -70,  -659,  -659,  -659,  -659,  -394
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,   430,   431,   432,   608,   433,   434,   435,   436,   437,
-     438,   439,   484,   441,   442,   443,   444,   445,   446,   447,
-     448,   449,   450,   451,   452,   485,   631,   486,   592,   487,
-     557,   488,   334,   514,   408,   489,   336,   337,   338,   368,
-     369,   370,   339,   340,   341,   342,   343,   344,   388,   389,
-     345,   346,   347,   348,   454,   385,   455,   381,   351,   352,
-     353,   462,   391,   465,   466,   562,   563,   512,   603,   492,
-     493,   494,   495,   580,   672,   701,   680,   681,   682,   702,
-     496,   497,   498,   499,   683,   668,   500,   501,   684,   709,
-     502,   503,   504,   644,   568,   639,   662,   678,   679,   505,
-     354,   355,   356,   365,   506,   646,   647
+      -1,   432,   433,   434,   616,   435,   436,   437,   438,   439,
+     440,   441,   490,   443,   461,   462,   463,   464,   465,   466,
+     467,   468,   469,   470,   471,   491,   645,   492,   600,   493,
+     542,   494,   335,   520,   411,   495,   337,   338,   339,   369,
+     370,   371,   340,   341,   342,   343,   344,   345,   390,   391,
+     346,   347,   348,   349,   444,   387,   445,   397,   382,   383,
+     446,   352,   353,   354,   453,   393,   456,   457,   547,   548,
+     518,   611,   498,   499,   500,   501,   588,   681,   710,   689,
+     690,   691,   711,   502,   503,   504,   505,   692,   677,   506,
+     507,   693,   718,   508,   509,   510,   653,   576,   648,   671,
+     687,   688,   511,   355,   356,   357,   366,   512,   655,   656
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1384,121 +1390,122 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     350,   333,   335,   371,   378,   471,   349,   472,   473,   511,
-     453,   476,   394,   386,   600,   565,   602,   648,   559,   604,
-     362,   359,   550,   539,   540,   404,   697,   521,   522,   378,
-     700,   666,   371,   402,   596,   380,   357,   380,   700,   456,
-     364,   520,   403,   358,   529,   393,   -34,   468,   523,   666,
-     507,   509,   524,   375,   380,   456,   463,   551,   541,   542,
-     360,   508,   513,   405,   456,   363,   406,   457,   460,   407,
-     605,   601,   366,   458,   461,   440,   581,   582,   583,   584,
-     585,   586,   587,   588,   589,   590,   554,   537,   538,   556,
-     526,   607,   573,   663,   575,   591,   527,   593,   664,   593,
-     373,   670,   704,   374,   593,   671,   638,   651,   593,   565,
-     619,   620,   621,   622,   511,   384,   511,   518,   519,   511,
-     516,   378,   593,   517,   367,   594,   636,   463,   593,   637,
-     463,   641,   390,   611,   636,   708,   531,   657,   400,   652,
-     609,   653,   329,   330,   331,   532,   533,   534,   535,   380,
-     536,   440,   543,   544,   440,   565,   593,   643,   395,   674,
-     593,   675,   615,   616,   401,   617,   618,   623,   624,   459,
-     456,   467,   515,   525,   530,   548,   547,   545,   546,   463,
-     549,   552,   555,   561,   569,   566,   596,   640,   576,   567,
-     570,   642,   571,   574,   577,   606,   610,   578,   649,   650,
-     -35,   579,   -33,   645,   -28,   710,   659,   511,   632,   655,
-     669,   635,   676,  -517,   685,   593,   686,   688,   690,   695,
-     694,   693,   625,   627,   463,   481,   698,   612,   613,   614,
-     440,   440,   440,   440,   440,   440,   440,   440,   440,   440,
-     440,   440,   440,   440,   440,   440,   596,   703,   656,   699,
-     712,   711,   626,   628,   630,   687,   629,   398,   397,   511,
-     399,   665,   361,   558,   660,   658,   696,   706,   634,   707,
-     463,   387,   396,   661,   597,   677,   598,   599,   383,   665,
-     689,   691,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   692,     0,     0,     0,     0,     0,   556,
-       0,     0,     0,     0,     0,   511,     0,     0,     0,   667,
-     705,     0,     0,     0,     0,     0,     0,     0,     0,   479,
-       0,     0,     0,     0,     0,   378,     0,   667,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   372,     0,
-       0,     0,     0,     0,   349,     0,   379,     0,     0,     0,
-       0,     0,   349,     0,   350,   333,   335,     0,     0,     0,
-     349,   392,     0,     0,   440,     0,     0,   372,     0,     0,
-       0,   372,     0,   349,     0,     0,     0,   349,     0,     0,
+     351,   334,   336,   372,   379,   477,   350,   478,   479,   472,
+     388,   482,   526,   608,   604,   610,   517,   442,   612,   550,
+     657,   360,   544,   558,   559,   675,   363,   538,   395,   379,
+     569,   460,   372,   706,   365,   448,   396,   709,   405,   539,
+     395,   449,   407,   675,   358,   709,   451,   406,   447,   395,
+     535,   359,   452,   527,   528,   473,   514,   454,   560,   561,
+     361,   524,   525,   474,   541,   570,   581,   367,   583,   513,
+     515,   364,   -34,   473,   529,   473,   368,   532,   530,   537,
+     519,   679,   609,   533,   615,   680,   460,   573,   647,   613,
+     601,   589,   590,   591,   592,   593,   594,   595,   596,   597,
+     598,   633,   634,   635,   636,   556,   557,   550,   660,   460,
+     599,   379,   408,   672,   617,   409,   673,   454,   410,   601,
+     454,   713,   601,   376,   517,   374,   517,   601,   375,   517,
+     522,   601,   624,   523,   602,   625,   386,   601,   624,   717,
+     650,   665,   661,   619,   662,   330,   331,   332,   551,   552,
+     553,   554,   381,   555,   562,   563,   601,   652,   601,   684,
+     392,   683,   403,   649,   398,   629,   630,   651,   404,   604,
+     395,   631,   632,   450,   620,   458,   550,   521,   637,   638,
+     531,   536,   473,   540,   454,   546,   566,   626,   627,   628,
+     460,   460,   460,   460,   460,   460,   460,   460,   460,   460,
+     460,   460,   460,   460,   460,   460,   564,   719,   454,   565,
+     658,   659,   623,   567,   568,   574,   571,   575,   579,   517,
+     587,   577,   578,   582,   584,   614,   586,   585,   -35,   604,
+     667,   -33,   618,   -28,   654,   668,   646,   664,   674,   678,
+     685,  -523,   601,   694,   695,   697,   699,   703,   702,   704,
+     712,   487,   707,   708,   639,   720,   674,   721,   640,   642,
+     696,   641,   401,   400,   543,   402,   362,   643,   622,   389,
+     701,   644,   517,   669,   666,   715,   705,   454,   716,   399,
+     670,   605,   606,   686,   607,   385,   698,   714,     0,     0,
+       0,     0,   541,     0,   700,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   464,     0,     0,     0,   491,     0,   349,     0,     0,
-       0,   490,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   460,     0,     0,   676,   517,     0,
+     485,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   379,     0,   676,     0,     0,     0,   373,
+       0,     0,     0,     0,     0,   350,     0,   380,     0,     0,
+       0,     0,     0,   350,     0,   351,   334,   336,     0,     0,
+       0,   350,   394,     0,     0,     0,     0,     0,   373,     0,
+       0,     0,   373,     0,   350,     0,     0,     0,   350,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   455,     0,     0,     0,     0,   497,   350,
+       0,     0,     0,     0,   496,     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,   464,   560,     0,   464,     0,     0,   349,   349,
-       0,   349,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   455,   545,     0,   455,     0,     0,   350,
+     350,     0,   350,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   491,     0,     0,     0,
-       0,     0,   490,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   464,     0,     0,     0,     0,     0,
-     349,     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,   464,
-       0,     0,     0,     0,     0,   349,     0,     0,   491,     0,
-       0,     0,     0,     0,   490,     0,     0,     0,     0,     0,
-     491,     0,     0,     0,     0,     0,   490,     0,     0,     0,
+       0,     0,   497,     0,     0,     0,     0,     0,   496,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   464,     0,     0,     0,     0,
-       0,   349,     0,     0,     0,     0,     0,     0,     0,     0,
+     455,     0,     0,     0,     0,     0,   350,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   491,
-       0,     0,     0,     0,   491,   490,     0,     0,   491,     0,
-     490,     0,     0,     0,   490,     0,     0,     0,     0,     0,
-       0,     0,   491,     0,     0,     0,     0,   379,   490,     0,
-       0,     0,     0,   349,     0,     0,     0,     0,     0,     0,
-       0,     0,   491,     0,     0,     0,   491,     0,   490,     0,
-       0,     0,   490,     0,   491,     0,     0,     0,   491,     0,
-     490,     0,     0,     0,   490,     0,     0,     0,   491,     0,
-       0,     0,   382,     0,   490,     1,     2,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    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,   325,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   455,     0,     0,     0,     0,     0,
+     350,     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,   497,     0,     0,     0,
+       0,     0,   496,     0,     0,     0,     0,     0,   497,     0,
+       0,     0,     0,     0,   496,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   455,     0,     0,     0,     0,     0,   350,
+       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,   497,     0,
+       0,     0,     0,   497,   496,     0,     0,   497,     0,   496,
+       0,     0,     0,   496,     0,     0,     0,     0,     0,     0,
+       0,   497,     0,     0,     0,     0,   380,   496,     0,     0,
+       0,     0,   350,     0,     0,     0,     0,     0,     0,     0,
+       0,   497,     0,     0,     0,   497,     0,   496,     0,     0,
+       0,   496,     0,   497,     0,     0,     0,   497,     0,   496,
+       0,     0,     0,   496,     0,     0,     0,   497,     0,     0,
+       0,   384,     0,   496,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    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,
+       0,     0,   326,     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,   326,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   327,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     327,   328,   329,   330,   331,   332,     1,     2,     3,     4,
+     328,   329,   330,   331,   332,   333,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,   469,   470,   471,     0,   472,
-     473,   474,   475,   476,   477,   478,    20,    21,    22,    23,
+      15,    16,    17,    18,    19,   475,   476,   477,     0,   478,
+     479,   480,   481,   482,   483,   484,    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,
@@ -1529,56 +1536,16 @@ static const yytype_int16 yytable[] =
      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,   479,   409,   325,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,   421,     0,     0,   422,   423,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   424,     0,   480,
-       0,   481,   482,     0,     0,     0,     0,   483,   426,   427,
-     428,   429,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   327,   328,   329,   330,   331,   332,     1,     2,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,   469,   470,   471,     0,
-     472,   473,   474,   475,   476,   477,   478,    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,   479,   409,   325,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,   421,     0,     0,   422,
-     423,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   424,     0,
-     480,     0,   481,   595,     0,     0,     0,     0,   483,   426,
-     427,   428,   429,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   327,   328,   329,   330,   331,   332,     1,     2,
+     324,   325,   485,   412,   326,   413,   414,   415,   416,   417,
+     418,   419,   420,   421,   422,   423,   424,     0,     0,   425,
+     426,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   427,     0,
+     486,     0,   487,   488,     0,     0,     0,     0,   489,   428,
+     429,   430,   431,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   328,   329,   330,   331,   332,   333,     1,     2,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,   469,   470,   471,
-       0,   472,   473,   474,   475,   476,   477,   478,    20,    21,
+      13,    14,    15,    16,    17,    18,    19,   475,   476,   477,
+       0,   478,   479,   480,   481,   482,   483,   484,    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,
@@ -1609,56 +1576,16 @@ static const yytype_int16 yytable[] =
      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,   479,   409,   325,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,   421,     0,     0,
-     422,   423,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   424,
-       0,   480,     0,   481,     0,     0,     0,     0,     0,   483,
-     426,   427,   428,   429,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   327,   328,   329,   330,   331,   332,     1,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,   469,   470,
-     471,     0,   472,   473,   474,   475,   476,   477,   478,    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,   479,   409,   325,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,   421,     0,
-       0,   422,   423,     0,     0,     0,     0,     0,     0,     0,
+     322,   323,   324,   325,   485,   412,   326,   413,   414,   415,
+     416,   417,   418,   419,   420,   421,   422,   423,   424,     0,
+       0,   425,   426,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     424,     0,   480,     0,   395,     0,     0,     0,     0,     0,
-     483,   426,   427,   428,   429,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   327,   328,   329,   330,   331,   332,
+     427,     0,   486,     0,   487,   603,     0,     0,     0,     0,
+     489,   428,   429,   430,   431,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   328,   329,   330,   331,   332,   333,
        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,   469,
-     470,   471,     0,   472,   473,   474,   475,   476,   477,   478,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,   475,
+     476,   477,     0,   478,   479,   480,   481,   482,   483,   484,
       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,
@@ -1689,57 +1616,17 @@ static const yytype_int16 yytable[] =
      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,   479,   409,   325,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,   421,
-       0,     0,   422,   423,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   424,     0,   480,     0,     0,     0,     0,     0,     0,
-       0,   483,   426,   427,   428,   429,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   327,   328,   329,   330,   331,
-     332,     1,     2,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    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,   409,   325,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-     421,     0,     0,   422,   423,     0,     0,     0,     0,     0,
+     320,   321,   322,   323,   324,   325,   485,   412,   326,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   423,
+     424,     0,     0,   425,   426,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   424,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   483,   426,   427,   428,   429,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   327,   328,   329,   330,
-     331,   332,     1,     2,     3,     4,     5,     6,     7,     8,
+       0,     0,   427,     0,   486,     0,   487,     0,     0,     0,
+       0,     0,   489,   428,   429,   430,   431,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   328,   329,   330,   331,
+     332,   333,     1,     2,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    20,    21,    22,    23,    24,    25,    26,    27,
+      19,   475,   476,   477,     0,   478,   479,   480,   481,   482,
+     483,   484,    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,
@@ -1769,302 +1656,67 @@ static const yytype_int16 yytable[] =
      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,   325,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     318,   319,   320,   321,   322,   323,   324,   325,   485,   412,
+     326,   413,   414,   415,   416,   417,   418,   419,   420,   421,
+     422,   423,   424,     0,     0,   425,   426,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   427,     0,   486,     0,   398,     0,
+       0,     0,     0,     0,   489,   428,   429,   430,   431,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   328,   329,
+     330,   331,   332,   333,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,   475,   476,   477,     0,   478,   479,   480,
+     481,   482,   483,   484,    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,
+     485,   412,   326,   413,   414,   415,   416,   417,   418,   419,
+     420,   421,   422,   423,   424,     0,     0,   425,   426,     0,
        0,     0,     0,     0,     0,     0,     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,   332,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,   409,
-     325,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,   421,     0,     0,   422,   423,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   424,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   426,   427,   428,   429,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,   376,
-     325,     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,   377,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,
-     325,     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,   564,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,
-     325,     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,   633,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,
-     325,     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,   654,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,     1,     2,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,
-     325,     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,     3,     4,     5,     6,     7,     0,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,     0,     0,     0,     0,     0,     0,     0,   327,   328,
-     329,   330,   331,    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,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    69,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     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,   409,   325,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   421,     0,     0,   422,   423,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   424,     0,     0,     0,   510,   673,     0,
-       0,     0,     0,     0,   426,   427,   428,   429,     3,     4,
-       5,     6,     7,     0,     9,    10,    11,    12,    13,    14,
+       0,     0,     0,     0,     0,     0,   427,     0,   486,     0,
+       0,     0,     0,     0,     0,     0,   489,   428,   429,   430,
+     431,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     328,   329,   330,   331,   332,   333,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    21,    22,    23,
+       0,     0,     0,     0,     0,     0,    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,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    69,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      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,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   118,   119,   120,   121,   122,   123,
+     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,
@@ -2085,24 +1737,66 @@ static const yytype_int16 yytable[] =
      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,   409,   325,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,   421,     0,     0,   422,   423,
+     324,   325,     0,   412,   326,   413,   414,   415,   416,   417,
+     418,   419,   420,   421,   422,   423,   424,     0,     0,   425,
+     426,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   427,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   489,   428,
+     429,   430,   431,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   328,   329,   330,   331,   332,   333,     1,     2,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    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,     0,     0,   326,     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,   424,     0,     0,
-     425,     0,     0,     0,     0,     0,     0,     0,   426,   427,
-     428,   429,     3,     4,     5,     6,     7,     0,     9,    10,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     327,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   328,   329,   330,   331,   332,   333,
+       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      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,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    69,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    85,    86,    87,    88,    89,
+      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,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   118,   119,
+     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,
@@ -2123,278 +1817,58 @@ static const yytype_int16 yytable[] =
      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,   409,   325,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,   419,   420,   421,
-       0,     0,   422,   423,     0,     0,     0,     0,     0,     0,
+     320,   321,   322,   323,   324,   325,     0,   412,   326,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   423,
+     424,     0,     0,   425,   426,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   424,     0,     0,     0,   510,     0,     0,     0,     0,
-       0,     0,   426,   427,   428,   429,     3,     4,     5,     6,
-       7,     0,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    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,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    69,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
-     106,   107,   108,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   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,
-     409,   325,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,   419,   420,   421,     0,     0,   422,   423,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   424,     0,     0,   553,     0,
-       0,     0,     0,     0,     0,     0,   426,   427,   428,   429,
-       3,     4,     5,     6,     7,     0,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    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,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    69,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   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,   409,   325,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,   419,   420,   421,     0,     0,
-     422,   423,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   424,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   572,
-     426,   427,   428,   429,     3,     4,     5,     6,     7,     0,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    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,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    69,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     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,   409,   325,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
-     420,   421,     0,     0,   422,   423,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   424,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   426,   427,   428,   429,     3,     4,
-       5,     6,     7,     0,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    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,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    69,     0,     0,     0,     0,
+       0,     0,   427,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   428,   429,   430,   431,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   328,   329,   330,   331,
+     332,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,   107,   108,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   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,
-     528,     0,   409,   325,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   419,   420,   421,     0,     0,   422,   423,
+       0,    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,     0,   377,   326,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   424,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   426,   427,
-     428,   429,     3,     4,     5,     6,     7,     0,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    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,
        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,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107,   108,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   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,   325
-};
-
-static const yytype_int16 yycheck[] =
-{
-       0,     0,     0,   338,   346,    24,     0,    26,    27,   403,
-     380,    30,   362,    81,   508,   465,   510,   580,   462,   513,
-     339,   339,   362,   357,   358,   375,   682,   355,   356,   371,
-     686,   644,   367,   374,   496,   376,   374,   376,   694,   376,
-     384,   424,   383,   374,   438,   384,   374,   384,   376,   662,
-     400,   401,   380,   339,   376,   376,   391,   397,   392,   393,
-     378,   383,   383,   378,   376,   384,   381,   375,   375,   384,
-     514,   383,   375,   381,   381,   380,   364,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   456,   353,   354,   459,
-     375,   375,   475,   375,   477,   383,   381,   381,   375,   381,
-     381,   377,   375,   384,   381,   381,   568,   601,   381,   559,
-     539,   540,   541,   542,   508,   339,   510,   422,   423,   513,
-     381,   463,   381,   384,   381,   384,   381,   462,   381,   384,
-     465,   384,   378,   527,   381,   698,   441,   384,   339,   379,
-     523,   381,   400,   401,   402,   389,   390,   391,   386,   376,
-     388,   456,   359,   360,   459,   605,   381,   382,   378,   653,
-     381,   382,   535,   536,   339,   537,   538,   543,   544,   383,
-     376,   384,   339,   375,   374,   361,   394,   396,   395,   514,
-     363,   377,   339,   339,   374,   384,   648,   570,   382,   384,
-     374,   574,   384,   374,   374,   339,   339,   376,   592,   593,
-     374,   379,   374,   339,   375,   699,   338,   601,   377,   377,
-     374,   561,   374,   378,   339,   381,   375,   377,   379,    25,
-     375,   384,   545,   547,   559,   378,   378,   532,   533,   534,
-     535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
-     545,   546,   547,   548,   549,   550,   708,   375,   631,   383,
-     379,   384,   546,   548,   550,   669,   549,   371,   367,   653,
-     371,   644,   332,   461,   639,   636,   681,   694,   560,   695,
-     605,   339,   365,   639,   506,   662,   506,   506,   354,   662,
-     671,   675,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   676,    -1,    -1,    -1,    -1,    -1,   669,
-      -1,    -1,    -1,    -1,    -1,   699,    -1,    -1,    -1,   644,
-     693,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,
-      -1,    -1,    -1,    -1,    -1,   667,    -1,   662,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,    -1,
-      -1,    -1,    -1,    -1,   338,    -1,   346,    -1,    -1,    -1,
-      -1,    -1,   346,    -1,   354,   354,   354,    -1,    -1,    -1,
-     354,   361,    -1,    -1,   669,    -1,    -1,   367,    -1,    -1,
-      -1,   371,    -1,   367,    -1,    -1,    -1,   371,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   391,    -1,    -1,    -1,   395,    -1,   391,    -1,    -1,
-      -1,   395,    -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,   462,   463,    -1,   465,    -1,    -1,   462,   463,
-      -1,   465,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   496,    -1,    -1,    -1,
-      -1,    -1,   496,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   514,    -1,    -1,    -1,    -1,    -1,
-     514,    -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,   559,
-      -1,    -1,    -1,    -1,    -1,   559,    -1,    -1,   568,    -1,
-      -1,    -1,    -1,    -1,   568,    -1,    -1,    -1,    -1,    -1,
-     580,    -1,    -1,    -1,    -1,    -1,   580,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   605,    -1,    -1,    -1,    -1,
-      -1,   605,    -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,   639,
-      -1,    -1,    -1,    -1,   644,   639,    -1,    -1,   648,    -1,
-     644,    -1,    -1,    -1,   648,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   662,    -1,    -1,    -1,    -1,   667,   662,    -1,
-      -1,    -1,    -1,   667,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   682,    -1,    -1,    -1,   686,    -1,   682,    -1,
-      -1,    -1,   686,    -1,   694,    -1,    -1,    -1,   698,    -1,
-     694,    -1,    -1,    -1,   698,    -1,    -1,    -1,   708,    -1,
-      -1,    -1,     0,    -1,   708,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    33,    34,    35,    36,    37,
+       0,     0,     0,   378,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   328,   329,   330,
+     331,   332,     1,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    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,
@@ -2423,17 +1897,17 @@ 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,   317,
-     318,   319,   320,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
-      -1,    -1,   340,    -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,   384,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     398,   399,   400,   401,   402,   403,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    -1,    26,
+     318,   319,   320,   321,   322,   323,   324,   325,     0,     0,
+     326,     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,   549,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   328,   329,
+     330,   331,   332,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    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,
@@ -2463,17 +1937,17 @@ 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,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,   351,   352,    -1,    -1,   355,   356,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,    -1,   376,
-      -1,   378,   379,    -1,    -1,    -1,    -1,   384,   385,   386,
-     387,   388,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   398,   399,   400,   401,   402,   403,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    -1,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,     0,
+       0,   326,     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,
+     621,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   328,
+     329,   330,   331,   332,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    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,
@@ -2504,17 +1978,17 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,   330,   331,   332,   333,   334,   335,
-     336,   337,   338,   339,   340,   341,   342,   343,   344,   345,
-     346,   347,   348,   349,   350,   351,   352,    -1,    -1,   355,
-     356,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,    -1,
-     376,    -1,   378,   379,    -1,    -1,    -1,    -1,   384,   385,
-     386,   387,   388,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   398,   399,   400,   401,   402,   403,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      -1,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+       0,     0,   326,     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,   663,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     328,   329,   330,   331,   332,     1,     2,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    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,
@@ -2544,186 +2018,61 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,    -1,    -1,
-     355,   356,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,
-      -1,   376,    -1,   378,    -1,    -1,    -1,    -1,    -1,   384,
-     385,   386,   387,   388,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   398,   399,   400,   401,   402,   403,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    -1,    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,   327,   328,   329,   330,   331,   332,   333,
-     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
-     344,   345,   346,   347,   348,   349,   350,   351,   352,    -1,
-      -1,   355,   356,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     374,    -1,   376,    -1,   378,    -1,    -1,    -1,    -1,    -1,
-     384,   385,   386,   387,   388,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,   403,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    -1,    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,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
-      -1,    -1,   355,   356,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   374,    -1,   376,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   384,   385,   386,   387,   388,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,
-     403,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    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,   327,   328,   329,   330,   331,
-     332,   333,   334,   335,   336,   337,    -1,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,   349,   350,   351,
-     352,    -1,    -1,   355,   356,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   374,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   384,   385,   386,   387,   388,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   398,   399,   400,   401,
-     402,   403,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    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,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,    -1,   340,
-      -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,   384,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,   400,
-     401,   402,   403,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+     325,     0,     0,   326,     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,     3,     4,     5,
+       6,     7,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
+       0,   328,   329,   330,   331,   332,    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,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    69,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   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,     0,   412,   326,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,   422,   423,   424,     0,     0,   425,   426,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   427,     0,     0,
+       0,   516,   682,     0,     0,     0,     0,     0,   428,   429,
+     430,   431,     3,     4,     5,     6,     7,     0,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    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,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    69,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    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,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   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,
@@ -2744,26 +2093,63 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,   339,
-     340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
-     350,   351,   352,    -1,    -1,   355,   356,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   374,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+     320,   321,   322,   323,   324,   325,     0,   412,   326,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   423,
+     424,     0,     0,   425,   426,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   427,     0,     0,   459,     0,     0,     0,     0,
+       0,     0,     0,   428,   429,   430,   431,     3,     4,     5,
+       6,     7,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    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,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    69,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   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,     0,   412,   326,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,   422,   423,   424,     0,     0,   425,   426,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   427,     0,     0,
+       0,   516,     0,     0,     0,     0,     0,     0,   428,   429,
+     430,   431,     3,     4,     5,     6,     7,     0,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    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,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    69,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    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,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   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,
@@ -2784,26 +2170,63 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,   339,
-     340,    -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,   384,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+     320,   321,   322,   323,   324,   325,     0,   412,   326,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   423,
+     424,     0,     0,   425,   426,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   427,     0,     0,   572,     0,     0,     0,     0,
+       0,     0,     0,   428,   429,   430,   431,     3,     4,     5,
+       6,     7,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    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,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    69,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   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,     0,   412,   326,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,   422,   423,   424,     0,     0,   425,   426,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   427,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   580,   428,   429,
+     430,   431,     3,     4,     5,     6,     7,     0,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    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,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    69,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    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,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   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,
@@ -2824,66 +2247,63 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,    -1,
-     340,    -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,   379,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,    -1,
-     340,    -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,   379,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    33,    34,    35,    36,    37,    38,    39,
+     320,   321,   322,   323,   324,   325,     0,   412,   326,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   423,
+     424,     0,     0,   425,   426,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   427,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   428,   429,   430,   431,     3,     4,     5,
+       6,     7,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    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,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    69,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   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,
+     534,     0,   412,   326,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,   422,   423,   424,     0,     0,   425,   426,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   427,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   428,   429,
+     430,   431,     3,     4,     5,     6,     7,     0,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    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,
+       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,    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,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   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,
@@ -2904,64 +2324,257 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,    -1,
-     340,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     320,   321,   322,   323,   324,   325,     0,     0,   326
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,     0,     0,   339,   347,    24,     0,    26,    27,   395,
+      81,    30,   427,   514,   502,   516,   406,   381,   519,   456,
+     588,   340,   453,   358,   359,   653,   340,   382,   377,   372,
+     363,   395,   368,   691,   385,   376,   385,   695,   375,   394,
+     377,   382,   376,   671,   375,   703,   376,   384,   382,   377,
+     440,   375,   382,   356,   357,   377,   384,   393,   393,   394,
+     379,   425,   426,   385,   450,   398,   481,   376,   483,   403,
+     404,   385,   375,   377,   377,   377,   382,   376,   381,   443,
+     384,   378,   384,   382,   376,   382,   450,   473,   576,   520,
+     382,   365,   366,   367,   368,   369,   370,   371,   372,   373,
+     374,   558,   559,   560,   561,   354,   355,   544,   609,   473,
+     384,   454,   379,   376,   529,   382,   376,   453,   385,   382,
+     456,   376,   382,   340,   514,   382,   516,   382,   385,   519,
+     382,   382,   382,   385,   385,   385,   340,   382,   382,   707,
+     385,   385,   380,   533,   382,   401,   402,   403,   390,   391,
+     392,   387,   393,   389,   360,   361,   382,   383,   382,   383,
+     379,   662,   340,   578,   379,   554,   555,   582,   340,   657,
+     377,   556,   557,   384,   538,   385,   613,   340,   562,   563,
+     376,   375,   377,   340,   520,   340,   395,   551,   552,   553,
+     554,   555,   556,   557,   558,   559,   560,   561,   562,   563,
+     564,   565,   566,   567,   568,   569,   397,   708,   544,   396,
+     600,   601,   546,   362,   364,   385,   378,   385,   385,   609,
+     380,   375,   375,   375,   383,   340,   377,   375,   375,   717,
+     645,   375,   340,   376,   340,   339,   378,   378,   653,   375,
+     375,   379,   382,   340,   376,   378,   380,   376,   385,    25,
+     376,   379,   379,   384,   564,   385,   671,   380,   565,   567,
+     678,   566,   372,   368,   452,   372,   333,   568,   545,   340,
+     685,   569,   662,   648,   624,   703,   690,   613,   704,   366,
+     648,   512,   512,   671,   512,   355,   680,   702,    -1,    -1,
+      -1,    -1,   678,    -1,   684,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   678,    -1,    -1,   653,   708,    -1,
+     339,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   676,    -1,   671,    -1,    -1,    -1,   339,
+      -1,    -1,    -1,    -1,    -1,   339,    -1,   347,    -1,    -1,
+      -1,    -1,    -1,   347,    -1,   355,   355,   355,    -1,    -1,
+      -1,   355,   362,    -1,    -1,    -1,    -1,    -1,   368,    -1,
+      -1,    -1,   372,    -1,   368,    -1,    -1,    -1,   372,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,
+      -1,    -1,    -1,   393,    -1,    -1,    -1,    -1,   398,   393,
+      -1,    -1,    -1,    -1,   398,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    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,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,    -1,
-     340,    -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,     5,     6,     7,     8,     9,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   453,   454,    -1,   456,    -1,    -1,   453,
+     454,    -1,   456,    -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,   502,    -1,    -1,    -1,    -1,    -1,   502,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     520,    -1,    -1,    -1,    -1,    -1,   520,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   544,    -1,    -1,    -1,    -1,    -1,
+     544,    -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,   576,    -1,    -1,    -1,
+      -1,    -1,   576,    -1,    -1,    -1,    -1,    -1,   588,    -1,
+      -1,    -1,    -1,    -1,   588,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   613,    -1,    -1,    -1,    -1,    -1,   613,
+      -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,   648,    -1,
+      -1,    -1,    -1,   653,   648,    -1,    -1,   657,    -1,   653,
+      -1,    -1,    -1,   657,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   671,    -1,    -1,    -1,    -1,   676,   671,    -1,    -1,
+      -1,    -1,   676,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   691,    -1,    -1,    -1,   695,    -1,   691,    -1,    -1,
+      -1,   695,    -1,   703,    -1,    -1,    -1,   707,    -1,   703,
+      -1,    -1,    -1,   707,    -1,    -1,    -1,   717,    -1,    -1,
+      -1,     0,    -1,   717,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    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,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,   341,    -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,   385,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     399,   400,   401,   402,   403,   404,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    -1,    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,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,   350,   351,   352,   353,    -1,    -1,   356,
+     357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,
+     377,    -1,   379,   380,    -1,    -1,    -1,    -1,   385,   386,
+     387,   388,   389,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   399,   400,   401,   402,   403,   404,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      -1,    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,   327,   328,   329,   330,   331,   332,   333,   334,
+     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
+     345,   346,   347,   348,   349,   350,   351,   352,   353,    -1,
+      -1,   356,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     375,    -1,   377,    -1,   379,   380,    -1,    -1,    -1,    -1,
+     385,   386,   387,   388,   389,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   399,   400,   401,   402,   403,   404,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    -1,    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,   327,   328,   329,   330,   331,   332,
+     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
+     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+     353,    -1,    -1,   356,   357,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   375,    -1,   377,    -1,   379,    -1,    -1,    -1,
+      -1,    -1,   385,   386,   387,   388,   389,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   399,   400,   401,   402,
+     403,   404,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,   399,
-     400,   401,   402,    34,    35,    36,    37,    38,    39,    40,
+      21,    22,    23,    24,    -1,    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,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    82,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    98,    99,   100,
+      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,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     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,
@@ -2982,25 +2595,67 @@ static const yytype_int16 yycheck[] =
      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,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,   339,   340,
+     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
      341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-     351,   352,    -1,    -1,   355,   356,    -1,    -1,    -1,    -1,
+     351,   352,   353,    -1,    -1,   356,   357,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   374,    -1,    -1,    -1,   378,   379,    -1,
-      -1,    -1,    -1,    -1,   385,   386,   387,   388,     5,     6,
-       7,     8,     9,    -1,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      -1,    -1,    -1,    -1,   375,    -1,   377,    -1,   379,    -1,
+      -1,    -1,    -1,    -1,   385,   386,   387,   388,   389,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   399,   400,
+     401,   402,   403,   404,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    -1,    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,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,   352,   353,    -1,    -1,   356,   357,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,
+     389,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     399,   400,   401,   402,   403,   404,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+      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,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   131,   132,   133,   134,   135,   136,
+     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,
@@ -3021,12 +2676,484 @@ static const yytype_int16 yycheck[] =
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
      327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,    -1,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,   351,   352,    -1,    -1,   355,   356,
+     337,   338,    -1,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,   350,   351,   352,   353,    -1,    -1,   356,
+     357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   385,   386,
+     387,   388,   389,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   399,   400,   401,   402,   403,   404,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    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,   327,   328,   329,   330,   331,   332,   333,   334,
+     335,   336,   337,   338,    -1,    -1,   341,    -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,
+     385,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   399,   400,   401,   402,   403,   404,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      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,   327,   328,   329,   330,   331,   332,
+     333,   334,   335,   336,   337,   338,    -1,   340,   341,   342,
+     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+     353,    -1,    -1,   356,   357,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   375,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   399,   400,   401,   402,
+     403,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    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,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,    -1,   340,   341,
+      -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,   385,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   399,   400,   401,
+     402,   403,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    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,   327,   328,   329,   330,
+     331,   332,   333,   334,   335,   336,   337,   338,    -1,    -1,
+     341,    -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,   380,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   399,   400,
+     401,   402,   403,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    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,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,   341,    -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,
+     380,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   399,
+     400,   401,   402,   403,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    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,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,   341,    -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,   380,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     399,   400,   401,   402,   403,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    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,   327,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,    -1,    -1,   341,    -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,     5,     6,     7,
+       8,     9,    -1,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   399,   400,   401,   402,   403,    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,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   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,   327,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,    -1,   340,   341,   342,   343,   344,   345,   346,   347,
+     348,   349,   350,   351,   352,   353,    -1,    -1,   356,   357,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,
+      -1,   379,   380,    -1,    -1,    -1,    -1,    -1,   386,   387,
+     388,   389,     5,     6,     7,     8,     9,    -1,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    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,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    82,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
+     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
+     113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   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,   327,   328,   329,   330,   331,   332,
+     333,   334,   335,   336,   337,   338,    -1,   340,   341,   342,
+     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+     353,    -1,    -1,   356,   357,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   375,    -1,    -1,   378,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,     5,     6,     7,
+       8,     9,    -1,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   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,   327,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,    -1,   340,   341,   342,   343,   344,   345,   346,   347,
+     348,   349,   350,   351,   352,   353,    -1,    -1,   356,   357,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,
+      -1,   379,    -1,    -1,    -1,    -1,    -1,    -1,   386,   387,
+     388,   389,     5,     6,     7,     8,     9,    -1,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    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,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    82,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
+     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
+     113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   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,   327,   328,   329,   330,   331,   332,
+     333,   334,   335,   336,   337,   338,    -1,   340,   341,   342,
+     343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
+     353,    -1,    -1,   356,   357,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   375,    -1,    -1,   378,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,     5,     6,     7,
+       8,     9,    -1,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   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,   327,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,    -1,   340,   341,   342,   343,   344,   345,   346,   347,
+     348,   349,   350,   351,   352,   353,    -1,    -1,   356,   357,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,    -1,    -1,
-     377,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   385,   386,
-     387,   388,     5,     6,     7,     8,     9,    -1,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   385,   386,   387,
+     388,   389,     5,     6,     7,     8,     9,    -1,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    34,    35,    36,    37,    38,    39,    40,    41,    42,
@@ -3059,166 +3186,51 @@ static const yytype_int16 yycheck[] =
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
      323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,    -1,   339,   340,   341,   342,
+     333,   334,   335,   336,   337,   338,    -1,   340,   341,   342,
      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
-      -1,    -1,   355,   356,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   374,    -1,    -1,    -1,   378,    -1,    -1,    -1,    -1,
-      -1,    -1,   385,   386,   387,   388,     5,     6,     7,     8,
-       9,    -1,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   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,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,    -1,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,   351,   352,    -1,    -1,   355,   356,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   374,    -1,    -1,   377,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,
-       5,     6,     7,     8,     9,    -1,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    82,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   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,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,    -1,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,    -1,    -1,
-     355,   356,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,
-     385,   386,   387,   388,     5,     6,     7,     8,     9,    -1,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    82,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     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,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-     351,   352,    -1,    -1,   355,   356,    -1,    -1,    -1,    -1,
+     353,    -1,    -1,   356,   357,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   374,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   385,   386,   387,   388,     5,     6,
-       7,     8,     9,    -1,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,
+      -1,    -1,   375,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,     5,     6,     7,
+       8,     9,    -1,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    82,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   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,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,    -1,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,   351,   352,    -1,    -1,   355,   356,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   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,   327,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,    -1,   340,   341,   342,   343,   344,   345,   346,   347,
+     348,   349,   350,   351,   352,   353,    -1,    -1,   356,   357,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   385,   386,
-     387,   388,     5,     6,     7,     8,     9,    -1,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,   387,
+     388,   389,     5,     6,     7,     8,     9,    -1,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    34,    35,    36,    37,    38,    39,    40,    41,    42,
@@ -3251,7 +3263,7 @@ static const yytype_int16 yycheck[] =
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
      323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,    -1,    -1,   340
+     333,   334,   335,   336,   337,   338,    -1,    -1,   341
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -3290,109 +3302,110 @@ static const yytype_uint16 yystos[] =
      303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
      323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   340,   384,   398,   399,   400,
-     401,   402,   403,   438,   439,   442,   443,   444,   445,   449,
-     450,   451,   452,   453,   454,   457,   458,   459,   460,   461,
-     463,   465,   466,   467,   507,   508,   509,   374,   374,   339,
-     378,   466,   339,   384,   384,   510,   375,   381,   446,   447,
-     448,   458,   463,   381,   384,   339,   339,   384,   459,   463,
-     376,   464,     0,   508,   339,   462,    81,   339,   455,   456,
-     378,   469,   463,   384,   464,   378,   486,   447,   446,   448,
-     339,   339,   374,   383,   464,   378,   381,   384,   441,   339,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-     351,   352,   355,   356,   374,   377,   385,   386,   387,   388,
-     408,   409,   410,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,   432,   461,   463,   376,   375,   381,   383,
-     375,   381,   468,   458,   463,   470,   471,   384,   384,    22,
-      23,    24,    26,    27,    28,    29,    30,    31,    32,   338,
-     376,   378,   379,   384,   419,   432,   434,   436,   438,   442,
-     461,   463,   476,   477,   478,   479,   487,   488,   489,   490,
-     493,   494,   497,   498,   499,   506,   511,   464,   383,   464,
-     378,   434,   474,   383,   440,   339,   381,   384,   419,   419,
-     436,   355,   356,   376,   380,   375,   375,   381,   337,   434,
-     374,   419,   389,   390,   391,   386,   388,   353,   354,   357,
-     358,   392,   393,   359,   360,   396,   395,   394,   361,   363,
-     362,   397,   377,   377,   432,   339,   432,   437,   456,   470,
-     463,   339,   472,   473,   379,   471,   384,   384,   501,   374,
-     374,   384,   384,   436,   374,   436,   382,   374,   376,   379,
-     480,   364,   365,   366,   367,   368,   369,   370,   371,   372,
-     373,   383,   435,   381,   384,   379,   477,   490,   494,   499,
-     474,   383,   474,   475,   474,   470,   339,   375,   411,   436,
-     339,   434,   419,   419,   419,   421,   421,   422,   422,   423,
-     423,   423,   423,   424,   424,   425,   426,   427,   428,   429,
-     430,   433,   377,   379,   472,   464,   381,   384,   477,   502,
-     436,   384,   436,   382,   500,   339,   512,   513,   487,   434,
-     434,   474,   379,   381,   379,   377,   436,   384,   473,   338,
-     476,   488,   503,   375,   375,   436,   451,   458,   492,   374,
-     377,   381,   481,   379,   474,   382,   374,   492,   504,   505,
-     483,   484,   485,   491,   495,   339,   375,   437,   377,   513,
-     379,   434,   436,   384,   375,    25,   479,   478,   378,   383,
-     478,   482,   486,   375,   375,   436,   482,   483,   487,   496,
-     474,   384,   379
+     333,   334,   335,   336,   337,   338,   341,   385,   399,   400,
+     401,   402,   403,   404,   439,   440,   443,   444,   445,   446,
+     450,   451,   452,   453,   454,   455,   458,   459,   460,   461,
+     462,   464,   469,   470,   471,   511,   512,   513,   375,   375,
+     340,   379,   470,   340,   385,   385,   514,   376,   382,   447,
+     448,   449,   459,   464,   382,   385,   340,   340,   385,   460,
+     464,   393,   466,   467,     0,   512,   340,   463,    81,   340,
+     456,   457,   379,   473,   464,   377,   385,   465,   379,   490,
+     448,   447,   449,   340,   340,   375,   384,   465,   379,   382,
+     385,   442,   340,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,   352,   353,   356,   357,   375,   386,   387,
+     388,   389,   409,   410,   411,   413,   414,   415,   416,   417,
+     418,   419,   420,   421,   462,   464,   468,   465,   376,   382,
+     384,   376,   382,   472,   459,   464,   474,   475,   385,   378,
+     420,   422,   423,   424,   425,   426,   427,   428,   429,   430,
+     431,   432,   433,   377,   385,    22,    23,    24,    26,    27,
+      28,    29,    30,    31,    32,   339,   377,   379,   380,   385,
+     420,   433,   435,   437,   439,   443,   462,   464,   480,   481,
+     482,   483,   491,   492,   493,   494,   497,   498,   501,   502,
+     503,   510,   515,   465,   384,   465,   379,   435,   478,   384,
+     441,   340,   382,   385,   420,   420,   437,   356,   357,   377,
+     381,   376,   376,   382,   338,   435,   375,   420,   382,   394,
+     340,   433,   438,   457,   474,   464,   340,   476,   477,   380,
+     475,   390,   391,   392,   387,   389,   354,   355,   358,   359,
+     393,   394,   360,   361,   397,   396,   395,   362,   364,   363,
+     398,   378,   378,   433,   385,   385,   505,   375,   375,   385,
+     385,   437,   375,   437,   383,   375,   377,   380,   484,   365,
+     366,   367,   368,   369,   370,   371,   372,   373,   374,   384,
+     436,   382,   385,   380,   481,   494,   498,   503,   478,   384,
+     478,   479,   478,   474,   340,   376,   412,   437,   340,   435,
+     420,   380,   476,   465,   382,   385,   420,   420,   420,   422,
+     422,   423,   423,   424,   424,   424,   424,   425,   425,   426,
+     427,   428,   429,   430,   431,   434,   378,   481,   506,   437,
+     385,   437,   383,   504,   340,   516,   517,   491,   435,   435,
+     478,   380,   382,   380,   378,   385,   477,   437,   339,   480,
+     492,   507,   376,   376,   437,   452,   459,   496,   375,   378,
+     382,   485,   380,   478,   383,   375,   496,   508,   509,   487,
+     488,   489,   495,   499,   340,   376,   438,   378,   517,   380,
+     435,   437,   385,   376,    25,   483,   482,   379,   384,   482,
+     486,   490,   376,   376,   437,   486,   487,   491,   500,   478,
+     385,   380
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint16 yyr1[] =
 {
-       0,   407,   408,   409,   409,   409,   409,   409,   409,   409,
-     409,   409,   409,   409,   409,   409,   409,   410,   410,   410,
-     410,   410,   410,   411,   412,   413,   414,   414,   415,   415,
-     416,   416,   417,   418,   418,   418,   419,   419,   419,   419,
-     420,   420,   420,   420,   421,   421,   421,   421,   422,   422,
-     422,   423,   423,   423,   424,   424,   424,   424,   424,   425,
-     425,   425,   426,   426,   427,   427,   428,   428,   429,   429,
-     430,   430,   431,   431,   432,   433,   432,   434,   434,   435,
-     435,   435,   435,   435,   435,   435,   435,   435,   435,   435,
-     436,   436,   437,   438,   438,   438,   438,   438,   438,   438,
-     438,   438,   440,   439,   441,   441,   442,   443,   443,   444,
-     444,   445,   446,   446,   447,   447,   447,   447,   448,   449,
-     449,   449,   449,   449,   450,   450,   450,   450,   450,   451,
-     451,   452,   453,   453,   453,   453,   453,   453,   453,   453,
-     454,   455,   455,   456,   456,   456,   457,   458,   458,   459,
-     459,   459,   459,   459,   459,   459,   460,   460,   460,   460,
-     460,   460,   460,   460,   460,   460,   460,   460,   460,   460,
-     460,   460,   460,   460,   460,   460,   460,   460,   460,   460,
-     460,   460,   460,   460,   460,   461,   462,   462,   463,   463,
-     464,   464,   464,   464,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   465,   465,   465,   465,   465,   465,   465,   465,   465,
-     465,   466,   466,   466,   468,   467,   469,   467,   470,   470,
-     471,   471,   472,   472,   473,   473,   474,   474,   474,   475,
-     475,   476,   477,   477,   478,   478,   478,   478,   478,   478,
-     478,   479,   480,   481,   479,   482,   482,   484,   483,   485,
-     483,   486,   486,   487,   487,   488,   488,   489,   489,   490,
-     491,   491,   492,   492,   493,   493,   495,   494,   496,   496,
-     497,   497,   498,   498,   500,   499,   501,   499,   502,   499,
-     503,   503,   504,   504,   505,   505,   506,   506,   506,   506,
-     506,   507,   507,   508,   508,   508,   510,   509,   511,   512,
-     512,   513,   513
+       0,   408,   409,   410,   410,   410,   410,   410,   410,   410,
+     410,   410,   410,   410,   410,   410,   410,   411,   411,   411,
+     411,   411,   411,   412,   413,   414,   415,   415,   416,   416,
+     417,   417,   418,   419,   419,   419,   420,   420,   420,   420,
+     421,   421,   421,   421,   422,   422,   422,   422,   423,   423,
+     423,   424,   424,   424,   425,   425,   425,   425,   425,   426,
+     426,   426,   427,   427,   428,   428,   429,   429,   430,   430,
+     431,   431,   432,   432,   433,   434,   433,   435,   435,   436,
+     436,   436,   436,   436,   436,   436,   436,   436,   436,   436,
+     437,   437,   438,   439,   439,   439,   439,   439,   439,   439,
+     439,   439,   441,   440,   442,   442,   443,   444,   444,   445,
+     445,   446,   447,   447,   448,   448,   448,   448,   449,   450,
+     450,   450,   450,   450,   451,   451,   451,   451,   451,   452,
+     452,   453,   454,   454,   454,   454,   454,   454,   454,   454,
+     455,   456,   456,   457,   457,   457,   458,   459,   459,   460,
+     460,   460,   460,   460,   460,   460,   461,   461,   461,   461,
+     461,   461,   461,   461,   461,   461,   461,   461,   461,   461,
+     461,   461,   461,   461,   461,   461,   461,   461,   461,   461,
+     461,   461,   461,   461,   461,   462,   463,   463,   464,   464,
+     465,   465,   465,   465,   466,   466,   467,   468,   468,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   469,   469,   469,
+     469,   469,   469,   469,   469,   469,   469,   470,   470,   470,
+     472,   471,   473,   471,   474,   474,   475,   475,   476,   476,
+     477,   477,   478,   478,   478,   479,   479,   480,   481,   481,
+     482,   482,   482,   482,   482,   482,   482,   483,   484,   485,
+     483,   486,   486,   488,   487,   489,   487,   490,   490,   491,
+     491,   492,   492,   493,   493,   494,   495,   495,   496,   496,
+     497,   497,   499,   498,   500,   500,   501,   501,   502,   502,
+     504,   503,   505,   503,   506,   503,   507,   507,   508,   508,
+     509,   509,   510,   510,   510,   510,   510,   511,   511,   512,
+     512,   512,   514,   513,   515,   516,   516,   517,   517
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -3416,8 +3429,9 @@ static const yytype_uint8 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,     4,     1,     1,     3,     1,     2,
-       2,     3,     3,     4,     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,     1,     1,     1,     1,     1,     1,
@@ -3446,16 +3460,15 @@ static const yytype_uint8 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,     0,     6,     0,     5,     1,     2,
-       3,     4,     1,     3,     1,     2,     1,     3,     4,     1,
-       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     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,     1,     2,     1,     1,     1,     0,     3,     5,     1,
-       3,     1,     4
+       0,     6,     0,     5,     1,     2,     3,     4,     1,     3,
+       1,     2,     1,     3,     4,     1,     3,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     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,     1,     2,     1,
+       1,     1,     0,     3,     5,     1,     3,     1,     4
 };
 
 
@@ -4138,250 +4151,250 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-#line 296 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 302 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
     }
-#line 4146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 3:
-#line 302 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 308 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 4:
-#line 305 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 5:
-#line 309 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 315 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 6:
-#line 313 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 7:
-#line 316 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4189 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 8:
-#line 320 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 326 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 9:
-#line 324 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 10:
-#line 328 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 334 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 11:
-#line 332 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 338 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 12:
-#line 336 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 4233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 13:
-#line 339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 345 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4242 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 14:
-#line 343 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 349 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 15:
-#line 347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 353 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 16:
-#line 350 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 356 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
     }
-#line 4269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 17:
-#line 358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 18:
-#line 361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 367 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 19:
-#line 364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 370 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 20:
-#line 367 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 373 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
     }
-#line 4301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 21:
-#line 370 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 376 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 22:
-#line 375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 381 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 23:
-#line 383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 24:
-#line 390 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
         delete (yyvsp[0].interm).function;
     }
-#line 4339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 25:
-#line 397 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 26:
-#line 403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 27:
-#line 407 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 413 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 28:
-#line 414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 29:
-#line 417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 423 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 30:
-#line 423 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 429 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -4389,11 +4402,11 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-1].interm).function;
         (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4393 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 31:
-#line 430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 436 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -4401,29 +4414,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 4405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 32:
-#line 440 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 446 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 33:
-#line 448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 454 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 34:
-#line 453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 459 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //
         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
@@ -4451,50 +4464,50 @@ yyreduce:
             (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
         }
     }
-#line 4455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 35:
-#line 480 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 486 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 36:
-#line 488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 37:
-#line 494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 500 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 38:
-#line 498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 504 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 39:
-#line 502 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 508 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm).op != EOpNull) {
             char errorOp[2] = {0, 0};
@@ -4511,179 +4524,179 @@ yyreduce:
                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
         }
     }
-#line 4515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 40:
-#line 522 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
-#line 4521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 41:
-#line 523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
-#line 4527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 42:
-#line 524 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 530 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
-#line 4533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 43:
-#line 525 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 531 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
               parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
-#line 4540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 44:
-#line 531 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 537 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 45:
-#line 532 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 46:
-#line 537 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 47:
-#line 542 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 48:
-#line 551 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 557 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 49:
-#line 552 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 50:
-#line 557 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 563 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 51:
-#line 565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 571 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 52:
-#line 566 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 53:
-#line 572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 578 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 54:
-#line 581 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 55:
-#line 582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 588 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 56:
-#line 587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 57:
-#line 592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 58:
-#line 597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 603 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 59:
-#line 605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 60:
-#line 606 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
@@ -4692,11 +4705,11 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 61:
-#line 614 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 620 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
@@ -4705,124 +4718,124 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 62:
-#line 625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 631 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 63:
-#line 626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 64:
-#line 635 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 641 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4745 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 65:
-#line 636 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 66:
-#line 645 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 651 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 67:
-#line 646 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 68:
-#line 655 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 69:
-#line 656 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 70:
-#line 664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 670 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 71:
-#line 665 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 671 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 72:
-#line 673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 679 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4811 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 73:
-#line 674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 680 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 4808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 74:
-#line 682 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4827 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 75:
-#line 683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 689 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 4822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 76:
-#line 686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 692 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         --parseContext.controlFlowNestingLevel;
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
@@ -4835,17 +4848,17 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 4839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 77:
-#line 701 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 78:
-#line 702 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
         parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
@@ -4859,119 +4872,119 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
         }
     }
-#line 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 79:
-#line 718 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 724 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
-#line 4872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 80:
-#line 722 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 728 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
-#line 4881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 81:
-#line 726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
-#line 4890 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 82:
-#line 730 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpModAssign;
     }
-#line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 83:
-#line 735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 741 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
-#line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 84:
-#line 739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 745 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
-#line 4918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 85:
-#line 743 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 749 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
-#line 4927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 86:
-#line 747 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 753 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
-#line 4936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 87:
-#line 751 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 757 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
-#line 4945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 88:
-#line 755 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 761 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
-#line 4954 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 89:
-#line 759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 765 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
-#line 4963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 90:
-#line 766 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 91:
-#line 769 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 775 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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);
@@ -4980,40 +4993,40 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 4984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 92:
-#line 780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 786 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 93:
-#line 787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 793 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 94:
-#line 792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 95:
-#line 797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 803 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
 
@@ -5022,75 +5035,75 @@ yyreduce:
         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
         (yyval.interm.intermNode) = 0;
     }
-#line 5026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 96:
-#line 805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 811 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
         (yyval.interm.intermNode) = 0;
     }
-#line 5035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 97:
-#line 809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 815 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 5044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 98:
-#line 813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 819 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
         (yyval.interm.intermNode) = 0;
     }
-#line 5053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 99:
-#line 817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 823 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 100:
-#line 822 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 101:
-#line 827 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 833 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5084 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 102:
-#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
-#line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 103:
-#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         --parseContext.structNestingLevel;
         parseContext.blockName = (yyvsp[-4].lex).string;
@@ -5100,54 +5113,54 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
     }
-#line 5104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 104:
-#line 847 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 853 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 105:
-#line 851 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 857 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 106:
-#line 858 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 864 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 5131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 107:
-#line 865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 871 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 108:
-#line 868 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 109:
-#line 875 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 881 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // Add the parameter
         (yyval.interm.function) = (yyvsp[-1].interm.function);
@@ -5156,11 +5169,11 @@ yyreduce:
         else
             delete (yyvsp[0].interm).param.type;
     }
-#line 5160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 110:
-#line 883 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 889 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //
         // Only first parameter of one-parameter functions can be void
@@ -5178,11 +5191,11 @@ yyreduce:
             (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
         }
     }
-#line 5182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 111:
-#line 903 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 909 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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",
@@ -5202,11 +5215,11 @@ yyreduce:
         function = new TFunction((yyvsp[-1].lex).string, type);
         (yyval.interm.function) = function;
     }
-#line 5206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 112:
-#line 926 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 932 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5222,11 +5235,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 113:
-#line 941 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 947 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5246,11 +5259,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 114:
-#line 966 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 972 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5262,11 +5275,11 @@ yyreduce:
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
 
     }
-#line 5266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 115:
-#line 977 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 983 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5274,11 +5287,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 5278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 116:
-#line 987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 993 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5289,11 +5302,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 5293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 117:
-#line 997 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1003 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5301,118 +5314,118 @@ 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 5305 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 118:
-#line 1007 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1013 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 119:
-#line 1016 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1022 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 5324 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 120:
-#line 1019 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1025 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-2].interm);
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
     }
-#line 5333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 121:
-#line 1023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1029 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-3].interm);
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
     }
-#line 5342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 122:
-#line 1027 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1033 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 123:
-#line 1032 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 124:
-#line 1040 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1046 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[0].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
     }
-#line 5372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 125:
-#line 1045 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1051 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5395 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 126:
-#line 1050 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1056 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 127:
-#line 1055 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1061 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 128:
-#line 1060 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1066 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5412 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 129:
-#line 1069 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1075 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
 
@@ -5424,11 +5437,11 @@ yyreduce:
 
         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
     }
-#line 5428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 130:
-#line 1080 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1086 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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));
@@ -5453,22 +5466,22 @@ yyreduce:
              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
             (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 131:
-#line 1107 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 132:
-#line 1116 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1122 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
@@ -5476,11 +5489,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 133:
-#line 1123 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1129 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
@@ -5488,11 +5501,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.flat = true;
     }
-#line 5492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 134:
-#line 1130 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1136 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
 #ifdef NV_EXTENSIONS
@@ -5504,11 +5517,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nopersp = true;
     }
-#line 5508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 135:
-#line 1141 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1147 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
@@ -5518,11 +5531,11 @@ yyreduce:
         (yyval.interm.type).qualifier.explicitInterp = true;
 #endif
     }
-#line 5522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 136:
-#line 1150 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1156 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
@@ -5533,11 +5546,11 @@ yyreduce:
         (yyval.interm.type).qualifier.pervertexNV = true;
 #endif
     }
-#line 5537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 137:
-#line 1160 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1166 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         // No need for profile version or extension check. Shader stage already checks both.
@@ -5550,11 +5563,11 @@ yyreduce:
         (yyval.interm.type).qualifier.perPrimitiveNV = true;
 #endif
     }
-#line 5554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 138:
-#line 1172 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1178 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         // No need for profile version or extension check. Shader stage already checks both.
@@ -5564,11 +5577,11 @@ yyreduce:
         (yyval.interm.type).qualifier.perViewNV = true;
 #endif
     }
-#line 5568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 139:
-#line 1181 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1187 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         // No need for profile version or extension check. Shader stage already checks both.
@@ -5578,84 +5591,84 @@ yyreduce:
         (yyval.interm.type).qualifier.perTaskNV = true;
 #endif
     }
-#line 5582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 140:
-#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1199 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
     }
-#line 5590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 141:
-#line 1199 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1205 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 142:
-#line 1202 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1208 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 143:
-#line 1209 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
     }
-#line 5617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 144:
-#line 1213 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1219 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 145:
-#line 1217 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { // 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 5636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 146:
-#line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1231 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 147:
-#line 1234 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1240 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 148:
-#line 1237 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         if ((yyval.interm.type).basicType == EbtVoid)
@@ -5664,80 +5677,80 @@ 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 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 149:
-#line 1248 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 150:
-#line 1251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 151:
-#line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 152:
-#line 1258 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1264 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5702 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 153:
-#line 1262 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1268 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 154:
-#line 1266 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1272 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 155:
-#line 1270 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 156:
-#line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1282 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 157:
-#line 1280 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1286 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
@@ -5750,11 +5763,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 158:
-#line 1292 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1298 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
@@ -5769,43 +5782,43 @@ yyreduce:
         else
             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 159:
-#line 1306 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1312 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqInOut;
     }
-#line 5783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 160:
-#line 1311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1317 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5807 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 161:
-#line 1317 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 162:
-#line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1329 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
@@ -5813,52 +5826,52 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.centroid = true;
     }
-#line 5817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 163:
-#line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1336 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 5828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 164:
-#line 1336 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.sample = true;
     }
-#line 5838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5851 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 165:
-#line 1341 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqUniform;
     }
-#line 5848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 166:
-#line 1346 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1352 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqBuffer;
     }
-#line 5858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 167:
-#line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
@@ -5869,11 +5882,11 @@ yyreduce:
         (yyval.interm.type).qualifier.storage = EvqHitAttrNV;
 #endif
     }
-#line 5873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 168:
-#line 1361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1367 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
@@ -5884,11 +5897,11 @@ yyreduce:
         (yyval.interm.type).qualifier.storage = EvqPayloadNV;
 #endif
     }
-#line 5888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 169:
-#line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1377 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
@@ -5899,11 +5912,11 @@ yyreduce:
         (yyval.interm.type).qualifier.storage = EvqPayloadInNV;
 #endif
     }
-#line 5903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 170:
-#line 1381 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1387 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
@@ -5914,11 +5927,11 @@ yyreduce:
         (yyval.interm.type).qualifier.storage = EvqCallableDataNV;
 #endif
     }
-#line 5918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 171:
-#line 1391 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1397 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
@@ -5928,11 +5941,11 @@ yyreduce:
         (yyval.interm.type).qualifier.storage = EvqCallableDataInNV;
 #endif
     }
-#line 5932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 172:
-#line 1400 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1406 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
@@ -5945,1703 +5958,1753 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqShared;
     }
-#line 5949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 173:
-#line 1412 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
-#line 5958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5971 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 174:
-#line 1416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5981 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 175:
-#line 1421 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 176:
-#line 1426 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1432 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 177:
-#line 1431 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1437 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 5998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 178:
-#line 1436 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1442 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 6008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 179:
-#line 1441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1447 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.volatil = true;
     }
-#line 6017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 180:
-#line 1445 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1451 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.restrict = true;
     }
-#line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 181:
-#line 1449 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.readonly = true;
     }
-#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 182:
-#line 1453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1459 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.writeonly = true;
     }
-#line 6044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 183:
-#line 1457 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 184:
-#line 1463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1469 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 185:
-#line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1478 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nonUniform = true;
     }
-#line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 186:
-#line 1479 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1485 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // TODO
     }
-#line 6083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 187:
-#line 1482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // 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 6093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 188:
-#line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1496 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
-        (yyval.interm.type) = (yyvsp[0].interm.type);
+        (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 6102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 189:
-#line 1494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1501 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
-        (yyval.interm.type) = (yyvsp[-1].interm.type);
+        (yyval.interm.type) = (yyvsp[-2].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
+        (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters);
         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
     }
-#line 6113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 190:
-#line 1503 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 6123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 191:
+#line 1516 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm).loc = (yyvsp[-2].lex).loc;
+        (yyval.interm).arraySizes = new TArraySizes;
+
+        TArraySize size;
+        parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
+        (yyval.interm).arraySizes->addInnerSize(size);
+    }
+#line 6151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 192:
+#line 1524 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm) = (yyvsp[-2].interm);
+        (yyval.interm).arraySizes->addInnerSize();
+    }
+#line 6160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 193:
+#line 1528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm) = (yyvsp[-3].interm);
+
+        TArraySize size;
+        parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
+        (yyval.interm).arraySizes->addInnerSize(size);
+    }
+#line 6172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 194:
+#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
+    }
+#line 6180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 195:
+#line 1541 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.typeParameters) = 0;
+    }
+#line 6188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 191:
-#line 1508 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 196:
+#line 1547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
-        (yyval.interm).loc = (yyvsp[-2].lex).loc;
-        (yyval.interm).arraySizes = new TArraySizes;
-
-        TArraySize size;
-        parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
-        (yyval.interm).arraySizes->addInnerSize(size);
+        (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
     }
-#line 6136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 192:
-#line 1516 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 197:
+#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
-        (yyval.interm) = (yyvsp[-2].interm);
-        (yyval.interm).arraySizes->addInnerSize();
+        (yyval.interm.typeParameters) = new TArraySizes;
+
+        TArraySize size;
+        parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
+        (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 193:
-#line 1520 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 198:
+#line 1560 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
-        (yyval.interm) = (yyvsp[-3].interm);
+        (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
 
         TArraySize size;
-        parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
-        (yyval.interm).arraySizes->addInnerSize(size);
+        parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
+        (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 194:
-#line 1530 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 199:
+#line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
-#line 6166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 195:
-#line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 200:
+#line 1574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 6175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 196:
-#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 201:
+#line 1578 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 6185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 197:
-#line 1543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 202:
+#line 1583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 198:
-#line 1548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 203:
+#line 1588 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 199:
-#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 204:
+#line 1593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 200:
-#line 1558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 205:
+#line 1598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 6224 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 201:
-#line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 206:
+#line 1602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 202:
-#line 1567 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 207:
+#line 1607 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 203:
-#line 1572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 208:
+#line 1612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 204:
-#line 1577 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 209:
+#line 1617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 205:
-#line 1582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 210:
+#line 1622 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 206:
-#line 1587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 211:
+#line 1627 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6284 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 207:
-#line 1592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 212:
+#line 1632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 208:
-#line 1597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 213:
+#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 209:
-#line 1602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 214:
+#line 1642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 210:
-#line 1607 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 215:
+#line 1647 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
     }
-#line 6323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 211:
-#line 1611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 216:
+#line 1651 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 6333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 212:
-#line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 217:
+#line 1656 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 6343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 213:
-#line 1621 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 218:
+#line 1661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 6353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 214:
-#line 1626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 219:
+#line 1666 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 6364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6427 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 215:
-#line 1632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 220:
+#line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 6375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 216:
-#line 1638 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 221:
+#line 1678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 217:
-#line 1644 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 222:
+#line 1684 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 218:
-#line 1650 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 223:
+#line 1690 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 219:
-#line 1656 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 224:
+#line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 220:
-#line 1662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 225:
+#line 1702 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 221:
-#line 1668 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 226:
+#line 1708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 222:
-#line 1674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 227:
+#line 1714 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 223:
-#line 1680 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 228:
+#line 1720 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 224:
-#line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 229:
+#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 225:
-#line 1692 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 230:
+#line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6548 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 226:
-#line 1698 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 231:
+#line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(2);
     }
-#line 6495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 227:
-#line 1703 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 232:
+#line 1743 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(3);
     }
-#line 6505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 228:
-#line 1708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 233:
+#line 1748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(4);
     }
-#line 6515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 229:
-#line 1713 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 234:
+#line 1753 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 6525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 230:
-#line 1718 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 235:
+#line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 6535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 231:
-#line 1723 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 236:
+#line 1763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 6545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 232:
-#line 1728 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 237:
+#line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 233:
-#line 1734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 238:
+#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 234:
-#line 1740 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 239:
+#line 1780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 235:
-#line 1746 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 240:
+#line 1786 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 236:
-#line 1752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 241:
+#line 1792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 237:
-#line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 242:
+#line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 238:
-#line 1764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 243:
+#line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 239:
-#line 1770 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 244:
+#line 1810 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 240:
-#line 1776 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 245:
+#line 1816 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 241:
-#line 1782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 246:
+#line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 242:
-#line 1788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 247:
+#line 1828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 243:
-#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 248:
+#line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 244:
-#line 1800 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 249:
+#line 1840 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 245:
-#line 1806 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 250:
+#line 1846 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 246:
-#line 1812 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 251:
+#line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 247:
-#line 1818 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 252:
+#line 1858 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 248:
-#line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 253:
+#line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 249:
-#line 1830 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 254:
+#line 1870 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 250:
-#line 1836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 255:
+#line 1876 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 251:
-#line 1842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 256:
+#line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6765 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 252:
-#line 1848 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 257:
+#line 1888 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 253:
-#line 1854 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 258:
+#line 1894 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 254:
-#line 1860 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 259:
+#line 1900 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6861 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 255:
-#line 1866 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 260:
+#line 1906 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 256:
-#line 1872 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 261:
+#line 1912 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 257:
-#line 1878 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 262:
+#line 1918 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 258:
-#line 1884 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 263:
+#line 1924 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 6842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 259:
-#line 1890 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 264:
+#line 1930 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 6852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 260:
-#line 1895 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 265:
+#line 1935 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 6862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 261:
-#line 1900 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 266:
+#line 1940 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 6872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 262:
-#line 1905 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 267:
+#line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 6882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 263:
-#line 1910 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 268:
+#line 1950 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 6892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 264:
-#line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 269:
+#line 1955 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 6902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 265:
-#line 1920 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 270:
+#line 1960 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 6912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 266:
-#line 1925 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 271:
+#line 1965 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 6922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 267:
-#line 1930 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 272:
+#line 1970 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 6932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 268:
-#line 1935 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 273:
+#line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 6942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 269:
-#line 1940 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 274:
+#line 1980 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 6952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 270:
-#line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 275:
+#line 1985 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 6962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 271:
-#line 1950 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 276:
+#line 1990 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 6973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 272:
-#line 1956 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 277:
+#line 1996 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 6984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 273:
-#line 1962 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 278:
+#line 2002 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 6995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 274:
-#line 1968 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 279:
+#line 2008 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 275:
-#line 1974 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 280:
+#line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 276:
-#line 1980 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 281:
+#line 2020 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 277:
-#line 1986 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 282:
+#line 2026 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 278:
-#line 1992 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 283:
+#line 2032 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7113 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 279:
-#line 1998 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 284:
+#line 2038 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7124 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 280:
-#line 2004 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 285:
+#line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 281:
-#line 2010 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 286:
+#line 2050 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 282:
-#line 2016 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 287:
+#line 2056 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 283:
-#line 2022 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 288:
+#line 2062 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 284:
-#line 2028 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 289:
+#line 2068 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 285:
-#line 2034 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 290:
+#line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 286:
-#line 2040 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 291:
+#line 2080 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 287:
-#line 2046 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 292:
+#line 2086 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 288:
-#line 2052 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 293:
+#line 2092 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 289:
-#line 2058 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 294:
+#line 2098 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 290:
-#line 2064 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 295:
+#line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 291:
-#line 2070 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 296:
+#line 2110 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 292:
-#line 2076 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 297:
+#line 2116 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 293:
-#line 2082 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 298:
+#line 2122 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7278 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 294:
-#line 2088 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 299:
+#line 2128 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 295:
-#line 2094 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 300:
+#line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 296:
-#line 2100 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 301:
+#line 2140 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 297:
-#line 2106 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 302:
+#line 2146 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 298:
-#line 2112 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 303:
+#line 2152 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7270 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 299:
-#line 2118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 304:
+#line 2158 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7344 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 300:
-#line 2124 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 305:
+#line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 301:
-#line 2130 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 306:
+#line 2170 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 302:
-#line 2136 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 307:
+#line 2176 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7314 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 303:
-#line 2142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 308:
+#line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 304:
-#line 2148 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 309:
+#line 2188 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 305:
-#line 2154 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 310:
+#line 2194 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 306:
-#line 2160 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 311:
+#line 2200 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 307:
-#line 2166 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 312:
+#line 2206 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 308:
-#line 2172 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 313:
+#line 2212 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7380 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7443 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 309:
-#line 2178 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 314:
+#line 2218 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 310:
-#line 2184 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 315:
+#line 2224 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 311:
-#line 2190 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 316:
+#line 2230 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 312:
-#line 2196 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 317:
+#line 2236 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 313:
-#line 2202 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 318:
+#line 2242 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7435 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 314:
-#line 2208 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 319:
+#line 2248 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 315:
-#line 2214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 320:
+#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 316:
-#line 2220 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 321:
+#line 2260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 317:
-#line 2226 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 322:
+#line 2266 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 318:
-#line 2232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 323:
+#line 2272 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 319:
-#line 2238 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 324:
+#line 2278 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef NV_EXTENSIONS
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStructNV;
 #endif
     }
-#line 7501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 320:
-#line 2244 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 325:
+#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 7511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 321:
-#line 2249 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 326:
+#line 2289 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
     }
-#line 7521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 322:
-#line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 327:
+#line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
     }
-#line 7531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 323:
-#line 2259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 328:
+#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
     }
-#line 7541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 324:
-#line 2264 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 329:
+#line 2304 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
     }
-#line 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7614 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 325:
-#line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 330:
+#line 2309 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 326:
-#line 2274 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 331:
+#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 327:
-#line 2279 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 332:
+#line 2319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 328:
-#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 333:
+#line 2324 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7654 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 329:
-#line 2289 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 334:
+#line 2329 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7664 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 330:
-#line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 335:
+#line 2334 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 331:
-#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 336:
+#line 2339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 332:
-#line 2304 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 337:
+#line 2344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 333:
-#line 2309 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 338:
+#line 2349 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 334:
-#line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 339:
+#line 2354 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7650,11 +7713,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
 #endif
     }
-#line 7654 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 335:
-#line 2322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 340:
+#line 2362 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7663,11 +7726,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
 #endif
     }
-#line 7667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 336:
-#line 2330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 341:
+#line 2370 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7676,11 +7739,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
 #endif
     }
-#line 7680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 337:
-#line 2338 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 342:
+#line 2378 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7689,11 +7752,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
 #endif
     }
-#line 7693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 338:
-#line 2346 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 343:
+#line 2386 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7702,11 +7765,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
 #endif
     }
-#line 7706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 339:
-#line 2354 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 344:
+#line 2394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7715,11 +7778,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
 #endif
     }
-#line 7719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 340:
-#line 2362 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 345:
+#line 2402 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7728,11 +7791,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
 #endif
     }
-#line 7732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 341:
-#line 2370 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 346:
+#line 2410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7741,11 +7804,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 7745 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 342:
-#line 2378 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 347:
+#line 2418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7754,11 +7817,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 7758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 343:
-#line 2386 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 348:
+#line 2426 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7767,11 +7830,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
 #endif
     }
-#line 7771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 344:
-#line 2394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 349:
+#line 2434 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7780,11 +7843,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
 #endif
     }
-#line 7784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 345:
-#line 2402 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 350:
+#line 2442 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7793,11 +7856,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 7797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7860 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 346:
-#line 2410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 351:
+#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7806,171 +7869,171 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
 #endif
     }
-#line 7810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 347:
-#line 2418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 352:
+#line 2458 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D);
     }
-#line 7820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 348:
-#line 2423 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 353:
+#line 2463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D);
     }
-#line 7830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7893 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 349:
-#line 2428 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 354:
+#line 2468 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd3D);
     }
-#line 7840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 350:
-#line 2433 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 355:
+#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube);
     }
-#line 7850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 351:
-#line 2438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 356:
+#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7860 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 352:
-#line 2443 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 357:
+#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 353:
-#line 2448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 358:
+#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7943 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 354:
-#line 2453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 359:
+#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D);
     }
-#line 7890 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 355:
-#line 2458 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 360:
+#line 2498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D);
     }
-#line 7900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 356:
-#line 2463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 361:
+#line 2503 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd3D);
     }
-#line 7910 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 357:
-#line 2468 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 362:
+#line 2508 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube);
     }
-#line 7920 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 358:
-#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 363:
+#line 2513 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 359:
-#line 2478 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 364:
+#line 2518 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 360:
-#line 2483 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 365:
+#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 361:
-#line 2488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 366:
+#line 2528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
     }
-#line 7960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 362:
-#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 367:
+#line 2533 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 7970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 363:
-#line 2498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 368:
+#line 2538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7979,11 +8042,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
 #endif
     }
-#line 7983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 364:
-#line 2506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 369:
+#line 2546 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7992,41 +8055,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
 #endif
     }
-#line 7996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 365:
-#line 2514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 370:
+#line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdRect);
     }
-#line 8006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 366:
-#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 371:
+#line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdRect);
     }
-#line 8016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 367:
-#line 2524 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 372:
+#line 2564 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
     }
-#line 8026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 368:
-#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 373:
+#line 2569 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -8035,41 +8098,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 8039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 369:
-#line 2537 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 374:
+#line 2577 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
     }
-#line 8049 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 370:
-#line 2542 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 375:
+#line 2582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
     }
-#line 8059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 371:
-#line 2547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 376:
+#line 2587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 372:
-#line 2552 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 377:
+#line 2592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -8078,41 +8141,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 8082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 373:
-#line 2560 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 378:
+#line 2600 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 374:
-#line 2565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 379:
+#line 2605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 375:
-#line 2570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 380:
+#line 2610 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 376:
-#line 2575 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 381:
+#line 2615 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -8121,61 +8184,61 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 8125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 377:
-#line 2583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 382:
+#line 2623 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 378:
-#line 2588 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 383:
+#line 2628 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 379:
-#line 2593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 384:
+#line 2633 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(false);
     }
-#line 8155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 380:
-#line 2598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 385:
+#line 2638 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(true);
     }
-#line 8165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8228 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 381:
-#line 2603 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 386:
+#line 2643 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
     }
-#line 8175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 382:
-#line 2608 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 387:
+#line 2648 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8184,21 +8247,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
 #endif
     }
-#line 8188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 383:
-#line 2616 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 388:
+#line 2656 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
     }
-#line 8198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 384:
-#line 2621 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 389:
+#line 2661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8207,21 +8270,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
 #endif
     }
-#line 8211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8274 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 385:
-#line 2629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 390:
+#line 2669 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
     }
-#line 8221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8284 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 386:
-#line 2634 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 391:
+#line 2674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8230,21 +8293,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
 #endif
     }
-#line 8234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 387:
-#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 392:
+#line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
     }
-#line 8244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 388:
-#line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 393:
+#line 2687 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8253,21 +8316,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
 #endif
     }
-#line 8257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 389:
-#line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 394:
+#line 2695 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 390:
-#line 2660 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 395:
+#line 2700 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8276,21 +8339,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 8280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 391:
-#line 2668 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 396:
+#line 2708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 392:
-#line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 397:
+#line 2713 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8299,21 +8362,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 8303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 393:
-#line 2681 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 398:
+#line 2721 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 394:
-#line 2686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 399:
+#line 2726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8322,161 +8385,161 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 8326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 395:
-#line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 400:
+#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
     }
-#line 8336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 396:
-#line 2699 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 401:
+#line 2739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
     }
-#line 8346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 397:
-#line 2704 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 402:
+#line 2744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
     }
-#line 8356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 398:
-#line 2709 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 403:
+#line 2749 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
     }
-#line 8366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8429 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 399:
-#line 2714 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 404:
+#line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 400:
-#line 2719 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 405:
+#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 401:
-#line 2724 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 406:
+#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8459 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 402:
-#line 2729 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 407:
+#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
     }
-#line 8406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 403:
-#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 408:
+#line 2774 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
     }
-#line 8416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 404:
-#line 2739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 409:
+#line 2779 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
     }
-#line 8426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 405:
-#line 2744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 410:
+#line 2784 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
     }
-#line 8436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 406:
-#line 2749 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 411:
+#line 2789 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 407:
-#line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 412:
+#line 2794 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 408:
-#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 413:
+#line 2799 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 409:
-#line 2764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 414:
+#line 2804 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
     }
-#line 8476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8539 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 410:
-#line 2769 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 415:
+#line 2809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8485,41 +8548,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
 #endif
     }
-#line 8489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 411:
-#line 2777 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 416:
+#line 2817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
     }
-#line 8499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 412:
-#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 417:
+#line 2822 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
     }
-#line 8509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 413:
-#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 418:
+#line 2827 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
     }
-#line 8519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 414:
-#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 419:
+#line 2832 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8528,41 +8591,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 8532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 415:
-#line 2800 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 420:
+#line 2840 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
     }
-#line 8542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 416:
-#line 2805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 421:
+#line 2845 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
     }
-#line 8552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 417:
-#line 2810 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 422:
+#line 2850 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 418:
-#line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 423:
+#line 2855 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8571,41 +8634,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 8575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 419:
-#line 2823 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 424:
+#line 2863 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 420:
-#line 2828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 425:
+#line 2868 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 421:
-#line 2833 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 426:
+#line 2873 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 422:
-#line 2838 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 427:
+#line 2878 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8614,41 +8677,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 423:
-#line 2846 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 428:
+#line 2886 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 424:
-#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 429:
+#line 2891 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 425:
-#line 2856 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 430:
+#line 2896 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
     }
-#line 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 426:
-#line 2861 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 431:
+#line 2901 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8657,41 +8720,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
 #endif
     }
-#line 8661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 427:
-#line 2869 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 432:
+#line 2909 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
     }
-#line 8671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 428:
-#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 433:
+#line 2914 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
     }
-#line 8681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 429:
-#line 2879 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 434:
+#line 2919 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
     }
-#line 8691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 430:
-#line 2884 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 435:
+#line 2924 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8700,41 +8763,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
 #endif
     }
-#line 8704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 431:
-#line 2892 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 436:
+#line 2932 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
     }
-#line 8714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 432:
-#line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 437:
+#line 2937 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
     }
-#line 8724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 433:
-#line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 438:
+#line 2942 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
     }
-#line 8734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 434:
-#line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 439:
+#line 2947 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8743,41 +8806,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
 #endif
     }
-#line 8747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 435:
-#line 2915 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 440:
+#line 2955 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
     }
-#line 8757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 436:
-#line 2920 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 441:
+#line 2960 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
     }
-#line 8767 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 437:
-#line 2925 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 442:
+#line 2965 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
     }
-#line 8777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 438:
-#line 2930 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 443:
+#line 2970 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8786,41 +8849,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
 #endif
     }
-#line 8790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 439:
-#line 2938 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 444:
+#line 2978 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
     }
-#line 8800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 440:
-#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 445:
+#line 2983 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
     }
-#line 8810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 441:
-#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 446:
+#line 2988 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
     }
-#line 8820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 442:
-#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 447:
+#line 2993 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8829,41 +8892,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
 #endif
     }
-#line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 443:
-#line 2961 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 448:
+#line 3001 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
     }
-#line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 444:
-#line 2966 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 449:
+#line 3006 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
     }
-#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 445:
-#line 2971 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 450:
+#line 3011 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
     }
-#line 8863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 446:
-#line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 451:
+#line 3016 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8872,41 +8935,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 8876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 447:
-#line 2984 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 452:
+#line 3024 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
     }
-#line 8886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 448:
-#line 2989 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 453:
+#line 3029 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
     }
-#line 8896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8959 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 449:
-#line 2994 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 454:
+#line 3034 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 450:
-#line 2999 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 455:
+#line 3039 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8915,41 +8978,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 8919 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 451:
-#line 3007 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 456:
+#line 3047 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 452:
-#line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 457:
+#line 3052 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8939 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 453:
-#line 3017 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 458:
+#line 3057 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 454:
-#line 3022 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 459:
+#line 3062 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8958,41 +9021,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 8962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 455:
-#line 3030 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 460:
+#line 3070 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 456:
-#line 3035 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 461:
+#line 3075 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 457:
-#line 3040 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 462:
+#line 3080 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 8992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 458:
-#line 3045 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 463:
+#line 3085 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -9001,41 +9064,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 9005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 459:
-#line 3053 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 464:
+#line 3093 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 460:
-#line 3058 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 465:
+#line 3098 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 461:
-#line 3063 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 466:
+#line 3103 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 462:
-#line 3068 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 467:
+#line 3108 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -9044,41 +9107,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 463:
-#line 3076 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 468:
+#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 464:
-#line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 469:
+#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 465:
-#line 3086 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 470:
+#line 3126 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 466:
-#line 3091 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 471:
+#line 3131 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -9087,75 +9150,75 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 9091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 467:
-#line 3099 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 472:
+#line 3139 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 468:
-#line 3104 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 473:
+#line 3144 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 469:
-#line 3109 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 474:
+#line 3149 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {  // 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 9122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9185 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 470:
-#line 3115 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 475:
+#line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { // 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 9133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 471:
-#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 476:
+#line 3161 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 472:
-#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 477:
+#line 3167 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 473:
-#line 3133 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 478:
+#line 3173 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
@@ -9165,11 +9228,11 @@ yyreduce:
         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
 #endif
     }
-#line 9169 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 474:
-#line 3142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 479:
+#line 3182 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
@@ -9179,65 +9242,76 @@ yyreduce:
         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
 #endif
     }
-#line 9183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 475:
-#line 3151 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 480:
+#line 3191 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 476:
-#line 3157 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 481:
+#line 3197 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 477:
-#line 3163 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 482:
+#line 3203 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 478:
-#line 3169 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 483:
+#line 3209 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 479:
-#line 3175 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 484:
+#line 3215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        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 9301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 485:
+#line 3221 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 480:
-#line 3180 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 486:
+#line 3226 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -9251,47 +9325,47 @@ yyreduce:
         } else
             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
     }
-#line 9255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9329 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 481:
-#line 3196 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 487:
+#line 3242 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 482:
-#line 3201 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 488:
+#line 3247 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9349 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 483:
-#line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 489:
+#line 3252 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 484:
-#line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 490:
+#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
-#line 9291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 485:
-#line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 491:
+#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
         parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
@@ -9303,17 +9377,17 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 9307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 486:
-#line 3225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 492:
+#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
-#line 9313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 487:
-#line 3225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 493:
+#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[-4].lex).loc);
@@ -9321,19 +9395,19 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 9325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 488:
-#line 3235 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 494:
+#line 3281 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
     }
-#line 9333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 489:
-#line 3238 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 495:
+#line 3284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
         for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
@@ -9344,11 +9418,11 @@ yyreduce:
             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
         }
     }
-#line 9348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 490:
-#line 3251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 496:
+#line 3297 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -9371,11 +9445,11 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 491:
-#line 3273 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 497:
+#line 3319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -9400,38 +9474,38 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9404 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 492:
-#line 3300 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 498:
+#line 3346 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 493:
-#line 3304 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 499:
+#line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 494:
-#line 3310 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 500:
+#line 3356 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 9431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 495:
-#line 3315 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 501:
+#line 3361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
 
@@ -9440,219 +9514,219 @@ yyreduce:
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
     }
-#line 9444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 496:
-#line 3326 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 502:
+#line 3372 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 497:
-#line 3329 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 503:
+#line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 498:
-#line 3335 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 504:
+#line 3381 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9548 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 499:
-#line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 505:
+#line 3390 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
     }
-#line 9482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 500:
-#line 3347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 506:
+#line 3393 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 9490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 501:
-#line 3353 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 507:
+#line 3399 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 502:
-#line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 508:
+#line 3403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 503:
-#line 3358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 509:
+#line 3404 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 504:
-#line 3364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 510:
+#line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 505:
-#line 3365 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 511:
+#line 3411 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 506:
-#line 3366 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 512:
+#line 3412 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 507:
-#line 3367 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 513:
+#line 3413 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 508:
-#line 3368 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 514:
+#line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 509:
-#line 3369 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 515:
+#line 3415 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 510:
-#line 3370 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 516:
+#line 3416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 511:
-#line 3374 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 517:
+#line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 512:
-#line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 518:
+#line 3421 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
-#line 9565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 513:
-#line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 519:
+#line 3425 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
-#line 9574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 514:
-#line 3383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 520:
+#line 3429 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 515:
-#line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 521:
+#line 3437 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9664 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 516:
-#line 3392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 522:
+#line 3438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 517:
-#line 3396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 523:
+#line 3442 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 518:
-#line 3399 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 524:
+#line 3445 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9687 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 519:
-#line 3403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 525:
+#line 3449 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 520:
-#line 3408 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 526:
+#line 3454 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 521:
-#line 3417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 527:
+#line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 522:
-#line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 528:
+#line 3466 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 523:
-#line 3428 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 529:
+#line 3474 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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 ||
@@ -9661,11 +9735,11 @@ yyreduce:
             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
         }
     }
-#line 9665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 524:
-#line 3436 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 530:
+#line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
@@ -9674,76 +9748,76 @@ yyreduce:
         } else
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 525:
-#line 3447 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 531:
+#line 3493 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 526:
-#line 3448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 532:
+#line 3494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
-#line 9690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 527:
-#line 3452 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 533:
+#line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 528:
-#line 3455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 534:
+#line 3501 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 529:
-#line 3461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 535:
+#line 3507 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 9716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 530:
-#line 3468 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 536:
+#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
     }
-#line 9725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 531:
-#line 3472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 537:
+#line 3518 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 9734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 532:
-#line 3480 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 538:
+#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
     }
-#line 9743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 533:
-#line 3484 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 539:
+#line 3530 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
 
@@ -9754,28 +9828,28 @@ yyreduce:
         else
             (yyval.interm.intermTypedNode) = 0;
     }
-#line 9758 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 534:
-#line 3497 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 540:
+#line 3543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 535:
-#line 3500 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 541:
+#line 3546 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 536:
-#line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 542:
+#line 3552 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -9784,11 +9858,11 @@ yyreduce:
         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
         parseContext.symbolTable.push();
     }
-#line 9788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 537:
-#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 543:
+#line 3560 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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();
@@ -9798,27 +9872,27 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 538:
-#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 544:
+#line 3572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 539:
-#line 3529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 545:
+#line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 540:
-#line 3535 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 546:
+#line 3581 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -9831,11 +9905,11 @@ yyreduce:
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
         }
     }
-#line 9835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 541:
-#line 3547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 547:
+#line 3593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -9845,28 +9919,28 @@ yyreduce:
         else
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
     }
-#line 9849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 542:
-#line 3559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 548:
+#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 543:
-#line 3562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 549:
+#line 3608 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 544:
-#line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 550:
+#line 3614 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
@@ -9875,11 +9949,11 @@ yyreduce:
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 545:
-#line 3576 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 551:
+#line 3622 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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);
@@ -9887,21 +9961,21 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 546:
-#line 3583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 552:
+#line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 547:
-#line 3588 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 553:
+#line 3634 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
@@ -9913,22 +9987,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 548:
-#line 3599 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 554:
+#line 3645 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9928 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 549:
-#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 555:
+#line 3651 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
@@ -9941,81 +10015,81 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 550:
-#line 3620 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 556:
+#line 3666 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 551:
-#line 3623 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 557:
+#line 3669 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 552:
-#line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 558:
+#line 3675 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9969 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 553:
-#line 3632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 559:
+#line 3678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = 0;
     }
-#line 9977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 554:
-#line 3638 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 560:
+#line 3684 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 9986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 555:
-#line 3642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 561:
+#line 3688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 556:
-#line 3649 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 562:
+#line 3695 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 10005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 557:
-#line 3654 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 563:
+#line 3700 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 10015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 558:
-#line 3659 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 564:
+#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -10023,83 +10097,83 @@ yyreduce:
         if (parseContext.inMain)
             parseContext.postEntryPointReturn = true;
     }
-#line 10027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 559:
-#line 3666 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 565:
+#line 3712 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 10035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 560:
-#line 3669 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 566:
+#line 3715 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
     }
-#line 10044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 561:
-#line 3678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 567:
+#line 3724 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
-#line 10053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 562:
-#line 3682 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 568:
+#line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 10064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 563:
-#line 3691 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 569:
+#line 3737 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 564:
-#line 3694 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 570:
+#line 3740 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 565:
-#line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 571:
+#line 3743 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         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 10090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 566:
-#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 572:
+#line 3751 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (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);
     }
-#line 10099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 567:
-#line 3709 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 573:
+#line 3755 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -10115,52 +10189,52 @@ yyreduce:
         (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
         (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
     }
-#line 10119 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 568:
-#line 3727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 574:
+#line 3773 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
         parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute");
     }
-#line 10128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 569:
-#line 3733 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 575:
+#line 3779 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
     }
-#line 10136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 570:
-#line 3736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 576:
+#line 3782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
     }
-#line 10144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 571:
-#line 3741 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 577:
+#line 3787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
     }
-#line 10152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 572:
-#line 3744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 578:
+#line 3790 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 10160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
 
-#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -10388,5 +10462,5 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 3748 "MachineIndependent/glslang.y" /* yacc.c:1906  */
+#line 3794 "MachineIndependent/glslang.y" /* yacc.c:1906  */
 

diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
index 6fcdd92..a467db6 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -220,235 +220,236 @@ extern int yydebug;
     F64MAT4X4 = 430,
     ATOMIC_UINT = 431,
     ACCSTRUCTNV = 432,
-    SAMPLER1D = 433,
-    SAMPLER2D = 434,
-    SAMPLER3D = 435,
-    SAMPLERCUBE = 436,
-    SAMPLER1DSHADOW = 437,
-    SAMPLER2DSHADOW = 438,
-    SAMPLERCUBESHADOW = 439,
-    SAMPLER1DARRAY = 440,
-    SAMPLER2DARRAY = 441,
-    SAMPLER1DARRAYSHADOW = 442,
-    SAMPLER2DARRAYSHADOW = 443,
-    ISAMPLER1D = 444,
-    ISAMPLER2D = 445,
-    ISAMPLER3D = 446,
-    ISAMPLERCUBE = 447,
-    ISAMPLER1DARRAY = 448,
-    ISAMPLER2DARRAY = 449,
-    USAMPLER1D = 450,
-    USAMPLER2D = 451,
-    USAMPLER3D = 452,
-    USAMPLERCUBE = 453,
-    USAMPLER1DARRAY = 454,
-    USAMPLER2DARRAY = 455,
-    SAMPLER2DRECT = 456,
-    SAMPLER2DRECTSHADOW = 457,
-    ISAMPLER2DRECT = 458,
-    USAMPLER2DRECT = 459,
-    SAMPLERBUFFER = 460,
-    ISAMPLERBUFFER = 461,
-    USAMPLERBUFFER = 462,
-    SAMPLERCUBEARRAY = 463,
-    SAMPLERCUBEARRAYSHADOW = 464,
-    ISAMPLERCUBEARRAY = 465,
-    USAMPLERCUBEARRAY = 466,
-    SAMPLER2DMS = 467,
-    ISAMPLER2DMS = 468,
-    USAMPLER2DMS = 469,
-    SAMPLER2DMSARRAY = 470,
-    ISAMPLER2DMSARRAY = 471,
-    USAMPLER2DMSARRAY = 472,
-    SAMPLEREXTERNALOES = 473,
-    SAMPLEREXTERNAL2DY2YEXT = 474,
-    F16SAMPLER1D = 475,
-    F16SAMPLER2D = 476,
-    F16SAMPLER3D = 477,
-    F16SAMPLER2DRECT = 478,
-    F16SAMPLERCUBE = 479,
-    F16SAMPLER1DARRAY = 480,
-    F16SAMPLER2DARRAY = 481,
-    F16SAMPLERCUBEARRAY = 482,
-    F16SAMPLERBUFFER = 483,
-    F16SAMPLER2DMS = 484,
-    F16SAMPLER2DMSARRAY = 485,
-    F16SAMPLER1DSHADOW = 486,
-    F16SAMPLER2DSHADOW = 487,
-    F16SAMPLER1DARRAYSHADOW = 488,
-    F16SAMPLER2DARRAYSHADOW = 489,
-    F16SAMPLER2DRECTSHADOW = 490,
-    F16SAMPLERCUBESHADOW = 491,
-    F16SAMPLERCUBEARRAYSHADOW = 492,
-    SAMPLER = 493,
-    SAMPLERSHADOW = 494,
-    TEXTURE1D = 495,
-    TEXTURE2D = 496,
-    TEXTURE3D = 497,
-    TEXTURECUBE = 498,
-    TEXTURE1DARRAY = 499,
-    TEXTURE2DARRAY = 500,
-    ITEXTURE1D = 501,
-    ITEXTURE2D = 502,
-    ITEXTURE3D = 503,
-    ITEXTURECUBE = 504,
-    ITEXTURE1DARRAY = 505,
-    ITEXTURE2DARRAY = 506,
-    UTEXTURE1D = 507,
-    UTEXTURE2D = 508,
-    UTEXTURE3D = 509,
-    UTEXTURECUBE = 510,
-    UTEXTURE1DARRAY = 511,
-    UTEXTURE2DARRAY = 512,
-    TEXTURE2DRECT = 513,
-    ITEXTURE2DRECT = 514,
-    UTEXTURE2DRECT = 515,
-    TEXTUREBUFFER = 516,
-    ITEXTUREBUFFER = 517,
-    UTEXTUREBUFFER = 518,
-    TEXTURECUBEARRAY = 519,
-    ITEXTURECUBEARRAY = 520,
-    UTEXTURECUBEARRAY = 521,
-    TEXTURE2DMS = 522,
-    ITEXTURE2DMS = 523,
-    UTEXTURE2DMS = 524,
-    TEXTURE2DMSARRAY = 525,
-    ITEXTURE2DMSARRAY = 526,
-    UTEXTURE2DMSARRAY = 527,
-    F16TEXTURE1D = 528,
-    F16TEXTURE2D = 529,
-    F16TEXTURE3D = 530,
-    F16TEXTURE2DRECT = 531,
-    F16TEXTURECUBE = 532,
-    F16TEXTURE1DARRAY = 533,
-    F16TEXTURE2DARRAY = 534,
-    F16TEXTURECUBEARRAY = 535,
-    F16TEXTUREBUFFER = 536,
-    F16TEXTURE2DMS = 537,
-    F16TEXTURE2DMSARRAY = 538,
-    SUBPASSINPUT = 539,
-    SUBPASSINPUTMS = 540,
-    ISUBPASSINPUT = 541,
-    ISUBPASSINPUTMS = 542,
-    USUBPASSINPUT = 543,
-    USUBPASSINPUTMS = 544,
-    F16SUBPASSINPUT = 545,
-    F16SUBPASSINPUTMS = 546,
-    IMAGE1D = 547,
-    IIMAGE1D = 548,
-    UIMAGE1D = 549,
-    IMAGE2D = 550,
-    IIMAGE2D = 551,
-    UIMAGE2D = 552,
-    IMAGE3D = 553,
-    IIMAGE3D = 554,
-    UIMAGE3D = 555,
-    IMAGE2DRECT = 556,
-    IIMAGE2DRECT = 557,
-    UIMAGE2DRECT = 558,
-    IMAGECUBE = 559,
-    IIMAGECUBE = 560,
-    UIMAGECUBE = 561,
-    IMAGEBUFFER = 562,
-    IIMAGEBUFFER = 563,
-    UIMAGEBUFFER = 564,
-    IMAGE1DARRAY = 565,
-    IIMAGE1DARRAY = 566,
-    UIMAGE1DARRAY = 567,
-    IMAGE2DARRAY = 568,
-    IIMAGE2DARRAY = 569,
-    UIMAGE2DARRAY = 570,
-    IMAGECUBEARRAY = 571,
-    IIMAGECUBEARRAY = 572,
-    UIMAGECUBEARRAY = 573,
-    IMAGE2DMS = 574,
-    IIMAGE2DMS = 575,
-    UIMAGE2DMS = 576,
-    IMAGE2DMSARRAY = 577,
-    IIMAGE2DMSARRAY = 578,
-    UIMAGE2DMSARRAY = 579,
-    F16IMAGE1D = 580,
-    F16IMAGE2D = 581,
-    F16IMAGE3D = 582,
-    F16IMAGE2DRECT = 583,
-    F16IMAGECUBE = 584,
-    F16IMAGE1DARRAY = 585,
-    F16IMAGE2DARRAY = 586,
-    F16IMAGECUBEARRAY = 587,
-    F16IMAGEBUFFER = 588,
-    F16IMAGE2DMS = 589,
-    F16IMAGE2DMSARRAY = 590,
-    STRUCT = 591,
-    VOID = 592,
-    WHILE = 593,
-    IDENTIFIER = 594,
-    TYPE_NAME = 595,
-    FLOATCONSTANT = 596,
-    DOUBLECONSTANT = 597,
-    INT16CONSTANT = 598,
-    UINT16CONSTANT = 599,
-    INT32CONSTANT = 600,
-    UINT32CONSTANT = 601,
-    INTCONSTANT = 602,
-    UINTCONSTANT = 603,
-    INT64CONSTANT = 604,
-    UINT64CONSTANT = 605,
-    BOOLCONSTANT = 606,
-    FLOAT16CONSTANT = 607,
-    LEFT_OP = 608,
-    RIGHT_OP = 609,
-    INC_OP = 610,
-    DEC_OP = 611,
-    LE_OP = 612,
-    GE_OP = 613,
-    EQ_OP = 614,
-    NE_OP = 615,
-    AND_OP = 616,
-    OR_OP = 617,
-    XOR_OP = 618,
-    MUL_ASSIGN = 619,
-    DIV_ASSIGN = 620,
-    ADD_ASSIGN = 621,
-    MOD_ASSIGN = 622,
-    LEFT_ASSIGN = 623,
-    RIGHT_ASSIGN = 624,
-    AND_ASSIGN = 625,
-    XOR_ASSIGN = 626,
-    OR_ASSIGN = 627,
-    SUB_ASSIGN = 628,
-    LEFT_PAREN = 629,
-    RIGHT_PAREN = 630,
-    LEFT_BRACKET = 631,
-    RIGHT_BRACKET = 632,
-    LEFT_BRACE = 633,
-    RIGHT_BRACE = 634,
-    DOT = 635,
-    COMMA = 636,
-    COLON = 637,
-    EQUAL = 638,
-    SEMICOLON = 639,
-    BANG = 640,
-    DASH = 641,
-    TILDE = 642,
-    PLUS = 643,
-    STAR = 644,
-    SLASH = 645,
-    PERCENT = 646,
-    LEFT_ANGLE = 647,
-    RIGHT_ANGLE = 648,
-    VERTICAL_BAR = 649,
-    CARET = 650,
-    AMPERSAND = 651,
-    QUESTION = 652,
-    INVARIANT = 653,
-    PRECISE = 654,
-    HIGH_PRECISION = 655,
-    MEDIUM_PRECISION = 656,
-    LOW_PRECISION = 657,
-    PRECISION = 658,
-    PACKED = 659,
-    RESOURCE = 660,
-    SUPERP = 661
+    FCOOPMATNV = 433,
+    SAMPLER1D = 434,
+    SAMPLER2D = 435,
+    SAMPLER3D = 436,
+    SAMPLERCUBE = 437,
+    SAMPLER1DSHADOW = 438,
+    SAMPLER2DSHADOW = 439,
+    SAMPLERCUBESHADOW = 440,
+    SAMPLER1DARRAY = 441,
+    SAMPLER2DARRAY = 442,
+    SAMPLER1DARRAYSHADOW = 443,
+    SAMPLER2DARRAYSHADOW = 444,
+    ISAMPLER1D = 445,
+    ISAMPLER2D = 446,
+    ISAMPLER3D = 447,
+    ISAMPLERCUBE = 448,
+    ISAMPLER1DARRAY = 449,
+    ISAMPLER2DARRAY = 450,
+    USAMPLER1D = 451,
+    USAMPLER2D = 452,
+    USAMPLER3D = 453,
+    USAMPLERCUBE = 454,
+    USAMPLER1DARRAY = 455,
+    USAMPLER2DARRAY = 456,
+    SAMPLER2DRECT = 457,
+    SAMPLER2DRECTSHADOW = 458,
+    ISAMPLER2DRECT = 459,
+    USAMPLER2DRECT = 460,
+    SAMPLERBUFFER = 461,
+    ISAMPLERBUFFER = 462,
+    USAMPLERBUFFER = 463,
+    SAMPLERCUBEARRAY = 464,
+    SAMPLERCUBEARRAYSHADOW = 465,
+    ISAMPLERCUBEARRAY = 466,
+    USAMPLERCUBEARRAY = 467,
+    SAMPLER2DMS = 468,
+    ISAMPLER2DMS = 469,
+    USAMPLER2DMS = 470,
+    SAMPLER2DMSARRAY = 471,
+    ISAMPLER2DMSARRAY = 472,
+    USAMPLER2DMSARRAY = 473,
+    SAMPLEREXTERNALOES = 474,
+    SAMPLEREXTERNAL2DY2YEXT = 475,
+    F16SAMPLER1D = 476,
+    F16SAMPLER2D = 477,
+    F16SAMPLER3D = 478,
+    F16SAMPLER2DRECT = 479,
+    F16SAMPLERCUBE = 480,
+    F16SAMPLER1DARRAY = 481,
+    F16SAMPLER2DARRAY = 482,
+    F16SAMPLERCUBEARRAY = 483,
+    F16SAMPLERBUFFER = 484,
+    F16SAMPLER2DMS = 485,
+    F16SAMPLER2DMSARRAY = 486,
+    F16SAMPLER1DSHADOW = 487,
+    F16SAMPLER2DSHADOW = 488,
+    F16SAMPLER1DARRAYSHADOW = 489,
+    F16SAMPLER2DARRAYSHADOW = 490,
+    F16SAMPLER2DRECTSHADOW = 491,
+    F16SAMPLERCUBESHADOW = 492,
+    F16SAMPLERCUBEARRAYSHADOW = 493,
+    SAMPLER = 494,
+    SAMPLERSHADOW = 495,
+    TEXTURE1D = 496,
+    TEXTURE2D = 497,
+    TEXTURE3D = 498,
+    TEXTURECUBE = 499,
+    TEXTURE1DARRAY = 500,
+    TEXTURE2DARRAY = 501,
+    ITEXTURE1D = 502,
+    ITEXTURE2D = 503,
+    ITEXTURE3D = 504,
+    ITEXTURECUBE = 505,
+    ITEXTURE1DARRAY = 506,
+    ITEXTURE2DARRAY = 507,
+    UTEXTURE1D = 508,
+    UTEXTURE2D = 509,
+    UTEXTURE3D = 510,
+    UTEXTURECUBE = 511,
+    UTEXTURE1DARRAY = 512,
+    UTEXTURE2DARRAY = 513,
+    TEXTURE2DRECT = 514,
+    ITEXTURE2DRECT = 515,
+    UTEXTURE2DRECT = 516,
+    TEXTUREBUFFER = 517,
+    ITEXTUREBUFFER = 518,
+    UTEXTUREBUFFER = 519,
+    TEXTURECUBEARRAY = 520,
+    ITEXTURECUBEARRAY = 521,
+    UTEXTURECUBEARRAY = 522,
+    TEXTURE2DMS = 523,
+    ITEXTURE2DMS = 524,
+    UTEXTURE2DMS = 525,
+    TEXTURE2DMSARRAY = 526,
+    ITEXTURE2DMSARRAY = 527,
+    UTEXTURE2DMSARRAY = 528,
+    F16TEXTURE1D = 529,
+    F16TEXTURE2D = 530,
+    F16TEXTURE3D = 531,
+    F16TEXTURE2DRECT = 532,
+    F16TEXTURECUBE = 533,
+    F16TEXTURE1DARRAY = 534,
+    F16TEXTURE2DARRAY = 535,
+    F16TEXTURECUBEARRAY = 536,
+    F16TEXTUREBUFFER = 537,
+    F16TEXTURE2DMS = 538,
+    F16TEXTURE2DMSARRAY = 539,
+    SUBPASSINPUT = 540,
+    SUBPASSINPUTMS = 541,
+    ISUBPASSINPUT = 542,
+    ISUBPASSINPUTMS = 543,
+    USUBPASSINPUT = 544,
+    USUBPASSINPUTMS = 545,
+    F16SUBPASSINPUT = 546,
+    F16SUBPASSINPUTMS = 547,
+    IMAGE1D = 548,
+    IIMAGE1D = 549,
+    UIMAGE1D = 550,
+    IMAGE2D = 551,
+    IIMAGE2D = 552,
+    UIMAGE2D = 553,
+    IMAGE3D = 554,
+    IIMAGE3D = 555,
+    UIMAGE3D = 556,
+    IMAGE2DRECT = 557,
+    IIMAGE2DRECT = 558,
+    UIMAGE2DRECT = 559,
+    IMAGECUBE = 560,
+    IIMAGECUBE = 561,
+    UIMAGECUBE = 562,
+    IMAGEBUFFER = 563,
+    IIMAGEBUFFER = 564,
+    UIMAGEBUFFER = 565,
+    IMAGE1DARRAY = 566,
+    IIMAGE1DARRAY = 567,
+    UIMAGE1DARRAY = 568,
+    IMAGE2DARRAY = 569,
+    IIMAGE2DARRAY = 570,
+    UIMAGE2DARRAY = 571,
+    IMAGECUBEARRAY = 572,
+    IIMAGECUBEARRAY = 573,
+    UIMAGECUBEARRAY = 574,
+    IMAGE2DMS = 575,
+    IIMAGE2DMS = 576,
+    UIMAGE2DMS = 577,
+    IMAGE2DMSARRAY = 578,
+    IIMAGE2DMSARRAY = 579,
+    UIMAGE2DMSARRAY = 580,
+    F16IMAGE1D = 581,
+    F16IMAGE2D = 582,
+    F16IMAGE3D = 583,
+    F16IMAGE2DRECT = 584,
+    F16IMAGECUBE = 585,
+    F16IMAGE1DARRAY = 586,
+    F16IMAGE2DARRAY = 587,
+    F16IMAGECUBEARRAY = 588,
+    F16IMAGEBUFFER = 589,
+    F16IMAGE2DMS = 590,
+    F16IMAGE2DMSARRAY = 591,
+    STRUCT = 592,
+    VOID = 593,
+    WHILE = 594,
+    IDENTIFIER = 595,
+    TYPE_NAME = 596,
+    FLOATCONSTANT = 597,
+    DOUBLECONSTANT = 598,
+    INT16CONSTANT = 599,
+    UINT16CONSTANT = 600,
+    INT32CONSTANT = 601,
+    UINT32CONSTANT = 602,
+    INTCONSTANT = 603,
+    UINTCONSTANT = 604,
+    INT64CONSTANT = 605,
+    UINT64CONSTANT = 606,
+    BOOLCONSTANT = 607,
+    FLOAT16CONSTANT = 608,
+    LEFT_OP = 609,
+    RIGHT_OP = 610,
+    INC_OP = 611,
+    DEC_OP = 612,
+    LE_OP = 613,
+    GE_OP = 614,
+    EQ_OP = 615,
+    NE_OP = 616,
+    AND_OP = 617,
+    OR_OP = 618,
+    XOR_OP = 619,
+    MUL_ASSIGN = 620,
+    DIV_ASSIGN = 621,
+    ADD_ASSIGN = 622,
+    MOD_ASSIGN = 623,
+    LEFT_ASSIGN = 624,
+    RIGHT_ASSIGN = 625,
+    AND_ASSIGN = 626,
+    XOR_ASSIGN = 627,
+    OR_ASSIGN = 628,
+    SUB_ASSIGN = 629,
+    LEFT_PAREN = 630,
+    RIGHT_PAREN = 631,
+    LEFT_BRACKET = 632,
+    RIGHT_BRACKET = 633,
+    LEFT_BRACE = 634,
+    RIGHT_BRACE = 635,
+    DOT = 636,
+    COMMA = 637,
+    COLON = 638,
+    EQUAL = 639,
+    SEMICOLON = 640,
+    BANG = 641,
+    DASH = 642,
+    TILDE = 643,
+    PLUS = 644,
+    STAR = 645,
+    SLASH = 646,
+    PERCENT = 647,
+    LEFT_ANGLE = 648,
+    RIGHT_ANGLE = 649,
+    VERTICAL_BAR = 650,
+    CARET = 651,
+    AMPERSAND = 652,
+    QUESTION = 653,
+    INVARIANT = 654,
+    PRECISE = 655,
+    HIGH_PRECISION = 656,
+    MEDIUM_PRECISION = 657,
+    LOW_PRECISION = 658,
+    PRECISION = 659,
+    PACKED = 660,
+    RESOURCE = 661,
+    SUPERP = 662
   };
 #endif
 
@@ -490,9 +491,10 @@ union YYSTYPE
             glslang::TArraySizes* arraySizes;
             glslang::TIdentifierList* identifierList;
         };
+        glslang::TArraySizes* typeParameters;
     } interm;
 
-#line 496 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
+#line 498 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
 };
 
 typedef union YYSTYPE YYSTYPE;

diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp
index f74b90a..f04981e 100644 (file)
--- a/glslang/MachineIndependent/intermOut.cpp
+++ b/glslang/MachineIndependent/intermOut.cpp
@@ -817,6 +817,7 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpConstructStruct:  out.debug << "Construct structure";  break;
     case EOpConstructTextureSampler: out.debug << "Construct combined texture-sampler"; break;
     case EOpConstructReference:  out.debug << "Construct reference";  break;
+    case EOpConstructCooperativeMatrix:  out.debug << "Construct cooperative matrix";  break;
 
     case EOpLessThan:         out.debug << "Compare Less Than";             break;
     case EOpGreaterThan:      out.debug << "Compare Greater Than";          break;
@@ -1066,6 +1067,10 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break;
 #endif
 
+    case EOpCooperativeMatrixLoad:  out.debug << "Load cooperative matrix";  break;
+    case EOpCooperativeMatrixStore:  out.debug << "Store cooperative matrix";  break;
+    case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices"; break;
+
     default: out.debug.message(EPrefixError, "Bad aggregation op");
     }
 

diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h
index aecbc6b..a9433fd 100755 (executable)
--- a/glslang/MachineIndependent/localintermediate.h
+++ b/glslang/MachineIndependent/localintermediate.h
@@ -261,6 +261,7 @@ public:
         useStorageBuffer(false),
         useVulkanMemoryModel(false),
         hlslIoMapping(false),
+        useVariablePointers(false),
         textureSamplerTransformMode(EShTexSampTransKeep),
         needToLegalize(false),
         binaryDoubleOutput(false),
@@ -405,6 +406,12 @@ public:
         usePhysicalStorageBuffer = true;
     }
     bool usingPhysicalStorageBuffer() const { return usePhysicalStorageBuffer; }
+    void setUseVariablePointers()
+    {
+        useVariablePointers = true;
+        processes.addProcess("use-variable-pointers");
+    }
+    bool usingVariablePointers() const { return useVariablePointers; }
 
     template<class T> T addCounterBufferName(const T& name) const { return name + implicitCounterName; }
     bool hasCounterBufferName(const TString& name) const {
@@ -491,6 +498,7 @@ public:
     TIntermTyped* addConversion(TOperator, const TType&, TIntermTyped*) const;
     std::tuple<TIntermTyped*, TIntermTyped*> addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1) const;
     TIntermTyped* addUniShapeConversion(TOperator, const TType&, TIntermTyped*);
+    TIntermTyped* addConversion(TBasicType convertTo, TIntermTyped* node) const;
     void addBiShapeConversion(TOperator, TIntermTyped*& lhsNode, TIntermTyped*& rhsNode);
     TIntermTyped* addShapeConversion(const TType&, TIntermTyped*);
     TIntermTyped* addBinaryMath(TOperator, TIntermTyped* left, TIntermTyped* right, TSourceLoc);
@@ -852,6 +860,7 @@ protected:
     bool useStorageBuffer;
     bool useVulkanMemoryModel;
     bool hlslIoMapping;
+    bool useVariablePointers;
 
     std::set<TString> ioAccessed;           // set of names of statically read/written I/O that might need extra checking
     std::vector<TIoRange> usedIo[4];        // sets of used locations, one for each of in, out, uniform, and buffers

diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h
index b5e229a..02af76a 100755 (executable)
--- a/glslang/MachineIndependent/parseVersions.h
+++ b/glslang/MachineIndependent/parseVersions.h
@@ -104,6 +104,7 @@ public:
     virtual bool checkExtensionsRequested(const TSourceLoc&, int numExtensions, const char* const extensions[], const char* featureDesc);
     virtual void updateExtensionBehavior(const char* const extension, TExtensionBehavior);
     virtual void checkExtensionStage(const TSourceLoc&, const char* const extension);
+    virtual void fcoopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false);
 
     virtual void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken,
         const char* szExtraInfoFormat, ...) = 0;

diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp
index 1a14407..28a2f27 100644 (file)
--- a/gtests/Spv.FromFile.cpp
+++ b/gtests/Spv.FromFile.cpp
@@ -286,6 +286,8 @@ INSTANTIATE_TEST_CASE_P(
         "spv.constStruct.vert",
         "spv.controlFlowAttributes.frag",
         "spv.conversion.frag",
+        "spv.coopmat.comp",
+        "spv.coopmat_Error.comp",
         "spv.dataOut.frag",
         "spv.dataOutIndirect.frag",
         "spv.dataOutIndirect.vert",
@@ -410,6 +412,7 @@ INSTANTIATE_TEST_CASE_P(
     ::testing::ValuesIn(std::vector<std::string>({
         "spv.1.3.8bitstorage-ubo.vert",
         "spv.1.3.8bitstorage-ssbo.vert",
+        "spv.1.3.coopmat.comp",
         "spv.deviceGroup.frag",
         "spv.drawParams.vert",
         "spv.int8.frag",

diff --git a/known_good.json b/known_good.json
index 6137894..cf2101b 100644 (file)
--- a/known_good.json
+++ b/known_good.json
@@ -5,14 +5,14 @@
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Tools",
       "subdir" : "External/spirv-tools",
-      "commit" : "5994ae2a045015004cce24802dc47c33736486ea"
+      "commit" : "002ef361cabc486a2f3567d646363334d50cc462"
     },
     {
       "name" : "spirv-tools/external/spirv-headers",
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Headers",
       "subdir" : "External/spirv-tools/external/spirv-headers",
-      "commit" : "79b6681aadcb53c27d1052e5f8a0e82a981dbf2f"
+      "commit" : "e74c389f81915d0a48d6df1af83c3862c5ad85ab"
     }
   ]
 }