GL_KHR_memory_scope_semantics

diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h
index ec0c06d..16b0d9c 100644 (file)
--- a/SPIRV/GLSL.ext.KHR.h
+++ b/SPIRV/GLSL.ext.KHR.h
@@ -39,5 +39,6 @@ static const char* const E_SPV_KHR_16bit_storage                = "SPV_KHR_16bit
 static const char* const E_SPV_KHR_8bit_storage                 = "SPV_KHR_8bit_storage";
 static const char* const E_SPV_KHR_storage_buffer_storage_class = "SPV_KHR_storage_buffer_storage_class";
 static const char* const E_SPV_KHR_post_depth_coverage          = "SPV_KHR_post_depth_coverage";
+static const char* const E_SPV_KHR_vulkan_memory_model          = "SPV_KHR_vulkan_memory_model";
 
 #endif  // #ifndef GLSLextKHR_H

diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index cffeb20..587460e 100644 (file)
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -129,6 +129,10 @@ protected:
     spv::Decoration TranslateInterpolationDecoration(const glslang::TQualifier& qualifier);
     spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier);
     spv::Decoration TranslateNonUniformDecoration(const glslang::TQualifier& qualifier);
+    spv::Builder::AccessChain::CoherentFlags TranslateCoherent(const glslang::TType& type);
+    spv::MemoryAccessMask TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
+    spv::ImageOperandsMask TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
+    spv::Scope TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
     spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration);
     spv::ImageFormat TranslateImageFormat(const glslang::TType& type);
     spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const;
@@ -327,13 +331,15 @@ spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useSto
 }
 
 // Translate glslang type to SPIR-V memory decorations.
-void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory)
+void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory, bool useVulkanMemoryModel)
 {
-    if (qualifier.coherent)
-        memory.push_back(spv::DecorationCoherent);
-    if (qualifier.volatil) {
-        memory.push_back(spv::DecorationVolatile);
-        memory.push_back(spv::DecorationCoherent);
+    if (!useVulkanMemoryModel) {
+        if (qualifier.coherent)
+            memory.push_back(spv::DecorationCoherent);
+        if (qualifier.volatil) {
+            memory.push_back(spv::DecorationVolatile);
+            memory.push_back(spv::DecorationCoherent);
+        }
     }
     if (qualifier.restrict)
         memory.push_back(spv::DecorationRestrict);
@@ -450,6 +456,105 @@ spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glsl
         return spv::DecorationMax;
 }
 
+spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
+{
+    if (!glslangIntermediate->usingVulkanMemoryModel() || coherentFlags.isImage) {
+        return spv::MemoryAccessMaskNone;
+    }
+    spv::MemoryAccessMask mask = spv::MemoryAccessMaskNone;
+    if (coherentFlags.volatil ||
+        coherentFlags.coherent ||
+        coherentFlags.devicecoherent ||
+        coherentFlags.queuefamilycoherent ||
+        coherentFlags.workgroupcoherent ||
+        coherentFlags.subgroupcoherent) {
+        mask = mask | spv::MemoryAccessMakePointerAvailableKHRMask |
+                      spv::MemoryAccessMakePointerVisibleKHRMask;
+    }
+    if (coherentFlags.nonprivate) {
+        mask = mask | spv::MemoryAccessNonPrivatePointerKHRMask;
+    }
+    if (coherentFlags.volatil) {
+        mask = mask | spv::MemoryAccessVolatileMask;
+    }
+    if (mask != spv::MemoryAccessMaskNone) {
+        builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+    }
+    return mask;
+}
+
+spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
+{
+    if (!glslangIntermediate->usingVulkanMemoryModel()) {
+        return spv::ImageOperandsMaskNone;
+    }
+    spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
+    if (coherentFlags.volatil ||
+        coherentFlags.coherent ||
+        coherentFlags.devicecoherent ||
+        coherentFlags.queuefamilycoherent ||
+        coherentFlags.workgroupcoherent ||
+        coherentFlags.subgroupcoherent) {
+        mask = mask | spv::ImageOperandsMakeTexelAvailableKHRMask |
+                      spv::ImageOperandsMakeTexelVisibleKHRMask;
+    }
+    if (coherentFlags.nonprivate) {
+        mask = mask | spv::ImageOperandsNonPrivateTexelKHRMask;
+    }
+    if (coherentFlags.volatil) {
+        mask = mask | spv::ImageOperandsVolatileTexelKHRMask;
+    }
+    if (mask != spv::ImageOperandsMaskNone) {
+        builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+    }
+    return mask;
+}
+
+spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type)
+{
+    spv::Builder::AccessChain::CoherentFlags flags;
+    flags.coherent = type.getQualifier().coherent;
+    flags.devicecoherent = type.getQualifier().devicecoherent;
+    flags.queuefamilycoherent = type.getQualifier().queuefamilycoherent;
+    // shared variables are implicitly workgroupcoherent in GLSL.
+    flags.workgroupcoherent = type.getQualifier().workgroupcoherent ||
+                              type.getQualifier().storage == glslang::EvqShared;
+    flags.subgroupcoherent = type.getQualifier().subgroupcoherent;
+    // *coherent variables are implicitly nonprivate in GLSL
+    flags.nonprivate = type.getQualifier().nonprivate ||
+                       type.getQualifier().subgroupcoherent ||
+                       type.getQualifier().workgroupcoherent ||
+                       type.getQualifier().queuefamilycoherent ||
+                       type.getQualifier().devicecoherent ||
+                       type.getQualifier().coherent;
+    flags.volatil = type.getQualifier().volatil;
+    flags.isImage = type.getBasicType() == glslang::EbtSampler;
+    return flags;
+}
+
+spv::Scope TGlslangToSpvTraverser::TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
+{
+    spv::Scope scope;
+    if (coherentFlags.coherent) {
+        // coherent defaults to Device scope in the old model, QueueFamilyKHR scope in the new model
+        scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
+    } else if (coherentFlags.devicecoherent) {
+        scope = spv::ScopeDevice;
+    } else if (coherentFlags.queuefamilycoherent) {
+        scope = spv::ScopeQueueFamilyKHR;
+    } else if (coherentFlags.workgroupcoherent) {
+        scope = spv::ScopeWorkgroup;
+    } else if (coherentFlags.subgroupcoherent) {
+        scope = spv::ScopeSubgroup;
+    } else {
+        scope = spv::ScopeMax;
+    }
+    if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::ScopeDevice) {
+        builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
+    }
+    return scope;
+}
+
 // Translate a glslang built-in variable to a SPIR-V built in decoration.  Also generate
 // associated capabilities when required.  For some built-in variables, a capability
 // is generated only when using the variable in an executable instruction, but not when
@@ -979,6 +1084,16 @@ void InheritQualifiers(glslang::TQualifier& child, const glslang::TQualifier& pa
         child.sample = true;
     if (parent.coherent)
         child.coherent = true;
+    if (parent.devicecoherent)
+        child.devicecoherent = true;
+    if (parent.queuefamilycoherent)
+        child.queuefamilycoherent = true;
+    if (parent.workgroupcoherent)
+        child.workgroupcoherent = true;
+    if (parent.subgroupcoherent)
+        child.subgroupcoherent = true;
+    if (parent.nonprivate)
+        child.nonprivate = true;
     if (parent.volatil)
         child.volatil = true;
     if (parent.restrict)
@@ -1045,7 +1160,12 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl
         builder.setSourceText(text);
     }
     stdBuiltins = builder.import("GLSL.std.450");
-    builder.setMemoryModel(spv::AddressingModelLogical, spv::MemoryModelGLSL450);
+    if (glslangIntermediate->usingVulkanMemoryModel()) {
+        builder.setMemoryModel(spv::AddressingModelLogical, spv::MemoryModelVulkanKHR);
+        builder.addExtension(spv::E_SPV_KHR_vulkan_memory_model);
+    } else {
+        builder.setMemoryModel(spv::AddressingModelLogical, spv::MemoryModelGLSL450);
+    }
     shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
     entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
 
@@ -1351,7 +1471,7 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
 
             // store the result
             builder.setAccessChain(lValue);
-            multiTypeStore(node->getType(), rValue);
+            multiTypeStore(node->getLeft()->getType(), rValue);
 
             // assignments are expressions having an rValue after they are evaluated...
             builder.clearAccessChain();
@@ -1388,7 +1508,7 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
                 }
 
                 // normal case for indexing array or structure or block
-                builder.accessChainPush(builder.makeIntConstant(spvIndex));
+                builder.accessChainPush(builder.makeIntConstant(spvIndex), TranslateCoherent(node->getLeft()->getType()));
 
                 // Add capabilities here for accessing PointSize and clip/cull distance.
                 // We have deferred generation of associated capabilities until now.
@@ -1424,7 +1544,7 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
             if (! node->getLeft()->getType().isArray() && node->getLeft()->getType().isVector())
                 builder.accessChainPushComponent(index, convertGlslangToSpvType(node->getLeft()->getType()));
             else
-                builder.accessChainPush(index);
+                builder.accessChainPush(index, TranslateCoherent(node->getLeft()->getType()));
         }
         return false;
     case glslang::EOpVectorSwizzle:
@@ -1658,11 +1778,11 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         builder.setAccessChainRValue(result);
 
         return false;
+    } else if (node->getOp() == glslang::EOpImageStore ||
 #ifdef AMD_EXTENSIONS
-    } else if (node->getOp() == glslang::EOpImageStore || node->getOp() == glslang::EOpImageStoreLod) {
-#else
-    } else if (node->getOp() == glslang::EOpImageStore) {
+        node->getOp() == glslang::EOpImageStoreLod ||
 #endif
+        node->getOp() == glslang::EOpImageAtomicStore) {
         // "imageStore" is a special case, which has no result
         return false;
     }
@@ -1952,6 +2072,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         // These all have 0 operands and will naturally finish up in the code below for 0 operands
         break;
 
+    case glslang::EOpAtomicStore:
+        noReturnValue = true;
+        // fallthrough
+    case glslang::EOpAtomicLoad:
     case glslang::EOpAtomicAdd:
     case glslang::EOpAtomicMin:
     case glslang::EOpAtomicMax:
@@ -2050,6 +2174,8 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         case glslang::EOpAtomicXor:
         case glslang::EOpAtomicExchange:
         case glslang::EOpAtomicCompSwap:
+        case glslang::EOpAtomicLoad:
+        case glslang::EOpAtomicStore:
         case glslang::EOpAtomicCounterAdd:
         case glslang::EOpAtomicCounterSubtract:
         case glslang::EOpAtomicCounterMin:
@@ -2876,7 +3002,7 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
             qualifier.storage == glslang::EvqBuffer) {
             // Add memory decorations only to top-level members of shader storage block
             std::vector<spv::Decoration> memory;
-            TranslateMemoryDecoration(memberQualifier, memory);
+            TranslateMemoryDecoration(memberQualifier, memory, glslangIntermediate->usingVulkanMemoryModel());
             for (unsigned int i = 0; i < memory.size(); ++i)
                 builder.addMemberDecoration(spvType, member, memory[i]);
         }
@@ -2987,8 +3113,15 @@ spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arra
 spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
 {
     spv::Id nominalTypeId = builder.accessChainGetInferredType();
+
+    spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
+    coherentFlags |= TranslateCoherent(type);
+
     spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type),
-                                               TranslateNonUniformDecoration(type.getQualifier()), nominalTypeId);
+                                               TranslateNonUniformDecoration(type.getQualifier()),
+                                               nominalTypeId,
+                                               spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask),
+                                               TranslateMemoryScope(coherentFlags));
 
     // Need to convert to abstract types when necessary
     if (type.getBasicType() == glslang::EbtBool) {
@@ -3044,7 +3177,12 @@ void TGlslangToSpvTraverser::accessChainStore(const glslang::TType& type, spv::I
         }
     }
 
-    builder.accessChainStore(rvalue);
+    spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
+    coherentFlags |= TranslateCoherent(type);
+
+    builder.accessChainStore(rvalue,
+                             spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerVisibleKHRMask),
+                             TranslateMemoryScope(coherentFlags));
 }
 
 // For storing when types match at the glslang level, but not might match at the
@@ -3090,7 +3228,7 @@ void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id
             // set up the target storage
             builder.clearAccessChain();
             builder.setAccessChainLValue(lValue);
-            builder.accessChainPush(builder.makeIntConstant(index));
+            builder.accessChainPush(builder.makeIntConstant(index), TranslateCoherent(type));
 
             // store the member
             multiTypeStore(glslangElementType, elementRValue);
@@ -3110,7 +3248,7 @@ void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id
             // set up the target storage
             builder.clearAccessChain();
             builder.setAccessChainLValue(lValue);
-            builder.accessChainPush(builder.makeIntConstant(m));
+            builder.accessChainPush(builder.makeIntConstant(m), TranslateCoherent(type));
 
             // store the member
             multiTypeStore(glslangMemberType, memberRValue);
@@ -3287,11 +3425,11 @@ bool TGlslangToSpvTraverser::originalParam(glslang::TStorageQualifier qualifier,
 // Make all the functions, skeletally, without actually visiting their bodies.
 void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslFunctions)
 {
-    const auto getParamDecorations = [](std::vector<spv::Decoration>& decorations, const glslang::TType& type) {
+    const auto getParamDecorations = [](std::vector<spv::Decoration>& decorations, const glslang::TType& type, bool useVulkanMemoryModel) {
         spv::Decoration paramPrecision = TranslatePrecisionDecoration(type);
         if (paramPrecision != spv::NoPrecision)
             decorations.push_back(paramPrecision);
-        TranslateMemoryDecoration(type.getQualifier(), decorations);
+        TranslateMemoryDecoration(type.getQualifier(), decorations, useVulkanMemoryModel);
     };
 
     for (int f = 0; f < (int)glslFunctions.size(); ++f) {
@@ -3330,7 +3468,7 @@ void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslF
                 typeId = builder.makePointer(spv::StorageClassFunction, typeId);
             else
                 rValueParameters.insert(parameters[p]->getAsSymbolNode()->getId());
-            getParamDecorations(paramDecorations[p], paramType);
+            getParamDecorations(paramDecorations[p], paramType, glslangIntermediate->usingVulkanMemoryModel());
             paramTypes.push_back(typeId);
         }
 
@@ -3420,6 +3558,8 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
         case glslang::EOpImageAtomicXor:
         case glslang::EOpImageAtomicExchange:
         case glslang::EOpImageAtomicCompSwap:
+        case glslang::EOpImageAtomicLoad:
+        case glslang::EOpImageAtomicStore:
             if (i == 0)
                 lvalue = true;
             break;
@@ -3547,8 +3687,10 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
     builder.setLine(node->getLoc().line);
 
     // Process a GLSL texturing op (will be SPV image)
-    const glslang::TSampler sampler = node->getAsAggregate() ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler()
-                                                             : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType().getSampler();
+
+    const glslang::TType &imageType = node->getAsAggregate() ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()
+                                                             : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType();
+    const glslang::TSampler sampler = imageType.getSampler();
 #ifdef AMD_EXTENSIONS
     bool f16ShadowCompare = (sampler.shadow && node->getAsAggregate())
                                 ? node->getAsAggregate()->getSequence()[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16
@@ -3651,22 +3793,38 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
 #else
         if (node->getOp() == glslang::EOpImageLoad) {
 #endif
+            spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
             if (sampler.ms) {
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsSampleMask };
-                operands.push_back(imageOperands);
-                spv::IdImmediate imageOperand = { true, *opIt };
-                operands.push_back(imageOperand);
+                mask = mask | spv::ImageOperandsSampleMask;
+            }
 #ifdef AMD_EXTENSIONS
-            } else if (cracked.lod) {
+            if (cracked.lod) {
                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
-
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsLodMask };
+                mask = mask | spv::ImageOperandsLodMask;
+            }
+#endif
+            mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
+            mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
+            if (mask) {
+                spv::IdImmediate imageOperands = { false, (unsigned int)mask };
                 operands.push_back(imageOperands);
-                spv::IdImmediate imageOperand = { true, *opIt };
+            }
+            if (mask & spv::ImageOperandsSampleMask) {
+                spv::IdImmediate imageOperand = { true, *opIt++ };
+                operands.push_back(imageOperand);
+            }
+#ifdef AMD_EXTENSIONS
+            if (mask & spv::ImageOperandsLodMask) {
+                spv::IdImmediate imageOperand = { true, *opIt++ };
                 operands.push_back(imageOperand);
+            }
 #endif
+            if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
+                spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
+                operands.push_back(imageOperand);
             }
+
             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
                 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
 
@@ -3683,29 +3841,52 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
 #else
         } else if (node->getOp() == glslang::EOpImageStore) {
 #endif
+
+            // Push the texel value before the operands
+#ifdef AMD_EXTENSIONS
+            if (sampler.ms || cracked.lod) {
+#else
             if (sampler.ms) {
+#endif
                 spv::IdImmediate texel = { true, *(opIt + 1) };
                 operands.push_back(texel);
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsSampleMask };
-                operands.push_back(imageOperands);
-                spv::IdImmediate imageOperand = { true, *opIt };
-                operands.push_back(imageOperand);
+            } else {
+                spv::IdImmediate texel = { true, *opIt };
+                operands.push_back(texel);
+            }
+
+            spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
+            if (sampler.ms) {
+                mask = mask | spv::ImageOperandsSampleMask;
+            }
 #ifdef AMD_EXTENSIONS
-            } else if (cracked.lod) {
+            if (cracked.lod) {
                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
-
-                spv::IdImmediate texel = { true, *(opIt + 1) };
-                operands.push_back(texel);
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsLodMask };
+                mask = mask | spv::ImageOperandsLodMask;
+            }
+#endif
+            mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
+            mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelVisibleKHRMask);
+            if (mask) {
+                spv::IdImmediate imageOperands = { false, (unsigned int)mask };
                 operands.push_back(imageOperands);
-                spv::IdImmediate imageOperand = { true, *opIt };
+            }
+            if (mask & spv::ImageOperandsSampleMask) {
+                spv::IdImmediate imageOperand = { true, *opIt++ };
+                operands.push_back(imageOperand);
+            }
+#ifdef AMD_EXTENSIONS
+            if (mask & spv::ImageOperandsLodMask) {
+                spv::IdImmediate imageOperand = { true, *opIt++ };
                 operands.push_back(imageOperand);
+            }
 #endif
-            } else {
-                spv::IdImmediate texel = { true, *opIt };
-                operands.push_back(texel);
+            if (mask & spv::ImageOperandsMakeTexelAvailableKHRMask) {
+                spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
+                operands.push_back(imageOperand);
             }
+
             builder.createNoResultOp(spv::OpImageWrite, operands);
             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
                 builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat);
@@ -3719,21 +3900,37 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
                 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
 
+            spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
             if (sampler.ms) {
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsSampleMask };
-                operands.push_back(imageOperands);
-                spv::IdImmediate imageOperand = { true, *opIt++ };
-                operands.push_back(imageOperand);
+                mask = mask | spv::ImageOperandsSampleMask;
+            }
 #ifdef AMD_EXTENSIONS
-            } else if (cracked.lod) {
+            if (cracked.lod) {
                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
 
-                spv::IdImmediate imageOperands = { false, spv::ImageOperandsLodMask };
+                mask = mask | spv::ImageOperandsLodMask;
+            }
+#endif
+            mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
+            mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
+            if (mask) {
+                spv::IdImmediate imageOperands = { false, (unsigned int)mask };
                 operands.push_back(imageOperands);
+            }
+            if (mask & spv::ImageOperandsSampleMask) {
                 spv::IdImmediate imageOperand = { true, *opIt++ };
                 operands.push_back(imageOperand);
+            }
+#ifdef AMD_EXTENSIONS
+            if (mask & spv::ImageOperandsLodMask) {
+                spv::IdImmediate imageOperand = { true, *opIt++ };
+                operands.push_back(imageOperand);
+            }
 #endif
+            if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
+                spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
+                operands.push_back(imageOperand);
             }
 
             // Create the return type that was a special structure
@@ -3756,7 +3953,14 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
             spv::IdImmediate sample = { true, sampler.ms ? *(opIt++) : builder.makeUintConstant(0) };
             operands.push_back(sample);
 
-            spv::Id resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
+            spv::Id resultTypeId;
+            // imageAtomicStore has a void return type so base the pointer type on
+            // the type of the value operand.
+            if (node->getOp() == glslang::EOpImageAtomicStore) {
+                resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(operands[2].word));                
+            } else {
+                resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
+            }
             spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands);
 
             std::vector<spv::Id> operands;
@@ -3972,6 +4176,16 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
         }
     }
 
+    // nonprivate
+    if (imageType.getQualifier().nonprivate) {
+        params.nonprivate = true;
+    }
+
+    // volatile
+    if (imageType.getQualifier().volatil) {
+        params.volatil = true;
+    }
+
     std::vector<spv::Id> result( 1, 
         builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather, noImplicitLod, params)
     );
@@ -5340,8 +5554,14 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
         opCode = spv::OpAtomicIDecrement;
         break;
     case glslang::EOpAtomicCounter:
+    case glslang::EOpImageAtomicLoad:
+    case glslang::EOpAtomicLoad:
         opCode = spv::OpAtomicLoad;
         break;
+    case glslang::EOpAtomicStore:
+    case glslang::EOpImageAtomicStore:
+        opCode = spv::OpAtomicStore;
+        break;
     default:
         assert(0);
         break;
@@ -5352,36 +5572,82 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
 
     // Sort out the operands
     //  - mapping from glslang -> SPV
-    //  - there are extra SPV operands with no glslang source
+    //  - there are extra SPV operands that are optional in glslang
     //  - compare-exchange swaps the value and comparator
     //  - compare-exchange has an extra memory semantics
     //  - EOpAtomicCounterDecrement needs a post decrement
+    spv::Id pointerId = 0, compareId = 0, valueId = 0;
+    // scope defaults to Device in the old model, QueueFamilyKHR in the new model
+    spv::Id scopeId;
+    if (glslangIntermediate->usingVulkanMemoryModel()) {
+        scopeId = builder.makeUintConstant(spv::ScopeQueueFamilyKHR);
+    } else {
+        scopeId = builder.makeUintConstant(spv::ScopeDevice);
+    }
+    // semantics default to relaxed 
+    spv::Id semanticsId = builder.makeUintConstant(spv::MemorySemanticsMaskNone);
+    spv::Id semanticsId2 = semanticsId;
+
+    pointerId = operands[0];
+    if (opCode == spv::OpAtomicIIncrement || opCode == spv::OpAtomicIDecrement) {
+        // no additional operands
+    } else if (opCode == spv::OpAtomicCompareExchange) {
+        compareId = operands[1];
+        valueId = operands[2];
+        if (operands.size() > 3) {
+            scopeId = operands[3];
+            semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[4]) | builder.getConstantScalar(operands[5]));
+            semanticsId2 = builder.makeUintConstant(builder.getConstantScalar(operands[6]) | builder.getConstantScalar(operands[7]));
+        }
+    } else if (opCode == spv::OpAtomicLoad) {
+        if (operands.size() > 1) {
+            scopeId = operands[1];
+            semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]));
+        }
+    } else {
+        // atomic store or RMW
+        valueId = operands[1];
+        if (operands.size() > 2) {
+            scopeId = operands[2];
+            semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[3]) | builder.getConstantScalar(operands[4]));
+        }
+    }
+
+    // Check for capabilities
+    unsigned semanticsImmediate = builder.getConstantScalar(semanticsId) | builder.getConstantScalar(semanticsId2);
+    if (semanticsImmediate & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask)) {
+        builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+    }
+
+    if (glslangIntermediate->usingVulkanMemoryModel() && builder.getConstantScalar(scopeId) == spv::ScopeDevice) {
+        builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
+    }
+
     std::vector<spv::Id> spvAtomicOperands;  // hold the spv operands
-    auto opIt = operands.begin();            // walk the glslang operands
-    spvAtomicOperands.push_back(*(opIt++));
-    spvAtomicOperands.push_back(builder.makeUintConstant(spv::ScopeDevice));     // TBD: what is the correct scope?
-    spvAtomicOperands.push_back(builder.makeUintConstant(spv::MemorySemanticsMaskNone)); // TBD: what are the correct memory semantics?
+    spvAtomicOperands.push_back(pointerId);
+    spvAtomicOperands.push_back(scopeId);
+    spvAtomicOperands.push_back(semanticsId);
     if (opCode == spv::OpAtomicCompareExchange) {
-        // There are 2 memory semantics for compare-exchange. And the operand order of "comparator" and "new value" in GLSL
-        // differs from that in SPIR-V. Hence, special processing is required.
-        spvAtomicOperands.push_back(builder.makeUintConstant(spv::MemorySemanticsMaskNone));
-        spvAtomicOperands.push_back(*(opIt + 1));
-        spvAtomicOperands.push_back(*opIt);
-        opIt += 2;
+        spvAtomicOperands.push_back(semanticsId2);
+        spvAtomicOperands.push_back(valueId);
+        spvAtomicOperands.push_back(compareId);
+    } else if (opCode != spv::OpAtomicLoad && opCode != spv::OpAtomicIIncrement && opCode != spv::OpAtomicIDecrement) {
+        spvAtomicOperands.push_back(valueId);
     }
 
-    // Add the rest of the operands, skipping any that were dealt with above.
-    for (; opIt != operands.end(); ++opIt)
-        spvAtomicOperands.push_back(*opIt);
-
-    spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands);
+    if (opCode == spv::OpAtomicStore) {
+        builder.createNoResultOp(opCode, spvAtomicOperands);
+        return 0;
+    } else {
+        spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands);
 
-    // GLSL and HLSL atomic-counter decrement return post-decrement value,
-    // while SPIR-V returns pre-decrement value. Translate between these semantics.
-    if (op == glslang::EOpAtomicCounterDecrement)
-        resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1));
+        // GLSL and HLSL atomic-counter decrement return post-decrement value,
+        // while SPIR-V returns pre-decrement value. Translate between these semantics.
+        if (op == glslang::EOpAtomicCounterDecrement)
+            resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1));
 
-    return resultId;
+        return resultId;
+    }
 }
 
 // Create group invocation operations.
@@ -6282,7 +6548,41 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         libCall = spv::InterpolateAtVertexAMD;
         break;
 #endif
-
+    case glslang::EOpBarrier:
+        {
+            // This is for the extended controlBarrier function, with four operands.
+            // The unextended barrier() goes through createNoArgOperation.
+            assert(operands.size() == 4);
+            unsigned int executionScope = builder.getConstantScalar(operands[0]);
+            unsigned int memoryScope = builder.getConstantScalar(operands[1]);
+            unsigned int semantics = builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]);
+            builder.createControlBarrier((spv::Scope)executionScope, (spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics);
+            if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask)) {
+                builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+            }
+            if (glslangIntermediate->usingVulkanMemoryModel() && (executionScope == spv::ScopeDevice || memoryScope == spv::ScopeDevice)) {
+                builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
+            }
+            return 0;
+        }
+        break;
+    case glslang::EOpMemoryBarrier:
+        {
+            // This is for the extended memoryBarrier function, with three operands.
+            // The unextended memoryBarrier() goes through createNoArgOperation.
+            assert(operands.size() == 3);
+            unsigned int memoryScope = builder.getConstantScalar(operands[0]);
+            unsigned int semantics = builder.getConstantScalar(operands[1]) | builder.getConstantScalar(operands[2]);
+            builder.createMemoryBarrier((spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics);
+            if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask)) {
+                builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+            }
+            if (glslangIntermediate->usingVulkanMemoryModel() && memoryScope == spv::ScopeDevice) {
+                builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
+            }
+            return 0;
+        }
+        break;
     default:
         return 0;
     }
@@ -6351,7 +6651,8 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
 // Intrinsics with no arguments (or no return value, and no precision).
 spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId)
 {
-    // TODO: get the barrier operands correct
+    // GLSL memory barriers use queuefamily scope in new model, device scope in old model
+    spv::Scope memoryBarrierScope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
 
     switch (op) {
     case glslang::EOpEmitVertex:
@@ -6362,11 +6663,14 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv:
         return 0;
     case glslang::EOpBarrier:
         if (glslangIntermediate->getStage() == EShLangTessControl) {
-            builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone);
-            // TODO: prefer the following, when available:
-            // builder.createControlBarrier(spv::ScopePatch, spv::ScopePatch,
-            //                                 spv::MemorySemanticsPatchMask |
-            //                                 spv::MemorySemanticsAcquireReleaseMask);
+            if (glslangIntermediate->usingVulkanMemoryModel()) {
+                builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
+                                             spv::MemorySemanticsOutputMemoryKHRMask |
+                                             spv::MemorySemanticsAcquireReleaseMask);
+                builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
+            } else {
+                builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone);
+            }
         } else {
             builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
                                             spv::MemorySemanticsWorkgroupMemoryMask |
@@ -6374,24 +6678,24 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv:
         }
         return 0;
     case glslang::EOpMemoryBarrier:
-        builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsAllMemory |
-                                                      spv::MemorySemanticsAcquireReleaseMask);
+        builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAllMemory |
+                                                        spv::MemorySemanticsAcquireReleaseMask);
         return 0;
     case glslang::EOpMemoryBarrierAtomicCounter:
-        builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsAtomicCounterMemoryMask |
-                                                      spv::MemorySemanticsAcquireReleaseMask);
+        builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask |
+                                                        spv::MemorySemanticsAcquireReleaseMask);
         return 0;
     case glslang::EOpMemoryBarrierBuffer:
-        builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
-                                                      spv::MemorySemanticsAcquireReleaseMask);
+        builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsUniformMemoryMask |
+                                                        spv::MemorySemanticsAcquireReleaseMask);
         return 0;
     case glslang::EOpMemoryBarrierImage:
-        builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsImageMemoryMask |
-                                                      spv::MemorySemanticsAcquireReleaseMask);
+        builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsImageMemoryMask |
+                                                        spv::MemorySemanticsAcquireReleaseMask);
         return 0;
     case glslang::EOpMemoryBarrierShared:
-        builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsWorkgroupMemoryMask |
-                                                      spv::MemorySemanticsAcquireReleaseMask);
+        builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsWorkgroupMemoryMask |
+                                                        spv::MemorySemanticsAcquireReleaseMask);
         return 0;
     case glslang::EOpGroupMemoryBarrier:
         builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory |
@@ -6520,7 +6824,7 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
 
     if (symbol->getType().isImage()) {
         std::vector<spv::Decoration> memory;
-        TranslateMemoryDecoration(symbol->getType().getQualifier(), memory);
+        TranslateMemoryDecoration(symbol->getType().getQualifier(), memory, glslangIntermediate->usingVulkanMemoryModel());
         for (unsigned int i = 0; i < memory.size(); ++i)
             builder.addDecoration(id, memory[i]);
     }

diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index 093a740..0891e8c 100644 (file)
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -1216,19 +1216,35 @@ Id Builder::createUndefined(Id type)
 }
 
 // Comments in header
-void Builder::createStore(Id rValue, Id lValue)
+void Builder::createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess, spv::Scope scope)
 {
     Instruction* store = new Instruction(OpStore);
     store->addIdOperand(lValue);
     store->addIdOperand(rValue);
+
+    if (memoryAccess != MemoryAccessMaskNone) {
+        store->addImmediateOperand(memoryAccess);
+        if (memoryAccess & spv::MemoryAccessMakePointerAvailableKHRMask) {
+            store->addIdOperand(makeUintConstant(scope));
+        }
+    }
+
     buildPoint->addInstruction(std::unique_ptr<Instruction>(store));
 }
 
 // Comments in header
-Id Builder::createLoad(Id lValue)
+Id Builder::createLoad(Id lValue, spv::MemoryAccessMask memoryAccess, spv::Scope scope)
 {
     Instruction* load = new Instruction(getUniqueId(), getDerefTypeId(lValue), OpLoad);
     load->addIdOperand(lValue);
+
+    if (memoryAccess != MemoryAccessMaskNone) {
+        load->addImmediateOperand(memoryAccess);
+        if (memoryAccess & spv::MemoryAccessMakePointerVisibleKHRMask) {
+            load->addIdOperand(makeUintConstant(scope));
+        }
+    }
+
     buildPoint->addInstruction(std::unique_ptr<Instruction>(load));
 
     return load->getResultId();
@@ -1362,6 +1378,16 @@ void Builder::createNoResultOp(Op opCode, Id operand)
 }
 
 // An opcode that has multiple operands, no result id, and no type
+void Builder::createNoResultOp(Op opCode, const std::vector<Id>& operands)
+{
+    Instruction* op = new Instruction(opCode);
+    for (auto it = operands.cbegin(); it != operands.cend(); ++it) {
+        op->addIdOperand(*it);
+    }
+    buildPoint->addInstruction(std::unique_ptr<Instruction>(op));
+}
+
+// An opcode that has multiple operands, no result id, and no type
 void Builder::createNoResultOp(Op opCode, const std::vector<IdImmediate>& operands)
 {
     Instruction* op = new Instruction(opCode);
@@ -1679,6 +1705,12 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse,
         mask = (ImageOperandsMask)(mask | ImageOperandsMinLodMask);
         texArgs[numArgs++] = parameters.lodClamp;
     }
+    if (parameters.nonprivate) {
+        mask = mask | ImageOperandsNonPrivateTexelKHRMask;
+    }
+    if (parameters.volatil) {
+        mask = mask | ImageOperandsVolatileTexelKHRMask;
+    }
     if (mask == ImageOperandsMaskNone)
         --numArgs;  // undo speculative reservation for the mask argument
     else
@@ -2352,6 +2384,7 @@ void Builder::clearAccessChain()
     accessChain.component = NoResult;
     accessChain.preSwizzleBaseType = NoType;
     accessChain.isRValue = false;
+    accessChain.coherentFlags.clear();
 }
 
 // Comments in header
@@ -2378,7 +2411,7 @@ void Builder::accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizz
 }
 
 // Comments in header
-void Builder::accessChainStore(Id rvalue)
+void Builder::accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess, spv::Scope scope)
 {
     assert(accessChain.isRValue == false);
 
@@ -2396,11 +2429,11 @@ void Builder::accessChainStore(Id rvalue)
         source = createLvalueSwizzle(getTypeId(tempBaseId), tempBaseId, source, accessChain.swizzle);
     }
 
-    createStore(source, base);
+    createStore(source, base, memoryAccess, scope);
 }
 
 // Comments in header
-Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resultType)
+Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resultType, spv::MemoryAccessMask memoryAccess, spv::Scope scope)
 {
     Id id;
 
@@ -2444,7 +2477,7 @@ Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resu
     } else {
         transferAccessChainSwizzle(true);
         // load through the access chain
-        id = createLoad(collapseAccessChain());
+        id = createLoad(collapseAccessChain(), memoryAccess, scope);
         setPrecision(id, precision);
         addDecoration(id, nonUniform);
     }

diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index b09ba04..eb52d01 100644 (file)
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -274,10 +274,10 @@ public:
     Id createUndefined(Id type);
 
     // Store into an Id and return the l-value
-    void createStore(Id rValue, Id lValue);
+    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax);
 
     // Load from an Id and return it
-    Id createLoad(Id lValue);
+    Id createLoad(Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax);
 
     // Create an OpAccessChain instruction
     Id createAccessChain(StorageClass, Id base, const std::vector<Id>& offsets);
@@ -296,6 +296,7 @@ public:
 
     void createNoResultOp(Op);
     void createNoResultOp(Op, Id operand);
+    void createNoResultOp(Op, const std::vector<Id>& operands);
     void createNoResultOp(Op, const std::vector<IdImmediate>& operands);
     void createControlBarrier(Scope execution, Scope memory, MemorySemanticsMask);
     void createMemoryBarrier(unsigned executionScope, unsigned memorySemantics);
@@ -365,6 +366,8 @@ public:
         Id component;
         Id texelOut;
         Id lodClamp;
+        bool nonprivate;
+        bool volatil;
     };
 
     // Select the correct texture operation based on all inputs, and emit the correct instruction
@@ -504,6 +507,43 @@ public:
         Id component;                  // a dynamic component index, can coexist with a swizzle, done after the swizzle, NoResult if not present
         Id preSwizzleBaseType;         // dereferenced type, before swizzle or component is applied; NoType unless a swizzle or component is present
         bool isRValue;                 // true if 'base' is an r-value, otherwise, base is an l-value
+
+        // Accumulate whether anything in the chain of structures has coherent decorations.
+        struct CoherentFlags {
+            unsigned coherent : 1;
+            unsigned devicecoherent : 1;
+            unsigned queuefamilycoherent : 1;
+            unsigned workgroupcoherent : 1;
+            unsigned subgroupcoherent : 1;
+            unsigned nonprivate : 1;
+            unsigned volatil : 1;
+            unsigned isImage : 1;
+
+            void clear() {
+                coherent = 0;
+                devicecoherent = 0;
+                queuefamilycoherent = 0;
+                workgroupcoherent = 0;
+                subgroupcoherent = 0;
+                nonprivate = 0;
+                volatil = 0;
+                isImage = 0;
+            }
+
+            CoherentFlags() { clear(); }
+            CoherentFlags operator |=(const CoherentFlags &other) {
+                coherent |= other.coherent;
+                devicecoherent |= other.devicecoherent;
+                queuefamilycoherent |= other.queuefamilycoherent;
+                workgroupcoherent |= other.workgroupcoherent;
+                subgroupcoherent |= other.subgroupcoherent;
+                nonprivate |= other.nonprivate;
+                volatil |= other.volatil;
+                isImage |= other.isImage;
+                return *this;
+            }
+        };
+        CoherentFlags coherentFlags;
     };
 
     //
@@ -533,9 +573,10 @@ public:
     }
 
     // push offset onto the end of the chain
-    void accessChainPush(Id offset)
+    void accessChainPush(Id offset, AccessChain::CoherentFlags coherentFlags)
     {
         accessChain.indexChain.push_back(offset);
+        accessChain.coherentFlags |= coherentFlags;
     }
 
     // push new swizzle onto the end of any existing swizzle, merging into a single swizzle
@@ -553,10 +594,10 @@ public:
     }
 
     // use accessChain and swizzle to store value
-    void accessChainStore(Id rvalue);
+    void accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax);
 
     // use accessChain and swizzle to load an r-value
-    Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType);
+    Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax);
 
     // get the direct pointer for an l-value
     Id accessChainGetLValue();

diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp
index 6f31609..042d558 100644 (file)
--- a/SPIRV/disassemble.cpp
+++ b/SPIRV/disassemble.cpp
@@ -535,6 +535,11 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
         case OperandLiteralString:
             numOperands -= disassembleString();
             break;
+        case OperandMemoryAccess:
+            outputMask(OperandMemoryAccess, stream[word++]);
+            --numOperands;
+            disassembleIds(numOperands);
+            return;
         default:
             assert(operandClass >= OperandSource && operandClass < OperandOpcode);
 

diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
index ae32efe..a68df0d 100644 (file)
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -117,9 +117,10 @@ const char* AddressingString(int addr)
 const char* MemoryString(int mem)
 {
     switch (mem) {
-    case 0:  return "Simple";
-    case 1:  return "GLSL450";
-    case 2:  return "OpenCL";
+    case MemoryModelSimple:     return "Simple";
+    case MemoryModelGLSL450:    return "GLSL450";
+    case MemoryModelOpenCL:     return "OpenCL";
+    case MemoryModelVulkanKHR:  return "VulkanKHR";
 
     default: return "Bad";
     }
@@ -499,19 +500,23 @@ const char* ImageChannelDataTypeString(int type)
     }
 }
 
-const int ImageOperandsCeiling = 8;
+const int ImageOperandsCeiling = 12;
 
 const char* ImageOperandsString(int format)
 {
     switch (format) {
-    case 0: return "Bias";
-    case 1: return "Lod";
-    case 2: return "Grad";
-    case 3: return "ConstOffset";
-    case 4: return "Offset";
-    case 5: return "ConstOffsets";
-    case 6: return "Sample";
-    case 7: return "MinLod";
+    case ImageOperandsBiasShift:                    return "Bias";
+    case ImageOperandsLodShift:                     return "Lod";
+    case ImageOperandsGradShift:                    return "Grad";
+    case ImageOperandsConstOffsetShift:             return "ConstOffset";
+    case ImageOperandsOffsetShift:                  return "Offset";
+    case ImageOperandsConstOffsetsShift:            return "ConstOffsets";
+    case ImageOperandsSampleShift:                  return "Sample";
+    case ImageOperandsMinLodShift:                  return "MinLod";
+    case ImageOperandsMakeTexelAvailableKHRShift:   return "MakeTexelAvailableKHR";
+    case ImageOperandsMakeTexelVisibleKHRShift:     return "MakeTexelVisibleKHR";
+    case ImageOperandsNonPrivateTexelKHRShift:      return "NonPrivateTexelKHR";
+    case ImageOperandsVolatileTexelKHRShift:        return "VolatileTexelKHR";
 
     case ImageOperandsCeiling:
     default:
@@ -645,12 +650,17 @@ const char* MemorySemanticsString(int mem)
     }
 }
 
+const int MemoryAccessCeiling = 6;
+
 const char* MemoryAccessString(int mem)
 {
     switch (mem) {
-    case 0:  return "Volatile";
-    case 1:  return "Aligned";
-    case 2:  return "Nontemporal";
+    case MemoryAccessVolatileShift:                 return "Volatile";
+    case MemoryAccessAlignedShift:                  return "Aligned";
+    case MemoryAccessNontemporalShift:              return "Nontemporal";
+    case MemoryAccessMakePointerAvailableKHRShift:  return "MakePointerAvailableKHR";
+    case MemoryAccessMakePointerVisibleKHRShift:    return "MakePointerVisibleKHR";
+    case MemoryAccessNonPrivatePointerKHRShift:     return "NonPrivatePointerKHR";
 
     default: return "Bad";
     }
@@ -833,6 +843,9 @@ const char* CapabilityString(int info)
     case CapabilityUniformTexelBufferArrayNonUniformIndexingEXT: return "CapabilityUniformTexelBufferArrayNonUniformIndexingEXT";
     case CapabilityStorageTexelBufferArrayNonUniformIndexingEXT: return "CapabilityStorageTexelBufferArrayNonUniformIndexingEXT";
 
+    case CapabilityVulkanMemoryModelKHR:                return "CapabilityVulkanMemoryModelKHR";
+    case CapabilityVulkanMemoryModelDeviceScopeKHR:     return "CapabilityVulkanMemoryModelDeviceScopeKHR";
+
     default: return "Bad";
     }
 }
@@ -1245,6 +1258,7 @@ EnumParameters DecorationParams[DecorationCeiling];
 EnumParameters LoopControlParams[FunctionControlCeiling];
 EnumParameters SelectionControlParams[SelectControlCeiling];
 EnumParameters FunctionControlParams[FunctionControlCeiling];
+EnumParameters MemoryAccessParams[MemoryAccessCeiling];
 
 // Set up all the parameterizing descriptions of the opcodes, operands, etc.
 void Parameterize()
@@ -1400,7 +1414,7 @@ void Parameterize()
     OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
     OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
     OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
-    OperandClassParams[OperandMemoryAccess].set(0, MemoryAccessString, nullptr, true);
+    OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
     OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
     OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
     OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
@@ -1522,10 +1536,14 @@ void Parameterize()
 
     InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'");
     InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true);
+    InstructionDesc[OpLoad].operands.push(OperandLiteralNumber, "", true);
+    InstructionDesc[OpLoad].operands.push(OperandId, "", true);
 
     InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'");
     InstructionDesc[OpStore].operands.push(OperandId, "'Object'");
     InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true);
+    InstructionDesc[OpStore].operands.push(OperandLiteralNumber, "", true);
+    InstructionDesc[OpStore].operands.push(OperandId, "", true);
 
     InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
 

diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index f16c296..622ce61 100644 (file)
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -87,6 +87,7 @@ enum MemoryModel {
     MemoryModelSimple = 0,
     MemoryModelGLSL450 = 1,
     MemoryModelOpenCL = 2,
+    MemoryModelVulkanKHR = 3,
     MemoryModelMax = 0x7fffffff,
 };
 
@@ -275,6 +276,10 @@ enum ImageOperandsShift {
     ImageOperandsConstOffsetsShift = 5,
     ImageOperandsSampleShift = 6,
     ImageOperandsMinLodShift = 7,
+    ImageOperandsMakeTexelAvailableKHRShift = 8,
+    ImageOperandsMakeTexelVisibleKHRShift = 9,
+    ImageOperandsNonPrivateTexelKHRShift = 10,
+    ImageOperandsVolatileTexelKHRShift = 11,
     ImageOperandsMax = 0x7fffffff,
 };
 
@@ -288,6 +293,10 @@ enum ImageOperandsMask {
     ImageOperandsConstOffsetsMask = 0x00000020,
     ImageOperandsSampleMask = 0x00000040,
     ImageOperandsMinLodMask = 0x00000080,
+    ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
+    ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
+    ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
+    ImageOperandsVolatileTexelKHRMask = 0x00000800,
 };
 
 enum FPFastMathModeShift {
@@ -528,6 +537,9 @@ enum MemorySemanticsShift {
     MemorySemanticsCrossWorkgroupMemoryShift = 9,
     MemorySemanticsAtomicCounterMemoryShift = 10,
     MemorySemanticsImageMemoryShift = 11,
+    MemorySemanticsOutputMemoryKHRShift = 12,
+    MemorySemanticsMakeAvailableKHRShift = 13,
+    MemorySemanticsMakeVisibleKHRShift = 14,
     MemorySemanticsMax = 0x7fffffff,
 };
 
@@ -543,12 +555,18 @@ enum MemorySemanticsMask {
     MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
     MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
     MemorySemanticsImageMemoryMask = 0x00000800,
+    MemorySemanticsOutputMemoryKHRMask = 0x00001000,
+    MemorySemanticsMakeAvailableKHRMask = 0x00002000,
+    MemorySemanticsMakeVisibleKHRMask = 0x00004000,
 };
 
 enum MemoryAccessShift {
     MemoryAccessVolatileShift = 0,
     MemoryAccessAlignedShift = 1,
     MemoryAccessNontemporalShift = 2,
+    MemoryAccessMakePointerAvailableKHRShift = 3,
+    MemoryAccessMakePointerVisibleKHRShift = 4,
+    MemoryAccessNonPrivatePointerKHRShift = 5,
     MemoryAccessMax = 0x7fffffff,
 };
 
@@ -557,6 +575,9 @@ enum MemoryAccessMask {
     MemoryAccessVolatileMask = 0x00000001,
     MemoryAccessAlignedMask = 0x00000002,
     MemoryAccessNontemporalMask = 0x00000004,
+    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
 };
 
 enum Scope {
@@ -565,6 +586,7 @@ enum Scope {
     ScopeWorkgroup = 2,
     ScopeSubgroup = 3,
     ScopeInvocation = 4,
+    ScopeQueueFamilyKHR = 5,\r
     ScopeMax = 0x7fffffff,
 };
 
@@ -708,6 +730,8 @@ enum Capability {
     CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
     CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
     CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+    CapabilityVulkanMemoryModelKHR = 5345,
+    CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,\r
     CapabilitySubgroupShuffleINTEL = 5568,
     CapabilitySubgroupBufferBlockIOINTEL = 5569,
     CapabilitySubgroupImageBlockIOINTEL = 5570,

diff --git a/Test/baseResults/spv.memoryScopeSemantics.comp.out b/Test/baseResults/spv.memoryScopeSemantics.comp.out
new file mode 100644 (file)
index 0000000..cf00754
--- /dev/null
+++ b/Test/baseResults/spv.memoryScopeSemantics.comp.out
@@ -0,0 +1,243 @@
+spv.memoryScopeSemantics.comp
+error: SPIRV-Tools Validation Errors
+error: Capability Int64Atomics is not allowed by Vulkan 1.0 specification (or requires extension)
+  OpCapability Int64Atomics
+
+// Module Version 10000
+// Generated by (magic number): 80007
+// Id's are bound by 142
+
+                              Capability Shader
+                              Capability Int64
+                              Capability Int64Atomics
+                              Capability CapabilityVulkanMemoryModelKHR
+                              Capability CapabilityVulkanMemoryModelDeviceScopeKHR
+                              Extension  "SPV_KHR_vulkan_memory_model"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical VulkanKHR
+                              EntryPoint GLCompute 4  "main"
+                              ExecutionMode 4 LocalSize 1 1 1
+                              Source GLSL 450
+                              SourceExtension  "GL_ARB_gpu_shader_int64"
+                              SourceExtension  "GL_KHR_memory_scope_semantics"
+                              Name 4  "main"
+                              Name 8  "origi"
+                              Name 10  "atomi"
+                              Name 21  "origu"
+                              Name 23  "atomu"
+                              Name 24  "value"
+                              Name 36  "imagei"
+                              Name 45  "imageu"
+                              Name 65  "BufferU"
+                              MemberName 65(BufferU) 0  "x"
+                              Name 67  "bufferu"
+                              Name 72  "y"
+                              Name 77  "BufferI"
+                              MemberName 77(BufferI) 0  "x"
+                              Name 79  "bufferi"
+                              Name 83  "A"
+                              MemberName 83(A) 0  "x"
+                              Name 84  "BufferJ"
+                              MemberName 84(BufferJ) 0  "a"
+                              Name 87  "bufferj"
+                              Name 98  "BufferK"
+                              MemberName 98(BufferK) 0  "x"
+                              Name 100  "bufferk"
+                              Name 109  "imagej"
+                              Name 121  "samp"
+                              Name 132  "atomu64"
+                              Name 137  "atomi64"
+                              Decorate 36(imagei) DescriptorSet 0
+                              Decorate 36(imagei) Binding 1
+                              Decorate 45(imageu) DescriptorSet 0
+                              Decorate 45(imageu) Binding 0
+                              MemberDecorate 65(BufferU) 0 Offset 0
+                              Decorate 65(BufferU) BufferBlock
+                              Decorate 67(bufferu) DescriptorSet 0
+                              Decorate 67(bufferu) Binding 2
+                              MemberDecorate 77(BufferI) 0 Offset 0
+                              Decorate 77(BufferI) BufferBlock
+                              Decorate 79(bufferi) DescriptorSet 0
+                              Decorate 79(bufferi) Binding 3
+                              Decorate 82 ArrayStride 4
+                              MemberDecorate 83(A) 0 Offset 0
+                              MemberDecorate 84(BufferJ) 0 Offset 0
+                              Decorate 84(BufferJ) BufferBlock
+                              Decorate 87(bufferj) DescriptorSet 0
+                              Decorate 87(bufferj) Binding 4
+                              MemberDecorate 98(BufferK) 0 Offset 0
+                              Decorate 98(BufferK) Block
+                              Decorate 100(bufferk) DescriptorSet 0
+                              Decorate 100(bufferk) Binding 7
+                              Decorate 109(imagej) DescriptorSet 0
+                              Decorate 109(imagej) Binding 5
+                              Decorate 121(samp) DescriptorSet 0
+                              Decorate 121(samp) Binding 6
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeInt 32 1
+               7:             TypePointer Function 6(int)
+               9:             TypePointer Workgroup 6(int)
+       10(atomi):      9(ptr) Variable Workgroup
+              11:      6(int) Constant 3
+              12:      6(int) Constant 1
+              13:      6(int) Constant 320
+              14:      6(int) Constant 4
+              15:             TypeInt 32 0
+              16:     15(int) Constant 5
+              17:     15(int) Constant 0
+              18:     15(int) Constant 324
+              20:             TypePointer Function 15(int)
+              22:             TypePointer Workgroup 15(int)
+       23(atomu):     22(ptr) Variable Workgroup
+       24(value):     22(ptr) Variable Workgroup
+              26:     15(int) Constant 2
+              28:      6(int) Constant 64
+              29:      6(int) Constant 2
+              30:     15(int) Constant 66
+              33:     15(int) Constant 68
+              34:             TypeImage 6(int) 2D nonsampled format:R32i
+              35:             TypePointer UniformConstant 34
+      36(imagei):     35(ptr) Variable UniformConstant
+              37:             TypeVector 6(int) 2
+              38:      6(int) Constant 0
+              39:   37(ivec2) ConstantComposite 38 38
+              40:             TypePointer Image 6(int)
+              43:             TypeImage 15(int) 2D nonsampled format:R32ui
+              44:             TypePointer UniformConstant 43
+      45(imageu):     44(ptr) Variable UniformConstant
+              46:     15(int) Constant 3
+              47:             TypePointer Image 15(int)
+              50:     15(int) Constant 4
+              52:     15(int) Constant 7
+              57:      6(int) Constant 7
+              61:     15(int) Constant 10
+              63:     15(int) Constant 322
+     65(BufferU):             TypeStruct 15(int)
+              66:             TypePointer Uniform 65(BufferU)
+     67(bufferu):     66(ptr) Variable Uniform
+              68:             TypePointer Uniform 15(int)
+              70:     15(int) Constant 1
+     77(BufferI):             TypeStruct 15(int)
+              78:             TypePointer Uniform 77(BufferI)
+     79(bufferi):     78(ptr) Variable Uniform
+              82:             TypeArray 15(int) 26
+           83(A):             TypeStruct 82
+     84(BufferJ):             TypeStruct 83(A)
+              85:             TypeArray 84(BufferJ) 26
+              86:             TypePointer Uniform 85
+     87(bufferj):     86(ptr) Variable Uniform
+              94:             TypePointer Uniform 83(A)
+     98(BufferK):             TypeStruct 15(int)
+              99:             TypePointer Uniform 98(BufferK)
+    100(bufferk):     99(ptr) Variable Uniform
+             105:             TypeVector 6(int) 4
+             107:             TypeArray 34 26
+             108:             TypePointer UniformConstant 107
+     109(imagej):    108(ptr) Variable UniformConstant
+             115:  105(ivec4) ConstantComposite 38 38 38 38
+             116:             TypeFloat 32
+             117:             TypeImage 116(float) 2D sampled format:Unknown
+             118:             TypeSampledImage 117
+             119:             TypeArray 118 26
+             120:             TypePointer UniformConstant 119
+       121(samp):    120(ptr) Variable UniformConstant
+             122:             TypePointer UniformConstant 118
+             125:             TypeVector 116(float) 2
+             126:  116(float) Constant 0
+             127:  125(fvec2) ConstantComposite 126 126
+             128:             TypeVector 116(float) 4
+             130:             TypeInt 64 0
+             131:             TypePointer Workgroup 130(int64_t)
+    132(atomu64):    131(ptr) Variable Workgroup
+             133:130(int64_t) Constant 7 0
+             135:             TypeInt 64 1
+             136:             TypePointer Workgroup 135(int64_t)
+    137(atomi64):    136(ptr) Variable Workgroup
+             138:135(int64_t) Constant 10 0
+         4(main):           2 Function None 3
+               5:             Label
+        8(origi):      7(ptr) Variable Function
+       21(origu):     20(ptr) Variable Function
+           72(y):     20(ptr) Variable Function
+              19:      6(int) AtomicIAdd 10(atomi) 12 18 11
+                              Store 8(origi) 19
+              25:     15(int) Load 24(value) MakePointerVisibleKHR 26
+              27:     15(int) AtomicAnd 23(atomu) 16 17 25
+                              Store 21(origu) 27
+              31:      6(int) AtomicLoad 10(atomi) 12 30
+                              Store 8(origi) 31
+              32:     15(int) Load 24(value) MakePointerVisibleKHR 26
+                              AtomicStore 23(atomu) 12 33 32
+              41:     40(ptr) ImageTexelPointer 36(imagei) 39 17
+              42:      6(int) AtomicLoad 41 12 30
+                              Store 8(origi) 42
+              48:     47(ptr) ImageTexelPointer 45(imageu) 39 17
+              49:     15(int) AtomicIAdd 48 12 30 46
+                              Store 21(origu) 49
+              51:     47(ptr) ImageTexelPointer 45(imageu) 39 17
+                              AtomicStore 51 12 33 50
+              53:     15(int) AtomicOr 23(atomu) 12 17 52
+                              Store 21(origu) 53
+              54:     15(int) AtomicXor 23(atomu) 12 17 52
+                              Store 21(origu) 54
+              55:     15(int) Load 24(value) MakePointerVisibleKHR 26
+              56:     15(int) AtomicUMin 23(atomu) 12 17 55
+                              Store 21(origu) 56
+              58:      6(int) AtomicSMax 10(atomi) 12 17 57
+                              Store 8(origi) 58
+              59:      6(int) Load 8(origi)
+              60:      6(int) AtomicExchange 10(atomi) 12 17 59
+                              Store 8(origi) 60
+              62:     15(int) Load 24(value) MakePointerVisibleKHR 26
+              64:     15(int) AtomicCompareExchange 23(atomu) 12 63 63 62 61
+                              Store 21(origu) 64
+              69:     68(ptr) AccessChain 67(bufferu) 38
+              71:     15(int) AtomicIAdd 69 12 18 70
+                              MemoryBarrier 26 18
+                              ControlBarrier 26 26 63
+                              ControlBarrier 26 26 17
+              73:     68(ptr) AccessChain 67(bufferu) 38
+              74:     15(int) Load 73 MakePointerVisibleKHR NonPrivatePointerKHR 26
+                              Store 72(y) 74
+              75:     15(int) Load 72(y)
+              76:     68(ptr) AccessChain 67(bufferu) 38
+                              Store 76 75 MakePointerAvailableKHR NonPrivatePointerKHR 26
+              80:     68(ptr) AccessChain 79(bufferi) 38
+              81:     15(int) Load 80 MakePointerVisibleKHR NonPrivatePointerKHR 16
+                              Store 72(y) 81
+              88:     68(ptr) AccessChain 87(bufferj) 38 38 38 12
+              89:     15(int) Load 88 Volatile MakePointerVisibleKHR NonPrivatePointerKHR 46
+                              Store 72(y) 89
+              90:     15(int) Load 72(y)
+              91:     68(ptr) AccessChain 79(bufferi) 38
+                              Store 91 90 MakePointerAvailableKHR NonPrivatePointerKHR 16
+              92:     15(int) Load 72(y)
+              93:     68(ptr) AccessChain 87(bufferj) 38 38 38 12
+                              Store 93 92 Volatile MakePointerAvailableKHR NonPrivatePointerKHR 46
+              95:     94(ptr) AccessChain 87(bufferj) 12 38
+              96:       83(A) Load 95 Volatile MakePointerVisibleKHR NonPrivatePointerKHR 46
+              97:     94(ptr) AccessChain 87(bufferj) 38 38
+                              Store 97 96 Volatile MakePointerAvailableKHR NonPrivatePointerKHR 46
+             101:     68(ptr) AccessChain 100(bufferk) 38
+             102:     15(int) Load 101 NonPrivatePointerKHR 
+             103:     68(ptr) AccessChain 79(bufferi) 38
+                              Store 103 102 MakePointerAvailableKHR NonPrivatePointerKHR 16
+             104:          34 Load 36(imagei)
+             106:  105(ivec4) ImageRead 104 39 MakeTexelVisibleKHR NonPrivateTexelKHR VolatileTexelKHR 16
+             110:     35(ptr) AccessChain 109(imagej) 38
+             111:          34 Load 110
+             112:  105(ivec4) ImageRead 111 39 NonPrivateTexelKHR 
+             113:     35(ptr) AccessChain 109(imagej) 12
+             114:          34 Load 113
+                              ImageWrite 114 39 115 NonPrivateTexelKHR 
+             123:    122(ptr) AccessChain 121(samp) 38
+             124:         118 Load 123
+             129:  128(fvec4) ImageSampleExplicitLod 124 127 Lod NonPrivateTexelKHR 126
+             134:130(int64_t) AtomicUMax 132(atomu64) 12 17 133
+                              Store 132(atomu64) 134 MakePointerAvailableKHR 26
+             139:130(int64_t) Load 132(atomu64) MakePointerVisibleKHR 26
+             140:135(int64_t) Bitcast 139
+             141:135(int64_t) AtomicCompareExchange 137(atomi64) 12 63 63 140 138
+                              Return
+                              FunctionEnd

diff --git a/Test/baseResults/spv.memoryScopeSemantics_Error.comp.out b/Test/baseResults/spv.memoryScopeSemantics_Error.comp.out
new file mode 100644 (file)
index 0000000..c4149d8
--- /dev/null
+++ b/Test/baseResults/spv.memoryScopeSemantics_Error.comp.out
@@ -0,0 +1,17 @@
+spv.memoryScopeSemantics_Error.comp
+ERROR: 0:15: 'atomicStore' : gl_SemanticsAcquire must not be used with (image) atomic store 
+ERROR: 0:16: 'imageAtomicLoad' : gl_SemanticsRelease must not be used with (image) atomic load 
+ERROR: 0:17: 'atomicStore' : gl_SemanticsAcquireRelease must not be used with (image) atomic load/store 
+ERROR: 0:18: 'atomicStore' : Invalid semantics value 
+ERROR: 0:19: 'imageAtomicLoad' : Invalid storage class semantics value 
+ERROR: 0:20: 'memoryBarrier' : Semantics must include exactly one of gl_SemanticsRelease, gl_SemanticsAcquire, or gl_SemanticsAcquireRelease 
+ERROR: 0:21: 'memoryBarrier' : Storage class semantics must not be zero 
+ERROR: 0:22: 'memoryBarrier' : Semantics must include exactly one of gl_SemanticsRelease, gl_SemanticsAcquire, or gl_SemanticsAcquireRelease 
+ERROR: 0:23: 'atomicAdd' : Semantics must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or gl_SemanticsAcquireRelease 
+ERROR: 0:24: 'atomicCompSwap' : semUnequal must not be gl_SemanticsRelease or gl_SemanticsAcquireRelease 
+ERROR: 0:25: 'memoryBarrier' : gl_SemanticsMakeVisible requires gl_SemanticsAcquire or gl_SemanticsAcquireRelease 
+ERROR: 0:26: 'memoryBarrier' : gl_SemanticsMakeAvailable requires gl_SemanticsRelease or gl_SemanticsAcquireRelease 
+ERROR: 12 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

diff --git a/Test/baseResults/spv.specConstant.vert.out b/Test/baseResults/spv.specConstant.vert.out
index beda9e0..0d47dce 100644 (file)
--- a/Test/baseResults/spv.specConstant.vert.out
+++ b/Test/baseResults/spv.specConstant.vert.out
@@ -11,7 +11,7 @@ spv.specConstant.vert
                               Source GLSL 400
                               Name 4  "main"
                               Name 9  "arraySize"
-                              Name 14  "foo(vf4[s2543];"
+                              Name 14  "foo(vf4[s2765];"
                               Name 13  "p"
                               Name 17  "builtin_spec_constant("
                               Name 20  "color"
@@ -102,10 +102,10 @@ spv.specConstant.vert
                               Store 20(color) 46
               48:          10 Load 22(ucol)
                               Store 47(param) 48
-              49:           2 FunctionCall 14(foo(vf4[s2543];) 47(param)
+              49:           2 FunctionCall 14(foo(vf4[s2765];) 47(param)
                               Return
                               FunctionEnd
-14(foo(vf4[s2543];):           2 Function None 12
+14(foo(vf4[s2765];):           2 Function None 12
            13(p):     11(ptr) FunctionParameter
               15:             Label
               54:     24(ptr) AccessChain 53(dupUcol) 23

diff --git a/Test/spv.memoryScopeSemantics.comp b/Test/spv.memoryScopeSemantics.comp
new file mode 100644 (file)
index 0000000..c03c123
--- /dev/null
+++ b/Test/spv.memoryScopeSemantics.comp
@@ -0,0 +1,61 @@
+#version 450\r
+#extension GL_KHR_memory_scope_semantics : require\r
+#extension GL_ARB_gpu_shader_int64 : require\r
+\r
+#pragma use_vulkan_memory_model\r
+\r
+shared uint value;\r
+shared int atomi;\r
+shared uint atomu;\r
+layout(binding = 0, r32ui) workgroupcoherent uniform uimage2D imageu;\r
+layout(binding = 1, r32i) volatile coherent uniform iimage2D imagei;\r
+layout(binding = 5, r32i) nonprivate uniform iimage2D imagej[2];\r
+layout (binding = 2) buffer BufferU { workgroupcoherent uint x; } bufferu;\r
+layout (binding = 3) coherent buffer BufferI { uint x; } bufferi;\r
+struct A { uint x[2]; };\r
+layout (binding = 4) volatile buffer BufferJ { subgroupcoherent A a; } bufferj[2];\r
+layout (binding = 6) nonprivate uniform sampler2D samp[2];\r
+layout (binding = 7) nonprivate uniform BufferK { uint x; } bufferk;\r
+shared uint64_t atomu64;\r
+shared int64_t atomi64;\r
+\r
+\r
+void main()\r
+{\r
+    int origi = atomicAdd(atomi, 3, gl_ScopeDevice, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsRelease);\r
+    uint origu = atomicAnd(atomu, value);\r
+    origi = atomicLoad(atomi, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsAcquire);\r
+    atomicStore(atomu, value, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsRelease);\r
+    origi = imageAtomicLoad(imagei, ivec2(0,0), gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsAcquire);\r
+    origu = imageAtomicAdd(imageu, ivec2(0,0), 3u, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsAcquire);\r
+    imageAtomicStore(imageu, ivec2(0,0), 4u, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsRelease);\r
+    origu = atomicOr(atomu, 7u, gl_ScopeDevice, 0, 0);\r
+    origu = atomicXor(atomu, 7u, gl_ScopeDevice, 0, 0);\r
+    origu = atomicMin(atomu, value, gl_ScopeDevice, 0, 0);\r
+    origi = atomicMax(atomi, 7, gl_ScopeDevice, 0, 0);\r
+    origi = atomicExchange(atomi, origi, gl_ScopeDevice, 0, 0);\r
+    origu = atomicCompSwap(atomu, 10u, value, gl_ScopeDevice, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire);\r
+    atomicAdd(bufferu.x, 1, gl_ScopeDevice, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsRelease);\r
+    memoryBarrier(gl_ScopeWorkgroup, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsRelease);\r
+    controlBarrier(gl_ScopeWorkgroup, gl_ScopeWorkgroup, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire);\r
+    controlBarrier(gl_ScopeWorkgroup, gl_ScopeWorkgroup, 0, 0);\r
+\r
+    uint y;\r
+    y = bufferu.x;\r
+    bufferu.x = y;\r
+    y = bufferi.x;\r
+    y = bufferj[0].a.x[1];\r
+    bufferi.x = y;\r
+    bufferj[0].a.x[1] = y;\r
+    bufferj[0].a = bufferj[1].a;\r
+    bufferi.x = bufferk.x;\r
+\r
+    imageLoad(imagei, ivec2(0,0));\r
+    imageLoad(imagej[0], ivec2(0,0));\r
+    imageStore(imagej[1], ivec2(0,0), ivec4(0,0,0,0));\r
+    texture(samp[0], vec2(0,0));\r
+\r
+    atomu64 = atomicMax(atomu64, uint64_t(7), gl_ScopeDevice, 0, 0);\r
+    atomicCompSwap(atomi64, int64_t(10), int64_t(atomu64), gl_ScopeDevice, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire);\r
+}\r
+\r

diff --git a/Test/spv.memoryScopeSemantics_Error.comp b/Test/spv.memoryScopeSemantics_Error.comp
new file mode 100644 (file)
index 0000000..4e18b2e
--- /dev/null
+++ b/Test/spv.memoryScopeSemantics_Error.comp
@@ -0,0 +1,28 @@
+#version 450\r
+#extension GL_KHR_memory_scope_semantics : require\r
+\r
+\r
+shared uint value;\r
+shared int atomi;\r
+shared uint atomu;\r
+layout(binding = 0, r32ui) workgroupcoherent uniform uimage2D imageu;\r
+layout(binding = 1, r32i) coherent uniform iimage2D imagei;\r
+layout (binding = 2) buffer BufferU { workgroupcoherent uint x; } bufferu;\r
+layout (binding = 3) subgroupcoherent buffer BufferI { uint x; } bufferi;\r
+\r
+void main()\r
+{\r
+    atomicStore(atomu, value, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsAcquire);\r
+    int origi = imageAtomicLoad(imagei, ivec2(0,0), gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsRelease);\r
+    atomicStore(atomu, value, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsAcquireRelease);\r
+    atomicStore(atomu, value, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_StorageSemanticsBuffer);\r
+    origi = imageAtomicLoad(imagei, ivec2(0,0), gl_ScopeDevice, gl_SemanticsAcquire, gl_SemanticsAcquire);\r
+    memoryBarrier(gl_ScopeWorkgroup, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, 0);\r
+    memoryBarrier(gl_ScopeWorkgroup, 0, gl_SemanticsRelease);\r
+    memoryBarrier(gl_ScopeWorkgroup, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsRelease | gl_SemanticsAcquire);\r
+    atomicAdd(atomu, value, gl_ScopeDevice, gl_StorageSemanticsBuffer, gl_SemanticsRelease | gl_SemanticsAcquire);\r
+    uint origu = atomicCompSwap(atomu, 10u, value, gl_ScopeDevice, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquire, gl_StorageSemanticsBuffer | gl_StorageSemanticsShared, gl_SemanticsAcquireRelease);\r
+    memoryBarrier(gl_ScopeWorkgroup, gl_StorageSemanticsBuffer, gl_SemanticsRelease | gl_SemanticsMakeVisible);\r
+    memoryBarrier(gl_ScopeWorkgroup, gl_StorageSemanticsBuffer, gl_SemanticsAcquire | gl_SemanticsMakeAvailable);\r
+}\r
+\r

diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h
index b877c15..3928932 100644 (file)
--- a/glslang/Include/Types.h
+++ b/glslang/Include/Types.h
@@ -462,6 +462,11 @@ public:
     void clearMemory()
     {
         coherent     = false;
+        devicecoherent = false;
+        queuefamilycoherent = false;
+        workgroupcoherent = false;
+        subgroupcoherent  = false;
+        nonprivate = false;
         volatil      = false;
         restrict     = false;
         readonly     = false;
@@ -499,6 +504,11 @@ public:
     bool patch        : 1;
     bool sample       : 1;
     bool coherent     : 1;
+    bool devicecoherent : 1;
+    bool queuefamilycoherent : 1;
+    bool workgroupcoherent : 1;
+    bool subgroupcoherent  : 1;
+    bool nonprivate   : 1;
     bool volatil      : 1;
     bool restrict     : 1;
     bool readonly     : 1;
@@ -508,7 +518,11 @@ public:
 
     bool isMemory() const
     {
-        return coherent || volatil || restrict || readonly || writeonly;
+        return subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate;
+    }
+    bool isMemoryQualifierImageAndSSBOOnly() const
+    {
+        return subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly;
     }
     bool isInterpolation() const
     {
@@ -1713,6 +1727,16 @@ public:
             appendStr(" sample");
         if (qualifier.coherent)
             appendStr(" coherent");
+        if (qualifier.devicecoherent)
+            appendStr(" devicecoherent");
+        if (qualifier.queuefamilycoherent)
+            appendStr(" queuefamilycoherent");
+        if (qualifier.workgroupcoherent)
+            appendStr(" workgroupcoherent");
+        if (qualifier.subgroupcoherent)
+            appendStr(" subgroupcoherent");
+        if (qualifier.nonprivate)
+            appendStr(" nonprivate");
         if (qualifier.volatil)
             appendStr(" volatile");
         if (qualifier.restrict)

diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
index 96c8749..b125adb 100644 (file)
--- a/glslang/Include/intermediate.h
+++ b/glslang/Include/intermediate.h
@@ -592,6 +592,8 @@ enum TOperator {
     EOpAtomicXor,
     EOpAtomicExchange,
     EOpAtomicCompSwap,
+    EOpAtomicLoad,
+    EOpAtomicStore,
 
     EOpAtomicCounterIncrement, // results in pre-increment value
     EOpAtomicCounterDecrement, // results in post-decrement value
@@ -784,6 +786,8 @@ enum TOperator {
     EOpImageAtomicXor,
     EOpImageAtomicExchange,
     EOpImageAtomicCompSwap,
+    EOpImageAtomicLoad,
+    EOpImageAtomicStore,
 
     EOpSubpassLoad,
     EOpSubpassLoadMS,

diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp
index 27bd9ac..b800509 100644 (file)
--- a/glslang/MachineIndependent/Initialize.cpp
+++ b/glslang/MachineIndependent/Initialize.cpp
@@ -935,27 +935,49 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
         commonBuiltins.append(
             "uint atomicAdd(coherent volatile inout uint, uint);"
             " int atomicAdd(coherent volatile inout  int,  int);"
+            "uint atomicAdd(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicAdd(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicMin(coherent volatile inout uint, uint);"
             " int atomicMin(coherent volatile inout  int,  int);"
+            "uint atomicMin(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicMin(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicMax(coherent volatile inout uint, uint);"
             " int atomicMax(coherent volatile inout  int,  int);"
+            "uint atomicMax(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicMax(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicAnd(coherent volatile inout uint, uint);"
             " int atomicAnd(coherent volatile inout  int,  int);"
+            "uint atomicAnd(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicAnd(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicOr (coherent volatile inout uint, uint);"
             " int atomicOr (coherent volatile inout  int,  int);"
+            "uint atomicOr (coherent volatile inout uint, uint, int, int, int);"
+            " int atomicOr (coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicXor(coherent volatile inout uint, uint);"
             " int atomicXor(coherent volatile inout  int,  int);"
+            "uint atomicXor(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicXor(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicExchange(coherent volatile inout uint, uint);"
             " int atomicExchange(coherent volatile inout  int,  int);"
+            "uint atomicExchange(coherent volatile inout uint, uint, int, int, int);"
+            " int atomicExchange(coherent volatile inout  int,  int, int, int, int);"
 
             "uint atomicCompSwap(coherent volatile inout uint, uint, uint);"
             " int atomicCompSwap(coherent volatile inout  int,  int,  int);"
+            "uint atomicCompSwap(coherent volatile inout uint, uint, uint, int, int, int, int, int);"
+            " int atomicCompSwap(coherent volatile inout  int,  int,  int, int, int, int, int, int);"
+
+            "uint atomicLoad(coherent volatile in uint, int, int, int);"
+            " int atomicLoad(coherent volatile in  int, int, int, int);"
+
+            "void atomicStore(coherent volatile out uint, uint, int, int, int);"
+            "void atomicStore(coherent volatile out  int,  int, int, int, int);"
 
             "\n");
     }
@@ -965,23 +987,49 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
         commonBuiltins.append(
             "uint64_t atomicMin(coherent volatile inout uint64_t, uint64_t);"
             " int64_t atomicMin(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicMin(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicMin(coherent volatile inout  int64_t,  int64_t, int, int, int);"
 
             "uint64_t atomicMax(coherent volatile inout uint64_t, uint64_t);"
             " int64_t atomicMax(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicMax(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicMax(coherent volatile inout  int64_t,  int64_t, int, int, int);"
 
             "uint64_t atomicAnd(coherent volatile inout uint64_t, uint64_t);"
             " int64_t atomicAnd(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicAnd(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicAnd(coherent volatile inout  int64_t,  int64_t, int, int, int);"
 
             "uint64_t atomicOr (coherent volatile inout uint64_t, uint64_t);"
             " int64_t atomicOr (coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicOr (coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicOr (coherent volatile inout  int64_t,  int64_t, int, int, int);"
 
             "uint64_t atomicXor(coherent volatile inout uint64_t, uint64_t);"
             " int64_t atomicXor(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicXor(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicXor(coherent volatile inout  int64_t,  int64_t, int, int, int);"
+
+            "uint64_t atomicAdd(coherent volatile inout uint64_t, uint64_t);"
+            " int64_t atomicAdd(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicAdd(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicAdd(coherent volatile inout  int64_t,  int64_t, int, int, int);"
+
+            "uint64_t atomicExchange(coherent volatile inout uint64_t, uint64_t);"
+            " int64_t atomicExchange(coherent volatile inout  int64_t,  int64_t);"
+            "uint64_t atomicExchange(coherent volatile inout uint64_t, uint64_t, int, int, int);"
+            " int64_t atomicExchange(coherent volatile inout  int64_t,  int64_t, int, int, int);"
 
-            " int64_t atomicAdd(coherent volatile inout int64_t, int64_t);"
-            " int64_t atomicExchange(coherent volatile inout int64_t, int64_t);"
-            " int64_t atomicCompSwap(coherent volatile inout int64_t, int64_t, int64_t);"
+            "uint64_t atomicCompSwap(coherent volatile inout uint64_t, uint64_t, uint64_t);"
+            " int64_t atomicCompSwap(coherent volatile inout  int64_t,  int64_t,  int64_t);"
+            "uint64_t atomicCompSwap(coherent volatile inout uint64_t, uint64_t, uint64_t, int, int, int, int, int);"
+            " int64_t atomicCompSwap(coherent volatile inout  int64_t,  int64_t,  int64_t, int, int, int, int, int);"
 
+            "uint64_t atomicLoad(coherent volatile in uint64_t, int, int, int);"
+            " int64_t atomicLoad(coherent volatile in  int64_t, int, int, int);"
+
+            "void atomicStore(coherent volatile out uint64_t, uint64_t, int, int, int);"
+            "void atomicStore(coherent volatile out  int64_t,  int64_t, int, int, int);"
             "\n");
     }
 #endif
@@ -4693,6 +4741,9 @@ 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");
+
     //============================================================================
     //
     // Prototypes for built-in functions seen by fragment shaders only.
@@ -5807,6 +5858,28 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
             "\n");
     }
 
+    if ((profile != EEsProfile && version >= 420) ||
+        (profile == EEsProfile && version >= 310)) {
+        commonBuiltins.append("const int gl_ScopeDevice      = 1;\n");
+        commonBuiltins.append("const int gl_ScopeWorkgroup   = 2;\n");
+        commonBuiltins.append("const int gl_ScopeSubgroup    = 3;\n");
+        commonBuiltins.append("const int gl_ScopeInvocation  = 4;\n");
+        commonBuiltins.append("const int gl_ScopeQueueFamily = 5;\n");
+
+        commonBuiltins.append("const int gl_SemanticsRelaxed         = 0x0;\n");
+        commonBuiltins.append("const int gl_SemanticsAcquire         = 0x2;\n");
+        commonBuiltins.append("const int gl_SemanticsRelease         = 0x4;\n");
+        commonBuiltins.append("const int gl_SemanticsAcquireRelease  = 0x8;\n");
+        commonBuiltins.append("const int gl_SemanticsMakeAvailable   = 0x2000;\n");
+        commonBuiltins.append("const int gl_SemanticsMakeVisible     = 0x4000;\n");
+
+        commonBuiltins.append("const int gl_StorageSemanticsNone     = 0x0;\n");
+        commonBuiltins.append("const int gl_StorageSemanticsBuffer   = 0x40;\n");
+        commonBuiltins.append("const int gl_StorageSemanticsShared   = 0x100;\n");
+        commonBuiltins.append("const int gl_StorageSemanticsImage    = 0x800;\n");
+        commonBuiltins.append("const int gl_StorageSemanticsOutput   = 0x1000;\n");
+    }
+
     // printf("%s\n", commonBuiltins.c_str());
     // printf("%s\n", stageBuiltins[EShLangFragment].c_str());
 }
@@ -6106,23 +6179,44 @@ void TBuiltIns::addImageFunctions(TSampler sampler, const TString& typeName, int
                 " imageAtomicExchange(volatile coherent "
             };
 
-            for (size_t i = 0; i < numBuiltins; ++i) {
+            // Loop twice to add prototypes with/without scope/semantics
+            for (int j = 0; j < 2; ++j) {
+                for (size_t i = 0; i < numBuiltins; ++i) {
+                    commonBuiltins.append(dataType);
+                    commonBuiltins.append(atomicFunc[i]);
+                    commonBuiltins.append(imageParams);
+                    commonBuiltins.append(", ");
+                    commonBuiltins.append(dataType);
+                    if (j == 1) {
+                        commonBuiltins.append(", int, int, int");
+                    }
+                    commonBuiltins.append(");\n");
+                }
+
                 commonBuiltins.append(dataType);
-                commonBuiltins.append(atomicFunc[i]);
+                commonBuiltins.append(" imageAtomicCompSwap(volatile coherent ");
                 commonBuiltins.append(imageParams);
                 commonBuiltins.append(", ");
                 commonBuiltins.append(dataType);
+                commonBuiltins.append(", ");
+                commonBuiltins.append(dataType);
+                if (j == 1) {
+                    commonBuiltins.append(", int, int, int, int, int");
+                }
                 commonBuiltins.append(");\n");
             }
 
             commonBuiltins.append(dataType);
-            commonBuiltins.append(" imageAtomicCompSwap(volatile coherent ");
+            commonBuiltins.append(" imageAtomicLoad(volatile coherent ");
+            commonBuiltins.append(imageParams);
+            commonBuiltins.append(", int, int, int);\n");
+
+            commonBuiltins.append("void imageAtomicStore(volatile coherent ");
             commonBuiltins.append(imageParams);
             commonBuiltins.append(", ");
             commonBuiltins.append(dataType);
-            commonBuiltins.append(", ");
-            commonBuiltins.append(dataType);
-            commonBuiltins.append(");\n");
+            commonBuiltins.append(", int, int, int);\n");
+
         } else {
             // not int or uint
             // GL_ARB_ES3_1_compatibility
@@ -7969,6 +8063,26 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
             symbolTable.setFunctionExtensions("shadow2DEXT",        1, &E_GL_EXT_shadow_samplers);
             symbolTable.setFunctionExtensions("shadow2DProjEXT",    1, &E_GL_EXT_shadow_samplers);
         }
+
+        if (spvVersion.vulkan > 0) {
+            symbolTable.setVariableExtensions("gl_ScopeDevice",             1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_ScopeWorkgroup",          1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_ScopeSubgroup",           1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_ScopeInvocation",         1, &E_GL_KHR_memory_scope_semantics);
+
+            symbolTable.setVariableExtensions("gl_SemanticsRelaxed",        1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_SemanticsAcquire",        1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_SemanticsRelease",        1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_SemanticsAcquireRelease", 1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_SemanticsMakeAvailable",  1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_SemanticsMakeVisible",    1, &E_GL_KHR_memory_scope_semantics);
+
+            symbolTable.setVariableExtensions("gl_StorageSemanticsNone",    1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_StorageSemanticsBuffer",  1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_StorageSemanticsShared",  1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_StorageSemanticsImage",   1, &E_GL_KHR_memory_scope_semantics);
+            symbolTable.setVariableExtensions("gl_StorageSemanticsOutput",  1, &E_GL_KHR_memory_scope_semantics);
+        }
         break;
 
     case EShLangCompute:
@@ -8003,6 +8117,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
             symbolTable.setFunctionExtensions("groupMemoryBarrier",         1, &E_GL_ARB_compute_shader);
         }
 
+        symbolTable.setFunctionExtensions("controlBarrier",                 1, &E_GL_KHR_memory_scope_semantics);
+
         // GL_ARB_shader_ballot
         if (profile != EEsProfile) {
             symbolTable.setVariableExtensions("gl_SubGroupSizeARB",       1, &E_GL_ARB_shader_ballot);
@@ -8213,6 +8329,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
     symbolTable.relateToOperator("all",          EOpAll);
 
     symbolTable.relateToOperator("barrier",                    EOpBarrier);
+    symbolTable.relateToOperator("controlBarrier",             EOpBarrier);
     symbolTable.relateToOperator("memoryBarrier",              EOpMemoryBarrier);
     symbolTable.relateToOperator("memoryBarrierAtomicCounter", EOpMemoryBarrierAtomicCounter);
     symbolTable.relateToOperator("memoryBarrierBuffer",        EOpMemoryBarrierBuffer);
@@ -8226,6 +8343,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
     symbolTable.relateToOperator("atomicXor",      EOpAtomicXor);
     symbolTable.relateToOperator("atomicExchange", EOpAtomicExchange);
     symbolTable.relateToOperator("atomicCompSwap", EOpAtomicCompSwap);
+    symbolTable.relateToOperator("atomicLoad",     EOpAtomicLoad);
+    symbolTable.relateToOperator("atomicStore",    EOpAtomicStore);
 
     symbolTable.relateToOperator("atomicCounterIncrement", EOpAtomicCounterIncrement);
     symbolTable.relateToOperator("atomicCounterDecrement", EOpAtomicCounterDecrement);
@@ -8270,6 +8389,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
         symbolTable.relateToOperator("imageAtomicXor",          EOpImageAtomicXor);
         symbolTable.relateToOperator("imageAtomicExchange",     EOpImageAtomicExchange);
         symbolTable.relateToOperator("imageAtomicCompSwap",     EOpImageAtomicCompSwap);
+        symbolTable.relateToOperator("imageAtomicLoad",         EOpImageAtomicLoad);
+        symbolTable.relateToOperator("imageAtomicStore",        EOpImageAtomicStore);
 
         symbolTable.relateToOperator("subpassLoad",             EOpSubpassLoad);
         symbolTable.relateToOperator("subpassLoadMS",           EOpSubpassLoadMS);

diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
index 5f4edfe..1d7413d 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.cpp
+++ b/glslang/MachineIndependent/ParseHelper.cpp
@@ -267,6 +267,10 @@ void TParseContext::handlePragma(const TSourceLoc& loc, const TVector<TString>&
         if (tokens.size() != 1)
             error(loc, "extra tokens", "#pragma", "");
         intermediate.setUseStorageBuffer();
+    } else if (spvVersion.spv > 0 && tokens[0].compare("use_vulkan_memory_model") == 0) {
+        if (tokens.size() != 1)
+            error(loc, "extra tokens", "#pragma", "");
+        intermediate.setUseVulkanMemoryModel();
     } else if (tokens[0].compare("once") == 0) {
         warn(loc, "not implemented", "#pragma once", "");
     } else if (tokens[0].compare("glslang_binary_double_output") == 0)
@@ -1028,8 +1032,16 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                         const char* message = "argument cannot drop memory qualifier when passed to formal parameter";
                         if (argQualifier.volatil && ! formalQualifier.volatil)
                             error(arguments->getLoc(), message, "volatile", "");
-                        if (argQualifier.coherent && ! formalQualifier.coherent)
+                        if (argQualifier.coherent && ! (formalQualifier.devicecoherent || formalQualifier.coherent))
                             error(arguments->getLoc(), message, "coherent", "");
+                        if (argQualifier.devicecoherent && ! (formalQualifier.devicecoherent || formalQualifier.coherent))
+                            error(arguments->getLoc(), message, "devicecoherent", "");
+                        if (argQualifier.queuefamilycoherent && ! (formalQualifier.queuefamilycoherent || formalQualifier.devicecoherent || formalQualifier.coherent))
+                            error(arguments->getLoc(), message, "queuefamilycoherent", "");
+                        if (argQualifier.workgroupcoherent && ! (formalQualifier.workgroupcoherent || formalQualifier.queuefamilycoherent || formalQualifier.devicecoherent || formalQualifier.coherent))
+                            error(arguments->getLoc(), message, "workgroupcoherent", "");
+                        if (argQualifier.subgroupcoherent && ! (formalQualifier.subgroupcoherent || formalQualifier.workgroupcoherent || formalQualifier.queuefamilycoherent || formalQualifier.devicecoherent || formalQualifier.coherent))
+                            error(arguments->getLoc(), message, "subgroupcoherent", "");
                         if (argQualifier.readonly && ! formalQualifier.readonly)
                             error(arguments->getLoc(), message, "readonly", "");
                         if (argQualifier.writeonly && ! formalQualifier.writeonly)
@@ -1428,6 +1440,159 @@ TIntermTyped* TParseContext::addOutputArgumentConversions(const TFunction& funct
     return conversionTree;
 }
 
+void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction& fnCandidate, const TIntermOperator& callNode)
+{
+    const TIntermSequence* argp = &callNode.getAsAggregate()->getSequence();
+
+    const int gl_SemanticsRelaxed         = 0x0;
+    const int gl_SemanticsAcquire         = 0x2;
+    const int gl_SemanticsRelease         = 0x4;
+    const int gl_SemanticsAcquireRelease  = 0x8;
+    const int gl_SemanticsMakeAvailable   = 0x2000;
+    const int gl_SemanticsMakeVisible     = 0x4000;
+
+    const int gl_StorageSemanticsNone     = 0x0;
+    const int gl_StorageSemanticsBuffer   = 0x40;
+    const int gl_StorageSemanticsShared   = 0x100;
+    const int gl_StorageSemanticsImage    = 0x800;
+    const int gl_StorageSemanticsOutput   = 0x1000;
+
+
+    unsigned int semantics = 0, storageClassSemantics = 0;
+    unsigned int semantics2 = 0, storageClassSemantics2 = 0;
+
+    // Grab the semantics and storage class semantics from the operands, based on opcode
+    switch (callNode.getOp()) {
+    case EOpAtomicAdd:
+    case EOpAtomicMin:
+    case EOpAtomicMax:
+    case EOpAtomicAnd:
+    case EOpAtomicOr:
+    case EOpAtomicXor:
+    case EOpAtomicExchange:
+    case EOpAtomicStore:
+        storageClassSemantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    case EOpAtomicLoad:
+        storageClassSemantics = (*argp)[2]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    case EOpAtomicCompSwap:
+        storageClassSemantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics2 = (*argp)[6]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics2 = (*argp)[7]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+
+    case EOpImageAtomicAdd:
+    case EOpImageAtomicMin:
+    case EOpImageAtomicMax:
+    case EOpImageAtomicAnd:
+    case EOpImageAtomicOr:
+    case EOpImageAtomicXor:
+    case EOpImageAtomicExchange:
+    case EOpImageAtomicStore:
+        storageClassSemantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    case EOpImageAtomicLoad:
+        storageClassSemantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    case EOpImageAtomicCompSwap:
+        storageClassSemantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[6]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics2 = (*argp)[7]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics2 = (*argp)[8]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+
+    case EOpBarrier:
+        storageClassSemantics = (*argp)[2]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    case EOpMemoryBarrier:
+        storageClassSemantics = (*argp)[1]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[2]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        break;
+    }
+
+    if ((semantics & gl_SemanticsAcquire) && 
+        (callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore)) {
+        error(loc, "gl_SemanticsAcquire must not be used with (image) atomic store",
+              fnCandidate.getName().c_str(), "");
+    }
+    if ((semantics & gl_SemanticsRelease) && 
+        (callNode.getOp() == EOpAtomicLoad || callNode.getOp() == EOpImageAtomicLoad)) {
+        error(loc, "gl_SemanticsRelease must not be used with (image) atomic load",
+              fnCandidate.getName().c_str(), "");
+    }
+    if ((semantics & gl_SemanticsAcquireRelease) && 
+        (callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore || 
+         callNode.getOp() == EOpAtomicLoad  || callNode.getOp() == EOpImageAtomicLoad)) {
+        error(loc, "gl_SemanticsAcquireRelease must not be used with (image) atomic load/store",
+              fnCandidate.getName().c_str(), "");
+    }
+    if (((semantics | semantics2) & ~(gl_SemanticsAcquire |
+                                      gl_SemanticsRelease |
+                                      gl_SemanticsAcquireRelease |
+                                      gl_SemanticsMakeAvailable |
+                                      gl_SemanticsMakeVisible))) {
+        error(loc, "Invalid semantics value", fnCandidate.getName().c_str(), "");
+    }
+    if (((storageClassSemantics | storageClassSemantics2) & ~(gl_StorageSemanticsBuffer |
+                                                              gl_StorageSemanticsShared |
+                                                              gl_StorageSemanticsImage |
+                                                              gl_StorageSemanticsOutput))) {
+        error(loc, "Invalid storage class semantics value", fnCandidate.getName().c_str(), "");
+    }
+
+    if (callNode.getOp() == EOpMemoryBarrier) {
+        if (!IsPow2(semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) {
+            error(loc, "Semantics must include exactly one of gl_SemanticsRelease, gl_SemanticsAcquire, or "
+                       "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), "");
+        }
+    } else {
+        if (semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease)) {
+            if (!IsPow2(semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) {
+                error(loc, "Semantics must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or "
+                           "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), "");
+            }
+        }
+        if (semantics2 & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease)) {
+            if (!IsPow2(semantics2 & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) {
+                error(loc, "semUnequal must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or "
+                           "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), "");
+            }
+        }
+    }
+    if (callNode.getOp() == EOpMemoryBarrier) {
+        if (storageClassSemantics == 0) {
+            error(loc, "Storage class semantics must not be zero", fnCandidate.getName().c_str(), "");
+        }
+    }
+    if (callNode.getOp() == EOpBarrier && semantics != 0 && storageClassSemantics == 0) {
+        error(loc, "Storage class semantics must not be zero", fnCandidate.getName().c_str(), "");
+    }
+    if ((callNode.getOp() == EOpAtomicCompSwap || callNode.getOp() == EOpImageAtomicCompSwap) &&
+        (semantics2 & (gl_SemanticsRelease | gl_SemanticsAcquireRelease))) {
+        error(loc, "semUnequal must not be gl_SemanticsRelease or gl_SemanticsAcquireRelease",
+              fnCandidate.getName().c_str(), "");
+    }
+    if ((semantics & gl_SemanticsMakeAvailable) &&
+        !(semantics & (gl_SemanticsRelease | gl_SemanticsAcquireRelease))) {
+        error(loc, "gl_SemanticsMakeAvailable requires gl_SemanticsRelease or gl_SemanticsAcquireRelease",
+              fnCandidate.getName().c_str(), "");
+    }
+    if ((semantics & gl_SemanticsMakeVisible) &&
+        !(semantics & (gl_SemanticsAcquire | gl_SemanticsAcquireRelease))) {
+        error(loc, "gl_SemanticsMakeVisible requires gl_SemanticsAcquire or gl_SemanticsAcquireRelease",
+              fnCandidate.getName().c_str(), "");
+    }
+
+}
+
+
 //
 // Do additional checking of built-in function calls that is not caught
 // by normal semantic checks on argument type, extension tagging, etc.
@@ -1656,6 +1821,8 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
     case EOpImageAtomicXor:
     case EOpImageAtomicExchange:
     case EOpImageAtomicCompSwap:
+    case EOpImageAtomicLoad:
+    case EOpImageAtomicStore:
     {
         // Make sure the image types have the correct layout() format and correct argument types
         const TType& imageType = arg0->getType();
@@ -1669,10 +1836,14 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
                 error(loc, "only supported on image with format r32f", fnCandidate.getName().c_str(), "");
         }
 
+        if (argp->size() > 4) {
+            requireExtensions(loc, 1, &E_GL_KHR_memory_scope_semantics, fnCandidate.getName().c_str());
+            memorySemanticsCheck(loc, fnCandidate, callNode);
+        }
+
         break;
     }
 
-#ifdef NV_EXTENSIONS
     case EOpAtomicAdd:
     case EOpAtomicMin:
     case EOpAtomicMax:
@@ -1681,13 +1852,19 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
     case EOpAtomicXor:
     case EOpAtomicExchange:
     case EOpAtomicCompSwap:
+    case EOpAtomicLoad:
+    case EOpAtomicStore:
     {
-        if (arg0->getType().getBasicType() == EbtInt64 || arg0->getType().getBasicType() == EbtUint64)
+        if (argp->size() > 3) {
+            requireExtensions(loc, 1, &E_GL_KHR_memory_scope_semantics, fnCandidate.getName().c_str());
+            memorySemanticsCheck(loc, fnCandidate, callNode);
+        }
+#ifdef NV_EXTENSIONS
+        else if (arg0->getType().getBasicType() == EbtInt64 || arg0->getType().getBasicType() == EbtUint64)
             requireExtensions(loc, 1, &E_GL_NV_shader_atomic_int64, fnCandidate.getName().c_str());
-
+#endif
         break;
     }
-#endif
 
     case EOpInterpolateAtCentroid:
     case EOpInterpolateAtSample:
@@ -1751,6 +1928,14 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
         }
         break;
 
+    case EOpBarrier:
+    case EOpMemoryBarrier:
+        if (argp->size() > 0) {
+            requireExtensions(loc, 1, &E_GL_KHR_memory_scope_semantics, fnCandidate.getName().c_str());
+            memorySemanticsCheck(loc, fnCandidate, callNode);
+        }
+        break;
+
     default:
         break;
     }
@@ -2806,8 +2991,11 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali
     if (! symbolTable.atGlobalLevel())
         return;
 
-    if (qualifier.isMemory() && ! publicType.isImage() && publicType.qualifier.storage != EvqBuffer)
+    if (qualifier.isMemoryQualifierImageAndSSBOOnly() && ! publicType.isImage() && publicType.qualifier.storage != EvqBuffer) {
+        error(loc, "memory qualifiers cannot be used on this type", "", "");
+    } else if (qualifier.isMemory() && (publicType.basicType != EbtSampler) && !publicType.qualifier.isUniformOrBuffer()) {
         error(loc, "memory qualifiers cannot be used on this type", "", "");
+    }
 
     if (qualifier.storage == EvqBuffer && publicType.basicType != EbtBlock)
         error(loc, "buffers can be declared only as blocks", "buffer", "");
@@ -3020,6 +3208,13 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
     if (dst.precision == EpqNone || (force && src.precision != EpqNone))
         dst.precision = src.precision;
 
+    if (!force && ((src.coherent && (dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+                   (src.devicecoherent && (dst.coherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+                   (src.queuefamilycoherent && (dst.coherent || dst.devicecoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+                   (src.workgroupcoherent && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.subgroupcoherent)) ||
+                   (src.subgroupcoherent  && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent)))) {
+        error(loc, "only one coherent/devicecoherent/queuefamilycoherent/workgroupcoherent/subgroupcoherent qualifier allowed", GetPrecisionQualifierString(src.precision), "");
+    }
     // Layout qualifiers
     mergeObjectLayoutQualifiers(dst, src, false);
 
@@ -3038,6 +3233,11 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
     MERGE_SINGLETON(patch);
     MERGE_SINGLETON(sample);
     MERGE_SINGLETON(coherent);
+    MERGE_SINGLETON(devicecoherent);
+    MERGE_SINGLETON(queuefamilycoherent);
+    MERGE_SINGLETON(workgroupcoherent);
+    MERGE_SINGLETON(subgroupcoherent);
+    MERGE_SINGLETON(nonprivate);
     MERGE_SINGLETON(volatil);
     MERGE_SINGLETON(restrict);
     MERGE_SINGLETON(readonly);
@@ -3862,6 +4062,11 @@ void TParseContext::paramCheckFix(const TSourceLoc& loc, const TQualifier& quali
     if (qualifier.isMemory()) {
         type.getQualifier().volatil   = qualifier.volatil;
         type.getQualifier().coherent  = qualifier.coherent;
+        type.getQualifier().devicecoherent  = qualifier.devicecoherent ;
+        type.getQualifier().queuefamilycoherent  = qualifier.queuefamilycoherent;
+        type.getQualifier().workgroupcoherent  = qualifier.workgroupcoherent;
+        type.getQualifier().subgroupcoherent  = qualifier.subgroupcoherent;
+        type.getQualifier().nonprivate = qualifier.nonprivate;
         type.getQualifier().readonly  = qualifier.readonly;
         type.getQualifier().writeonly = qualifier.writeonly;
         type.getQualifier().restrict  = qualifier.restrict;

diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h
index e40855e..e34bbbc 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.h
+++ b/glslang/MachineIndependent/ParseHelper.h
@@ -323,6 +323,7 @@ public:
     TFunction* handleConstructorCall(const TSourceLoc&, const TPublicType&);
     void handlePrecisionQualifier(const TSourceLoc&, TQualifier&, TPrecisionQualifier);
     void checkPrecisionQualifier(const TSourceLoc&, TPrecisionQualifier);
+    void memorySemanticsCheck(const TSourceLoc&, const TFunction&, const TIntermOperator& callNode);
 
     void assignError(const TSourceLoc&, const char* op, TString left, TString right);
     void unaryOpError(const TSourceLoc&, const char* op, TString operand);

diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
index eaedbe8..238301f 100644 (file)
--- a/glslang/MachineIndependent/Scan.cpp
+++ b/glslang/MachineIndependent/Scan.cpp
@@ -380,6 +380,11 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["varying"] =                 VARYING;
     (*KeywordMap)["buffer"] =                  BUFFER;
     (*KeywordMap)["coherent"] =                COHERENT;
+    (*KeywordMap)["devicecoherent"] =          DEVICECOHERENT;
+    (*KeywordMap)["queuefamilycoherent"] =     QUEUEFAMILYCOHERENT;
+    (*KeywordMap)["workgroupcoherent"] =       WORKGROUPCOHERENT;
+    (*KeywordMap)["subgroupcoherent"] =        SUBGROUPCOHERENT;
+    (*KeywordMap)["nonprivate"] =              NONPRIVATE;
     (*KeywordMap)["restrict"] =                RESTRICT;
     (*KeywordMap)["readonly"] =                READONLY;
     (*KeywordMap)["writeonly"] =               WRITEONLY;
@@ -937,6 +942,11 @@ int TScanContext::tokenizeIdentifier()
         return es30ReservedFromGLSL(420);
 
     case COHERENT:
+    case DEVICECOHERENT:
+    case QUEUEFAMILYCOHERENT:
+    case WORKGROUPCOHERENT:
+    case SUBGROUPCOHERENT:
+    case NONPRIVATE:
     case RESTRICT:
     case READONLY:
     case WRITEONLY:

diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
index 00af4d4..bd7b7de 100644 (file)
--- a/glslang/MachineIndependent/Versions.cpp
+++ b/glslang/MachineIndependent/Versions.cpp
@@ -194,6 +194,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_KHR_shader_subgroup_shuffle_relative] = EBhDisable;
     extensionBehavior[E_GL_KHR_shader_subgroup_clustered]        = EBhDisable;
     extensionBehavior[E_GL_KHR_shader_subgroup_quad]             = EBhDisable;
+    extensionBehavior[E_GL_KHR_memory_scope_semantics]           = EBhDisable;
 
     extensionBehavior[E_GL_EXT_shader_non_constant_global_initializers] = EBhDisable;
     extensionBehavior[E_GL_EXT_shader_image_load_formatted]             = EBhDisable;

diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
index 025e01c..f544324 100644 (file)
--- a/glslang/MachineIndependent/Versions.h
+++ b/glslang/MachineIndependent/Versions.h
@@ -148,6 +148,7 @@ const char* const E_GL_KHR_shader_subgroup_shuffle          = "GL_KHR_shader_sub
 const char* const E_GL_KHR_shader_subgroup_shuffle_relative = "GL_KHR_shader_subgroup_shuffle_relative";
 const char* const E_GL_KHR_shader_subgroup_clustered        = "GL_KHR_shader_subgroup_clustered";
 const char* const E_GL_KHR_shader_subgroup_quad             = "GL_KHR_shader_subgroup_quad";
+const char* const E_GL_KHR_memory_scope_semantics           = "GL_KHR_memory_scope_semantics";
 
 const char* const E_GL_EXT_shader_non_constant_global_initializers = "GL_EXT_shader_non_constant_global_initializers";
 const char* const E_GL_EXT_shader_image_load_formatted = "GL_EXT_shader_image_load_formatted";

diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
index 66a53d4..55b18ec 100644 (file)
--- a/glslang/MachineIndependent/glslang.y
+++ b/glslang/MachineIndependent/glslang.y
@@ -141,7 +141,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> VEC2 VEC3 VEC4
 %token <lex> MAT2 MAT3 MAT4 CENTROID IN OUT INOUT
 %token <lex> UNIFORM PATCH SAMPLE BUFFER SHARED NONUNIFORM
-%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY
+%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT SUBGROUPCOHERENT NONPRIVATE
 %token <lex> DVEC2 DVEC3 DVEC4 DMAT2 DMAT3 DMAT4
 %token <lex> F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4
 %token <lex> F32VEC2 F32VEC3 F32VEC4 F32MAT2 F32MAT3 F32MAT4
@@ -1317,6 +1317,31 @@ storage_qualifier
         $$.init($1.loc);
         $$.qualifier.coherent = true;
     }
+    | DEVICECOHERENT {
+        $$.init($1.loc);
+        parseContext.requireExtensions($1.loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
+        $$.qualifier.devicecoherent = true;
+    }
+    | QUEUEFAMILYCOHERENT {
+        $$.init($1.loc);
+        parseContext.requireExtensions($1.loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
+        $$.qualifier.queuefamilycoherent = true;
+    }
+    | WORKGROUPCOHERENT {
+        $$.init($1.loc);
+        parseContext.requireExtensions($1.loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
+        $$.qualifier.workgroupcoherent = true;
+    }
+    | SUBGROUPCOHERENT {
+        $$.init($1.loc);
+        parseContext.requireExtensions($1.loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
+        $$.qualifier.subgroupcoherent = true;
+    }
+    | NONPRIVATE {
+        $$.init($1.loc);
+        parseContext.requireExtensions($1.loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
+        $$.qualifier.nonprivate = true;
+    }
     | VOLATILE {
         $$.init($1.loc);
         $$.qualifier.volatil = true;

diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
index a79c480..f708964 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp
+++ b/glslang/MachineIndependent/glslang_tab.cpp
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.0.4.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -44,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.0"
+#define YYBISON_VERSION "3.0.4"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -90,11 +90,11 @@ using namespace glslang;
 
 #line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339  */
 
-# ifndef YY_NULL
+# ifndef YY_NULLPTR
 #  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
+#   define YY_NULLPTR nullptr
 #  else
-#   define YY_NULL 0
+#   define YY_NULLPTR 0
 #  endif
 # endif
 
@@ -208,315 +208,320 @@ extern int yydebug;
     RESTRICT = 340,
     READONLY = 341,
     WRITEONLY = 342,
-    DVEC2 = 343,
-    DVEC3 = 344,
-    DVEC4 = 345,
-    DMAT2 = 346,
-    DMAT3 = 347,
-    DMAT4 = 348,
-    F16VEC2 = 349,
-    F16VEC3 = 350,
-    F16VEC4 = 351,
-    F16MAT2 = 352,
-    F16MAT3 = 353,
-    F16MAT4 = 354,
-    F32VEC2 = 355,
-    F32VEC3 = 356,
-    F32VEC4 = 357,
-    F32MAT2 = 358,
-    F32MAT3 = 359,
-    F32MAT4 = 360,
-    F64VEC2 = 361,
-    F64VEC3 = 362,
-    F64VEC4 = 363,
-    F64MAT2 = 364,
-    F64MAT3 = 365,
-    F64MAT4 = 366,
-    NOPERSPECTIVE = 367,
-    FLAT = 368,
-    SMOOTH = 369,
-    LAYOUT = 370,
-    EXPLICITINTERPAMD = 371,
-    MAT2X2 = 372,
-    MAT2X3 = 373,
-    MAT2X4 = 374,
-    MAT3X2 = 375,
-    MAT3X3 = 376,
-    MAT3X4 = 377,
-    MAT4X2 = 378,
-    MAT4X3 = 379,
-    MAT4X4 = 380,
-    DMAT2X2 = 381,
-    DMAT2X3 = 382,
-    DMAT2X4 = 383,
-    DMAT3X2 = 384,
-    DMAT3X3 = 385,
-    DMAT3X4 = 386,
-    DMAT4X2 = 387,
-    DMAT4X3 = 388,
-    DMAT4X4 = 389,
-    F16MAT2X2 = 390,
-    F16MAT2X3 = 391,
-    F16MAT2X4 = 392,
-    F16MAT3X2 = 393,
-    F16MAT3X3 = 394,
-    F16MAT3X4 = 395,
-    F16MAT4X2 = 396,
-    F16MAT4X3 = 397,
-    F16MAT4X4 = 398,
-    F32MAT2X2 = 399,
-    F32MAT2X3 = 400,
-    F32MAT2X4 = 401,
-    F32MAT3X2 = 402,
-    F32MAT3X3 = 403,
-    F32MAT3X4 = 404,
-    F32MAT4X2 = 405,
-    F32MAT4X3 = 406,
-    F32MAT4X4 = 407,
-    F64MAT2X2 = 408,
-    F64MAT2X3 = 409,
-    F64MAT2X4 = 410,
-    F64MAT3X2 = 411,
-    F64MAT3X3 = 412,
-    F64MAT3X4 = 413,
-    F64MAT4X2 = 414,
-    F64MAT4X3 = 415,
-    F64MAT4X4 = 416,
-    ATOMIC_UINT = 417,
-    SAMPLER1D = 418,
-    SAMPLER2D = 419,
-    SAMPLER3D = 420,
-    SAMPLERCUBE = 421,
-    SAMPLER1DSHADOW = 422,
-    SAMPLER2DSHADOW = 423,
-    SAMPLERCUBESHADOW = 424,
-    SAMPLER1DARRAY = 425,
-    SAMPLER2DARRAY = 426,
-    SAMPLER1DARRAYSHADOW = 427,
-    SAMPLER2DARRAYSHADOW = 428,
-    ISAMPLER1D = 429,
-    ISAMPLER2D = 430,
-    ISAMPLER3D = 431,
-    ISAMPLERCUBE = 432,
-    ISAMPLER1DARRAY = 433,
-    ISAMPLER2DARRAY = 434,
-    USAMPLER1D = 435,
-    USAMPLER2D = 436,
-    USAMPLER3D = 437,
-    USAMPLERCUBE = 438,
-    USAMPLER1DARRAY = 439,
-    USAMPLER2DARRAY = 440,
-    SAMPLER2DRECT = 441,
-    SAMPLER2DRECTSHADOW = 442,
-    ISAMPLER2DRECT = 443,
-    USAMPLER2DRECT = 444,
-    SAMPLERBUFFER = 445,
-    ISAMPLERBUFFER = 446,
-    USAMPLERBUFFER = 447,
-    SAMPLERCUBEARRAY = 448,
-    SAMPLERCUBEARRAYSHADOW = 449,
-    ISAMPLERCUBEARRAY = 450,
-    USAMPLERCUBEARRAY = 451,
-    SAMPLER2DMS = 452,
-    ISAMPLER2DMS = 453,
-    USAMPLER2DMS = 454,
-    SAMPLER2DMSARRAY = 455,
-    ISAMPLER2DMSARRAY = 456,
-    USAMPLER2DMSARRAY = 457,
-    SAMPLEREXTERNALOES = 458,
-    F16SAMPLER1D = 459,
-    F16SAMPLER2D = 460,
-    F16SAMPLER3D = 461,
-    F16SAMPLER2DRECT = 462,
-    F16SAMPLERCUBE = 463,
-    F16SAMPLER1DARRAY = 464,
-    F16SAMPLER2DARRAY = 465,
-    F16SAMPLERCUBEARRAY = 466,
-    F16SAMPLERBUFFER = 467,
-    F16SAMPLER2DMS = 468,
-    F16SAMPLER2DMSARRAY = 469,
-    F16SAMPLER1DSHADOW = 470,
-    F16SAMPLER2DSHADOW = 471,
-    F16SAMPLER1DARRAYSHADOW = 472,
-    F16SAMPLER2DARRAYSHADOW = 473,
-    F16SAMPLER2DRECTSHADOW = 474,
-    F16SAMPLERCUBESHADOW = 475,
-    F16SAMPLERCUBEARRAYSHADOW = 476,
-    SAMPLER = 477,
-    SAMPLERSHADOW = 478,
-    TEXTURE1D = 479,
-    TEXTURE2D = 480,
-    TEXTURE3D = 481,
-    TEXTURECUBE = 482,
-    TEXTURE1DARRAY = 483,
-    TEXTURE2DARRAY = 484,
-    ITEXTURE1D = 485,
-    ITEXTURE2D = 486,
-    ITEXTURE3D = 487,
-    ITEXTURECUBE = 488,
-    ITEXTURE1DARRAY = 489,
-    ITEXTURE2DARRAY = 490,
-    UTEXTURE1D = 491,
-    UTEXTURE2D = 492,
-    UTEXTURE3D = 493,
-    UTEXTURECUBE = 494,
-    UTEXTURE1DARRAY = 495,
-    UTEXTURE2DARRAY = 496,
-    TEXTURE2DRECT = 497,
-    ITEXTURE2DRECT = 498,
-    UTEXTURE2DRECT = 499,
-    TEXTUREBUFFER = 500,
-    ITEXTUREBUFFER = 501,
-    UTEXTUREBUFFER = 502,
-    TEXTURECUBEARRAY = 503,
-    ITEXTURECUBEARRAY = 504,
-    UTEXTURECUBEARRAY = 505,
-    TEXTURE2DMS = 506,
-    ITEXTURE2DMS = 507,
-    UTEXTURE2DMS = 508,
-    TEXTURE2DMSARRAY = 509,
-    ITEXTURE2DMSARRAY = 510,
-    UTEXTURE2DMSARRAY = 511,
-    F16TEXTURE1D = 512,
-    F16TEXTURE2D = 513,
-    F16TEXTURE3D = 514,
-    F16TEXTURE2DRECT = 515,
-    F16TEXTURECUBE = 516,
-    F16TEXTURE1DARRAY = 517,
-    F16TEXTURE2DARRAY = 518,
-    F16TEXTURECUBEARRAY = 519,
-    F16TEXTUREBUFFER = 520,
-    F16TEXTURE2DMS = 521,
-    F16TEXTURE2DMSARRAY = 522,
-    SUBPASSINPUT = 523,
-    SUBPASSINPUTMS = 524,
-    ISUBPASSINPUT = 525,
-    ISUBPASSINPUTMS = 526,
-    USUBPASSINPUT = 527,
-    USUBPASSINPUTMS = 528,
-    F16SUBPASSINPUT = 529,
-    F16SUBPASSINPUTMS = 530,
-    IMAGE1D = 531,
-    IIMAGE1D = 532,
-    UIMAGE1D = 533,
-    IMAGE2D = 534,
-    IIMAGE2D = 535,
-    UIMAGE2D = 536,
-    IMAGE3D = 537,
-    IIMAGE3D = 538,
-    UIMAGE3D = 539,
-    IMAGE2DRECT = 540,
-    IIMAGE2DRECT = 541,
-    UIMAGE2DRECT = 542,
-    IMAGECUBE = 543,
-    IIMAGECUBE = 544,
-    UIMAGECUBE = 545,
-    IMAGEBUFFER = 546,
-    IIMAGEBUFFER = 547,
-    UIMAGEBUFFER = 548,
-    IMAGE1DARRAY = 549,
-    IIMAGE1DARRAY = 550,
-    UIMAGE1DARRAY = 551,
-    IMAGE2DARRAY = 552,
-    IIMAGE2DARRAY = 553,
-    UIMAGE2DARRAY = 554,
-    IMAGECUBEARRAY = 555,
-    IIMAGECUBEARRAY = 556,
-    UIMAGECUBEARRAY = 557,
-    IMAGE2DMS = 558,
-    IIMAGE2DMS = 559,
-    UIMAGE2DMS = 560,
-    IMAGE2DMSARRAY = 561,
-    IIMAGE2DMSARRAY = 562,
-    UIMAGE2DMSARRAY = 563,
-    F16IMAGE1D = 564,
-    F16IMAGE2D = 565,
-    F16IMAGE3D = 566,
-    F16IMAGE2DRECT = 567,
-    F16IMAGECUBE = 568,
-    F16IMAGE1DARRAY = 569,
-    F16IMAGE2DARRAY = 570,
-    F16IMAGECUBEARRAY = 571,
-    F16IMAGEBUFFER = 572,
-    F16IMAGE2DMS = 573,
-    F16IMAGE2DMSARRAY = 574,
-    STRUCT = 575,
-    VOID = 576,
-    WHILE = 577,
-    IDENTIFIER = 578,
-    TYPE_NAME = 579,
-    FLOATCONSTANT = 580,
-    DOUBLECONSTANT = 581,
-    INT16CONSTANT = 582,
-    UINT16CONSTANT = 583,
-    INT32CONSTANT = 584,
-    UINT32CONSTANT = 585,
-    INTCONSTANT = 586,
-    UINTCONSTANT = 587,
-    INT64CONSTANT = 588,
-    UINT64CONSTANT = 589,
-    BOOLCONSTANT = 590,
-    FLOAT16CONSTANT = 591,
-    LEFT_OP = 592,
-    RIGHT_OP = 593,
-    INC_OP = 594,
-    DEC_OP = 595,
-    LE_OP = 596,
-    GE_OP = 597,
-    EQ_OP = 598,
-    NE_OP = 599,
-    AND_OP = 600,
-    OR_OP = 601,
-    XOR_OP = 602,
-    MUL_ASSIGN = 603,
-    DIV_ASSIGN = 604,
-    ADD_ASSIGN = 605,
-    MOD_ASSIGN = 606,
-    LEFT_ASSIGN = 607,
-    RIGHT_ASSIGN = 608,
-    AND_ASSIGN = 609,
-    XOR_ASSIGN = 610,
-    OR_ASSIGN = 611,
-    SUB_ASSIGN = 612,
-    LEFT_PAREN = 613,
-    RIGHT_PAREN = 614,
-    LEFT_BRACKET = 615,
-    RIGHT_BRACKET = 616,
-    LEFT_BRACE = 617,
-    RIGHT_BRACE = 618,
-    DOT = 619,
-    COMMA = 620,
-    COLON = 621,
-    EQUAL = 622,
-    SEMICOLON = 623,
-    BANG = 624,
-    DASH = 625,
-    TILDE = 626,
-    PLUS = 627,
-    STAR = 628,
-    SLASH = 629,
-    PERCENT = 630,
-    LEFT_ANGLE = 631,
-    RIGHT_ANGLE = 632,
-    VERTICAL_BAR = 633,
-    CARET = 634,
-    AMPERSAND = 635,
-    QUESTION = 636,
-    INVARIANT = 637,
-    PRECISE = 638,
-    HIGH_PRECISION = 639,
-    MEDIUM_PRECISION = 640,
-    LOW_PRECISION = 641,
-    PRECISION = 642,
-    PACKED = 643,
-    RESOURCE = 644,
-    SUPERP = 645
+    DEVICECOHERENT = 343,
+    QUEUEFAMILYCOHERENT = 344,
+    WORKGROUPCOHERENT = 345,
+    SUBGROUPCOHERENT = 346,
+    NONPRIVATE = 347,
+    DVEC2 = 348,
+    DVEC3 = 349,
+    DVEC4 = 350,
+    DMAT2 = 351,
+    DMAT3 = 352,
+    DMAT4 = 353,
+    F16VEC2 = 354,
+    F16VEC3 = 355,
+    F16VEC4 = 356,
+    F16MAT2 = 357,
+    F16MAT3 = 358,
+    F16MAT4 = 359,
+    F32VEC2 = 360,
+    F32VEC3 = 361,
+    F32VEC4 = 362,
+    F32MAT2 = 363,
+    F32MAT3 = 364,
+    F32MAT4 = 365,
+    F64VEC2 = 366,
+    F64VEC3 = 367,
+    F64VEC4 = 368,
+    F64MAT2 = 369,
+    F64MAT3 = 370,
+    F64MAT4 = 371,
+    NOPERSPECTIVE = 372,
+    FLAT = 373,
+    SMOOTH = 374,
+    LAYOUT = 375,
+    EXPLICITINTERPAMD = 376,
+    MAT2X2 = 377,
+    MAT2X3 = 378,
+    MAT2X4 = 379,
+    MAT3X2 = 380,
+    MAT3X3 = 381,
+    MAT3X4 = 382,
+    MAT4X2 = 383,
+    MAT4X3 = 384,
+    MAT4X4 = 385,
+    DMAT2X2 = 386,
+    DMAT2X3 = 387,
+    DMAT2X4 = 388,
+    DMAT3X2 = 389,
+    DMAT3X3 = 390,
+    DMAT3X4 = 391,
+    DMAT4X2 = 392,
+    DMAT4X3 = 393,
+    DMAT4X4 = 394,
+    F16MAT2X2 = 395,
+    F16MAT2X3 = 396,
+    F16MAT2X4 = 397,
+    F16MAT3X2 = 398,
+    F16MAT3X3 = 399,
+    F16MAT3X4 = 400,
+    F16MAT4X2 = 401,
+    F16MAT4X3 = 402,
+    F16MAT4X4 = 403,
+    F32MAT2X2 = 404,
+    F32MAT2X3 = 405,
+    F32MAT2X4 = 406,
+    F32MAT3X2 = 407,
+    F32MAT3X3 = 408,
+    F32MAT3X4 = 409,
+    F32MAT4X2 = 410,
+    F32MAT4X3 = 411,
+    F32MAT4X4 = 412,
+    F64MAT2X2 = 413,
+    F64MAT2X3 = 414,
+    F64MAT2X4 = 415,
+    F64MAT3X2 = 416,
+    F64MAT3X3 = 417,
+    F64MAT3X4 = 418,
+    F64MAT4X2 = 419,
+    F64MAT4X3 = 420,
+    F64MAT4X4 = 421,
+    ATOMIC_UINT = 422,
+    SAMPLER1D = 423,
+    SAMPLER2D = 424,
+    SAMPLER3D = 425,
+    SAMPLERCUBE = 426,
+    SAMPLER1DSHADOW = 427,
+    SAMPLER2DSHADOW = 428,
+    SAMPLERCUBESHADOW = 429,
+    SAMPLER1DARRAY = 430,
+    SAMPLER2DARRAY = 431,
+    SAMPLER1DARRAYSHADOW = 432,
+    SAMPLER2DARRAYSHADOW = 433,
+    ISAMPLER1D = 434,
+    ISAMPLER2D = 435,
+    ISAMPLER3D = 436,
+    ISAMPLERCUBE = 437,
+    ISAMPLER1DARRAY = 438,
+    ISAMPLER2DARRAY = 439,
+    USAMPLER1D = 440,
+    USAMPLER2D = 441,
+    USAMPLER3D = 442,
+    USAMPLERCUBE = 443,
+    USAMPLER1DARRAY = 444,
+    USAMPLER2DARRAY = 445,
+    SAMPLER2DRECT = 446,
+    SAMPLER2DRECTSHADOW = 447,
+    ISAMPLER2DRECT = 448,
+    USAMPLER2DRECT = 449,
+    SAMPLERBUFFER = 450,
+    ISAMPLERBUFFER = 451,
+    USAMPLERBUFFER = 452,
+    SAMPLERCUBEARRAY = 453,
+    SAMPLERCUBEARRAYSHADOW = 454,
+    ISAMPLERCUBEARRAY = 455,
+    USAMPLERCUBEARRAY = 456,
+    SAMPLER2DMS = 457,
+    ISAMPLER2DMS = 458,
+    USAMPLER2DMS = 459,
+    SAMPLER2DMSARRAY = 460,
+    ISAMPLER2DMSARRAY = 461,
+    USAMPLER2DMSARRAY = 462,
+    SAMPLEREXTERNALOES = 463,
+    F16SAMPLER1D = 464,
+    F16SAMPLER2D = 465,
+    F16SAMPLER3D = 466,
+    F16SAMPLER2DRECT = 467,
+    F16SAMPLERCUBE = 468,
+    F16SAMPLER1DARRAY = 469,
+    F16SAMPLER2DARRAY = 470,
+    F16SAMPLERCUBEARRAY = 471,
+    F16SAMPLERBUFFER = 472,
+    F16SAMPLER2DMS = 473,
+    F16SAMPLER2DMSARRAY = 474,
+    F16SAMPLER1DSHADOW = 475,
+    F16SAMPLER2DSHADOW = 476,
+    F16SAMPLER1DARRAYSHADOW = 477,
+    F16SAMPLER2DARRAYSHADOW = 478,
+    F16SAMPLER2DRECTSHADOW = 479,
+    F16SAMPLERCUBESHADOW = 480,
+    F16SAMPLERCUBEARRAYSHADOW = 481,
+    SAMPLER = 482,
+    SAMPLERSHADOW = 483,
+    TEXTURE1D = 484,
+    TEXTURE2D = 485,
+    TEXTURE3D = 486,
+    TEXTURECUBE = 487,
+    TEXTURE1DARRAY = 488,
+    TEXTURE2DARRAY = 489,
+    ITEXTURE1D = 490,
+    ITEXTURE2D = 491,
+    ITEXTURE3D = 492,
+    ITEXTURECUBE = 493,
+    ITEXTURE1DARRAY = 494,
+    ITEXTURE2DARRAY = 495,
+    UTEXTURE1D = 496,
+    UTEXTURE2D = 497,
+    UTEXTURE3D = 498,
+    UTEXTURECUBE = 499,
+    UTEXTURE1DARRAY = 500,
+    UTEXTURE2DARRAY = 501,
+    TEXTURE2DRECT = 502,
+    ITEXTURE2DRECT = 503,
+    UTEXTURE2DRECT = 504,
+    TEXTUREBUFFER = 505,
+    ITEXTUREBUFFER = 506,
+    UTEXTUREBUFFER = 507,
+    TEXTURECUBEARRAY = 508,
+    ITEXTURECUBEARRAY = 509,
+    UTEXTURECUBEARRAY = 510,
+    TEXTURE2DMS = 511,
+    ITEXTURE2DMS = 512,
+    UTEXTURE2DMS = 513,
+    TEXTURE2DMSARRAY = 514,
+    ITEXTURE2DMSARRAY = 515,
+    UTEXTURE2DMSARRAY = 516,
+    F16TEXTURE1D = 517,
+    F16TEXTURE2D = 518,
+    F16TEXTURE3D = 519,
+    F16TEXTURE2DRECT = 520,
+    F16TEXTURECUBE = 521,
+    F16TEXTURE1DARRAY = 522,
+    F16TEXTURE2DARRAY = 523,
+    F16TEXTURECUBEARRAY = 524,
+    F16TEXTUREBUFFER = 525,
+    F16TEXTURE2DMS = 526,
+    F16TEXTURE2DMSARRAY = 527,
+    SUBPASSINPUT = 528,
+    SUBPASSINPUTMS = 529,
+    ISUBPASSINPUT = 530,
+    ISUBPASSINPUTMS = 531,
+    USUBPASSINPUT = 532,
+    USUBPASSINPUTMS = 533,
+    F16SUBPASSINPUT = 534,
+    F16SUBPASSINPUTMS = 535,
+    IMAGE1D = 536,
+    IIMAGE1D = 537,
+    UIMAGE1D = 538,
+    IMAGE2D = 539,
+    IIMAGE2D = 540,
+    UIMAGE2D = 541,
+    IMAGE3D = 542,
+    IIMAGE3D = 543,
+    UIMAGE3D = 544,
+    IMAGE2DRECT = 545,
+    IIMAGE2DRECT = 546,
+    UIMAGE2DRECT = 547,
+    IMAGECUBE = 548,
+    IIMAGECUBE = 549,
+    UIMAGECUBE = 550,
+    IMAGEBUFFER = 551,
+    IIMAGEBUFFER = 552,
+    UIMAGEBUFFER = 553,
+    IMAGE1DARRAY = 554,
+    IIMAGE1DARRAY = 555,
+    UIMAGE1DARRAY = 556,
+    IMAGE2DARRAY = 557,
+    IIMAGE2DARRAY = 558,
+    UIMAGE2DARRAY = 559,
+    IMAGECUBEARRAY = 560,
+    IIMAGECUBEARRAY = 561,
+    UIMAGECUBEARRAY = 562,
+    IMAGE2DMS = 563,
+    IIMAGE2DMS = 564,
+    UIMAGE2DMS = 565,
+    IMAGE2DMSARRAY = 566,
+    IIMAGE2DMSARRAY = 567,
+    UIMAGE2DMSARRAY = 568,
+    F16IMAGE1D = 569,
+    F16IMAGE2D = 570,
+    F16IMAGE3D = 571,
+    F16IMAGE2DRECT = 572,
+    F16IMAGECUBE = 573,
+    F16IMAGE1DARRAY = 574,
+    F16IMAGE2DARRAY = 575,
+    F16IMAGECUBEARRAY = 576,
+    F16IMAGEBUFFER = 577,
+    F16IMAGE2DMS = 578,
+    F16IMAGE2DMSARRAY = 579,
+    STRUCT = 580,
+    VOID = 581,
+    WHILE = 582,
+    IDENTIFIER = 583,
+    TYPE_NAME = 584,
+    FLOATCONSTANT = 585,
+    DOUBLECONSTANT = 586,
+    INT16CONSTANT = 587,
+    UINT16CONSTANT = 588,
+    INT32CONSTANT = 589,
+    UINT32CONSTANT = 590,
+    INTCONSTANT = 591,
+    UINTCONSTANT = 592,
+    INT64CONSTANT = 593,
+    UINT64CONSTANT = 594,
+    BOOLCONSTANT = 595,
+    FLOAT16CONSTANT = 596,
+    LEFT_OP = 597,
+    RIGHT_OP = 598,
+    INC_OP = 599,
+    DEC_OP = 600,
+    LE_OP = 601,
+    GE_OP = 602,
+    EQ_OP = 603,
+    NE_OP = 604,
+    AND_OP = 605,
+    OR_OP = 606,
+    XOR_OP = 607,
+    MUL_ASSIGN = 608,
+    DIV_ASSIGN = 609,
+    ADD_ASSIGN = 610,
+    MOD_ASSIGN = 611,
+    LEFT_ASSIGN = 612,
+    RIGHT_ASSIGN = 613,
+    AND_ASSIGN = 614,
+    XOR_ASSIGN = 615,
+    OR_ASSIGN = 616,
+    SUB_ASSIGN = 617,
+    LEFT_PAREN = 618,
+    RIGHT_PAREN = 619,
+    LEFT_BRACKET = 620,
+    RIGHT_BRACKET = 621,
+    LEFT_BRACE = 622,
+    RIGHT_BRACE = 623,
+    DOT = 624,
+    COMMA = 625,
+    COLON = 626,
+    EQUAL = 627,
+    SEMICOLON = 628,
+    BANG = 629,
+    DASH = 630,
+    TILDE = 631,
+    PLUS = 632,
+    STAR = 633,
+    SLASH = 634,
+    PERCENT = 635,
+    LEFT_ANGLE = 636,
+    RIGHT_ANGLE = 637,
+    VERTICAL_BAR = 638,
+    CARET = 639,
+    AMPERSAND = 640,
+    QUESTION = 641,
+    INVARIANT = 642,
+    PRECISE = 643,
+    HIGH_PRECISION = 644,
+    MEDIUM_PRECISION = 645,
+    LOW_PRECISION = 646,
+    PRECISION = 647,
+    PACKED = 648,
+    RESOURCE = 649,
+    SUPERP = 650
   };
 #endif
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
+
 union YYSTYPE
 {
 #line 70 "MachineIndependent/glslang.y" /* yacc.c:355  */
@@ -554,8 +559,10 @@ union YYSTYPE
         };
     } interm;
 
-#line 558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
+#line 563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
 };
+
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif
@@ -583,7 +590,7 @@ int yyparse (glslang::TParseContext* pParseContext);
 extern int yylex(YYSTYPE*, TParseContext&);
 
 
-#line 587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
+#line 594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -640,11 +647,30 @@ typedef short int yytype_int16;
 # endif
 #endif
 
-#ifndef __attribute__
-/* This feature is available in gcc versions 2.5 and later.  */
-# if (! defined __GNUC__ || __GNUC__ < 2 \
-      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
-#  define __attribute__(Spec) /* empty */
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+#  define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+#  define _Noreturn __declspec (noreturn)
+# else
+#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
 # endif
 #endif
 
@@ -804,23 +830,23 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  366
+#define YYFINAL  371
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   8949
+#define YYLAST   9064
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  391
+#define YYNTOKENS  396
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  107
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  556
+#define YYNRULES  561
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  697
+#define YYNSTATES  702
 
 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
    by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   645
+#define YYMAXUTOK   650
 
 #define YYTRANSLATE(YYX)                                                \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -893,7 +919,8 @@ static const yytype_uint16 yytranslate[] =
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390
+     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
+     395
 };
 
 #if YYDEBUG
@@ -916,46 +943,47 @@ static const yytype_uint16 yyrline[] =
     1077,  1104,  1113,  1120,  1127,  1138,  1150,  1156,  1159,  1166,
     1170,  1174,  1182,  1191,  1194,  1205,  1208,  1211,  1215,  1219,
     1223,  1227,  1233,  1237,  1249,  1263,  1268,  1274,  1280,  1287,
-    1293,  1298,  1303,  1308,  1316,  1320,  1324,  1328,  1332,  1336,
-    1342,  1351,  1358,  1361,  1369,  1373,  1382,  1387,  1395,  1399,
-    1409,  1413,  1417,  1422,  1427,  1432,  1437,  1441,  1446,  1451,
-    1456,  1461,  1466,  1471,  1476,  1481,  1486,  1490,  1495,  1500,
-    1505,  1511,  1517,  1523,  1529,  1535,  1541,  1547,  1553,  1559,
-    1565,  1571,  1577,  1582,  1587,  1592,  1597,  1602,  1607,  1613,
-    1619,  1625,  1631,  1637,  1643,  1649,  1655,  1661,  1667,  1673,
-    1679,  1685,  1691,  1697,  1703,  1709,  1715,  1721,  1727,  1733,
-    1739,  1745,  1751,  1757,  1763,  1769,  1774,  1779,  1784,  1789,
-    1794,  1799,  1804,  1809,  1814,  1819,  1824,  1829,  1835,  1841,
-    1847,  1853,  1859,  1865,  1871,  1877,  1883,  1889,  1895,  1901,
-    1907,  1913,  1919,  1925,  1931,  1937,  1943,  1949,  1955,  1961,
-    1967,  1973,  1979,  1985,  1991,  1997,  2003,  2009,  2015,  2021,
-    2027,  2033,  2039,  2045,  2051,  2057,  2063,  2069,  2075,  2081,
-    2087,  2093,  2099,  2105,  2111,  2117,  2122,  2127,  2132,  2137,
+    1293,  1298,  1303,  1308,  1316,  1320,  1325,  1330,  1335,  1340,
+    1345,  1349,  1353,  1357,  1361,  1367,  1376,  1383,  1386,  1394,
+    1398,  1407,  1412,  1420,  1424,  1434,  1438,  1442,  1447,  1452,
+    1457,  1462,  1466,  1471,  1476,  1481,  1486,  1491,  1496,  1501,
+    1506,  1511,  1515,  1520,  1525,  1530,  1536,  1542,  1548,  1554,
+    1560,  1566,  1572,  1578,  1584,  1590,  1596,  1602,  1607,  1612,
+    1617,  1622,  1627,  1632,  1638,  1644,  1650,  1656,  1662,  1668,
+    1674,  1680,  1686,  1692,  1698,  1704,  1710,  1716,  1722,  1728,
+    1734,  1740,  1746,  1752,  1758,  1764,  1770,  1776,  1782,  1788,
+    1794,  1799,  1804,  1809,  1814,  1819,  1824,  1829,  1834,  1839,
+    1844,  1849,  1854,  1860,  1866,  1872,  1878,  1884,  1890,  1896,
+    1902,  1908,  1914,  1920,  1926,  1932,  1938,  1944,  1950,  1956,
+    1962,  1968,  1974,  1980,  1986,  1992,  1998,  2004,  2010,  2016,
+    2022,  2028,  2034,  2040,  2046,  2052,  2058,  2064,  2070,  2076,
+    2082,  2088,  2094,  2100,  2106,  2112,  2118,  2124,  2130,  2136,
     2142,  2147,  2152,  2157,  2162,  2167,  2172,  2177,  2182,  2187,
-    2195,  2203,  2211,  2219,  2227,  2235,  2243,  2251,  2259,  2267,
-    2275,  2283,  2291,  2296,  2301,  2306,  2311,  2316,  2321,  2326,
-    2331,  2336,  2341,  2346,  2351,  2356,  2361,  2366,  2371,  2379,
-    2387,  2392,  2397,  2402,  2410,  2415,  2420,  2425,  2433,  2438,
-    2443,  2448,  2456,  2461,  2466,  2471,  2476,  2481,  2489,  2494,
-    2502,  2507,  2515,  2520,  2528,  2533,  2541,  2546,  2554,  2559,
-    2567,  2572,  2577,  2582,  2587,  2592,  2597,  2602,  2607,  2612,
-    2617,  2622,  2627,  2632,  2637,  2642,  2650,  2655,  2660,  2665,
-    2673,  2678,  2683,  2688,  2696,  2701,  2706,  2711,  2719,  2724,
-    2729,  2734,  2742,  2747,  2752,  2757,  2765,  2770,  2775,  2780,
-    2788,  2793,  2798,  2803,  2811,  2816,  2821,  2826,  2834,  2839,
-    2844,  2849,  2857,  2862,  2867,  2872,  2880,  2885,  2890,  2895,
-    2903,  2908,  2913,  2918,  2926,  2931,  2936,  2941,  2949,  2954,
-    2959,  2964,  2972,  2977,  2982,  2988,  2994,  3000,  3009,  3018,
-    3024,  3030,  3036,  3042,  3047,  3063,  3068,  3073,  3081,  3081,
-    3092,  3092,  3102,  3105,  3118,  3140,  3167,  3171,  3177,  3182,
-    3193,  3196,  3202,  3211,  3214,  3220,  3224,  3225,  3231,  3232,
-    3233,  3234,  3235,  3236,  3237,  3241,  3242,  3246,  3242,  3258,
-    3259,  3263,  3263,  3270,  3270,  3284,  3287,  3295,  3303,  3314,
-    3315,  3319,  3322,  3328,  3335,  3339,  3347,  3351,  3364,  3367,
-    3373,  3373,  3393,  3396,  3402,  3414,  3426,  3429,  3435,  3435,
-    3450,  3450,  3466,  3466,  3487,  3490,  3496,  3499,  3505,  3509,
-    3516,  3521,  3526,  3533,  3536,  3545,  3549,  3558,  3561,  3564,
-    3572,  3572,  3594,  3600,  3603,  3608,  3611
+    2192,  2197,  2202,  2207,  2212,  2220,  2228,  2236,  2244,  2252,
+    2260,  2268,  2276,  2284,  2292,  2300,  2308,  2316,  2321,  2326,
+    2331,  2336,  2341,  2346,  2351,  2356,  2361,  2366,  2371,  2376,
+    2381,  2386,  2391,  2396,  2404,  2412,  2417,  2422,  2427,  2435,
+    2440,  2445,  2450,  2458,  2463,  2468,  2473,  2481,  2486,  2491,
+    2496,  2501,  2506,  2514,  2519,  2527,  2532,  2540,  2545,  2553,
+    2558,  2566,  2571,  2579,  2584,  2592,  2597,  2602,  2607,  2612,
+    2617,  2622,  2627,  2632,  2637,  2642,  2647,  2652,  2657,  2662,
+    2667,  2675,  2680,  2685,  2690,  2698,  2703,  2708,  2713,  2721,
+    2726,  2731,  2736,  2744,  2749,  2754,  2759,  2767,  2772,  2777,
+    2782,  2790,  2795,  2800,  2805,  2813,  2818,  2823,  2828,  2836,
+    2841,  2846,  2851,  2859,  2864,  2869,  2874,  2882,  2887,  2892,
+    2897,  2905,  2910,  2915,  2920,  2928,  2933,  2938,  2943,  2951,
+    2956,  2961,  2966,  2974,  2979,  2984,  2989,  2997,  3002,  3007,
+    3013,  3019,  3025,  3034,  3043,  3049,  3055,  3061,  3067,  3072,
+    3088,  3093,  3098,  3106,  3106,  3117,  3117,  3127,  3130,  3143,
+    3165,  3192,  3196,  3202,  3207,  3218,  3221,  3227,  3236,  3239,
+    3245,  3249,  3250,  3256,  3257,  3258,  3259,  3260,  3261,  3262,
+    3266,  3267,  3271,  3267,  3283,  3284,  3288,  3288,  3295,  3295,
+    3309,  3312,  3320,  3328,  3339,  3340,  3344,  3347,  3353,  3360,
+    3364,  3372,  3376,  3389,  3392,  3398,  3398,  3418,  3421,  3427,
+    3439,  3451,  3454,  3460,  3460,  3475,  3475,  3491,  3491,  3512,
+    3515,  3521,  3524,  3530,  3534,  3541,  3546,  3551,  3558,  3561,
+    3570,  3574,  3583,  3586,  3589,  3597,  3597,  3619,  3625,  3628,
+    3633,  3636
 };
 #endif
 
@@ -977,35 +1005,37 @@ static const char *const yytname[] =
   "U8VEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID",
   "IN", "OUT", "INOUT", "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED",
   "NONUNIFORM", "COHERENT", "VOLATILE", "RESTRICT", "READONLY",
-  "WRITEONLY", "DVEC2", "DVEC3", "DVEC4", "DMAT2", "DMAT3", "DMAT4",
-  "F16VEC2", "F16VEC3", "F16VEC4", "F16MAT2", "F16MAT3", "F16MAT4",
-  "F32VEC2", "F32VEC3", "F32VEC4", "F32MAT2", "F32MAT3", "F32MAT4",
-  "F64VEC2", "F64VEC3", "F64VEC4", "F64MAT2", "F64MAT3", "F64MAT4",
-  "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", "EXPLICITINTERPAMD",
-  "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2",
-  "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2",
-  "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", "F16MAT2X2",
-  "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", "F16MAT3X3", "F16MAT3X4",
-  "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", "F32MAT2X2", "F32MAT2X3",
-  "F32MAT2X4", "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2",
-  "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4",
-  "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3",
-  "F64MAT4X4", "ATOMIC_UINT", "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", "F16SAMPLER1D",
-  "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
-  "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY",
-  "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY",
-  "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
+  "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT",
+  "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", "DVEC2", "DVEC3",
+  "DVEC4", "DMAT2", "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4",
+  "F16MAT2", "F16MAT3", "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4",
+  "F32MAT2", "F32MAT3", "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4",
+  "F64MAT2", "F64MAT3", "F64MAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH",
+  "LAYOUT", "EXPLICITINTERPAMD", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2",
+  "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3",
+  "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3",
+  "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2",
+  "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4",
+  "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", "F32MAT3X3",
+  "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2",
+  "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4",
+  "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "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", "F16SAMPLER1D", "F16SAMPLER2D", "F16SAMPLER3D",
+  "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY",
+  "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER",
+  "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW",
+  "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
   "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW",
   "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER",
   "SAMPLERSHADOW", "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE",
@@ -1082,7 +1112,7 @@ static const char *const yytname[] =
   "for_init_statement", "conditionopt", "for_rest_statement",
   "jump_statement", "translation_unit", "external_declaration",
   "function_definition", "$@13", "attribute", "attribute_list",
-  "single_attribute", YY_NULL
+  "single_attribute", YY_NULLPTR
 };
 #endif
 
@@ -1130,16 +1160,16 @@ static const yytype_uint16 yytoknum[] =
      615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
      625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
      635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
-     645
+     645,   646,   647,   648,   649,   650
 };
 # endif
 
-#define YYPACT_NINF -634
+#define YYPACT_NINF -641
 
 #define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-634)))
+  (!!((Yystate) == (-641)))
 
-#define YYTABLE_NINF -502
+#define YYTABLE_NINF -507
 
 #define yytable_value_is_error(Yytable_value) \
   0
@@ -1148,76 +1178,77 @@ static const yytype_uint16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    3391,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -311,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -295,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -301,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -241,  -634,  -302,  -342,
-    -290,  -254,  5696,  -300,  -634,  -210,  -634,  -634,  -634,  -634,
-    4160,  -634,  -634,  -634,  -634,  -219,  -634,  -634,   696,  -634,
-    -634,  -189,   -69,  -207,  -634,  8625,  -320,  -634,  -634,  -203,
-    -634,  5696,  -634,  -634,  -634,  5696,  -155,  -154,  -634,  -324,
-    -288,  -634,  -634,  -634,  6417,  -190,  -634,  -634,  -634,  -292,
-    -634,  -196,  -287,  -634,  -634,  5696,  -195,  -634,  -306,  1081,
-    -634,  -634,  -634,  -634,  -219,  -325,  -634,  6785,  -310,  -634,
-    -151,  -634,  -277,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  7889,  7889,  7889,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  -309,  -634,  -634,  -634,
-    -185,  -283,  8257,  -183,  -634,  7889,  -227,  -263,  -299,  -318,
-    -194,  -204,  -202,  -200,  -165,  -166,  -321,  -179,  -634,  -634,
-    7153,  -634,  -140,  7889,  -634,   -69,  5696,  5696,  -139,  4544,
-    -634,  -634,  -634,  -182,  -180,  -634,  -173,  -169,  -178,  7521,
-    -164,  7889,  -174,  -163,  -167,  -162,  -634,  -634,  -252,  -634,
-    -634,  -237,  -634,  -342,  -161,  -158,  -634,  -634,  -634,  -634,
-    1466,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-     -19,  -190,  6785,  -296,  6785,  -634,  -634,  6785,  5696,  -634,
-    -127,  -634,  -634,  -634,  -278,  -634,  -634,  7889,  -121,  -634,
-    -634,  7889,  -156,  -634,  -634,  -634,  7889,  7889,  7889,  7889,
-    7889,  7889,  7889,  7889,  7889,  7889,  7889,  7889,  7889,  7889,
-    7889,  7889,  7889,  7889,  7889,  -634,  -634,  -634,  -157,  -634,
-    -634,  -634,  -634,  4928,  -139,  -219,  -236,  -634,  -634,  -634,
-    -634,  -634,  1851,  -634,  7889,  -634,  -634,  -230,  7889,  -213,
-    -634,  -634,  -118,  -634,  1851,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  -634,  7889,  7889,  -634,  -634,
-    -634,  -634,  -634,  -634,  -634,  6785,  -634,  -270,  -634,  5312,
-    -634,  -634,  -153,  -150,  -634,  -634,  -634,  -634,  -634,  -227,
-    -227,  -263,  -263,  -299,  -299,  -299,  -299,  -318,  -318,  -194,
-    -204,  -202,  -200,  -165,  -166,  7889,  -634,  -634,  -226,  -190,
-    -139,  -634,  -113,  3006,  -275,  -634,  -253,  -634,  3776,  -148,
-    -282,  -634,  1851,  -634,  -634,  -634,  -634,  6049,  -634,  -634,
-    -208,  -634,  -634,  -147,  -634,  -634,  3776,  -146,  -634,  -150,
-    -111,  5696,  -145,  7889,  -144,  -118,  -143,  -634,  -634,  7889,
-    7889,  -634,  -149,  -141,   196,  -136,  2621,  -634,  -116,  -120,
-    2236,  -137,  -634,  -634,  -634,  -634,  -239,  7889,  2236,  -146,
-    -634,  -634,  1851,  6785,  -634,  -634,  -634,  -634,  -119,  -150,
-    -634,  -634,  1851,  -112,  -634,  -634,  -634
+    3431,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -321,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -300,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -306,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -247,  -641,  -307,  -320,  -295,  -287,  5766,  -305,  -641,
+    -223,  -641,  -641,  -641,  -641,  4210,  -641,  -641,  -641,  -641,
+    -275,  -641,  -641,   701,  -641,  -641,  -217,   -67,  -242,  -641,
+    8735,  -327,  -641,  -641,  -218,  -641,  5766,  -641,  -641,  -641,
+    5766,  -194,  -188,  -641,  -331,  -293,  -641,  -641,  -641,  6497,
+    -213,  -641,  -641,  -641,  -297,  -641,  -203,  -292,  -641,  -641,
+    5766,  -214,  -641,  -326,  1091,  -641,  -641,  -641,  -641,  -275,
+    -316,  -641,  6870,  -310,  -641,  -165,  -641,  -266,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  7989,  7989,  7989,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -315,  -641,  -641,  -641,  -190,  -288,  8362,  -187,  -641,
+    7989,  -233,  -227,  -185,  -322,  -312,  -210,  -207,  -204,  -172,
+    -171,  -328,  -184,  -641,  -641,  7243,  -641,  -145,  7989,  -641,
+     -67,  5766,  5766,  -144,  4599,  -641,  -641,  -641,  -186,  -182,
+    -641,  -178,  -175,  -181,  7616,  -174,  7989,  -177,  -170,  -169,
+    -173,  -641,  -641,  -259,  -641,  -641,  -244,  -641,  -320,  -166,
+    -163,  -641,  -641,  -641,  -641,  1481,  -641,  -641,  -641,  -641,
+    -641,  -641,  -641,  -641,  -641,   -19,  -213,  6870,  -301,  6870,
+    -641,  -641,  6870,  5766,  -641,  -127,  -641,  -641,  -641,  -285,
+    -641,  -641,  7989,  -126,  -641,  -641,  7989,  -161,  -641,  -641,
+    -641,  7989,  7989,  7989,  7989,  7989,  7989,  7989,  7989,  7989,
+    7989,  7989,  7989,  7989,  7989,  7989,  7989,  7989,  7989,  7989,
+    -641,  -641,  -641,  -162,  -641,  -641,  -641,  -641,  4988,  -144,
+    -275,  -243,  -641,  -641,  -641,  -641,  -641,  1871,  -641,  7989,
+    -641,  -641,  -238,  7989,  -209,  -641,  -641,  -123,  -641,  1871,
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  7989,  7989,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    6870,  -641,  -215,  -641,  5377,  -641,  -641,  -158,  -160,  -641,
+    -641,  -641,  -641,  -641,  -233,  -233,  -227,  -227,  -185,  -185,
+    -185,  -185,  -322,  -322,  -312,  -210,  -207,  -204,  -172,  -171,
+    7989,  -641,  -641,  -232,  -213,  -144,  -641,  -118,  3041,  -283,
+    -641,  -258,  -641,  3821,  -152,  -278,  -641,  1871,  -641,  -641,
+    -641,  -641,  6124,  -641,  -641,  -205,  -641,  -641,  -150,  -641,
+    -641,  3821,  -153,  -641,  -160,  -113,  5766,  -148,  7989,  -149,
+    -123,  -147,  -641,  -641,  7989,  7989,  -641,  -155,  -142,   194,
+    -141,  2651,  -641,  -121,  -124,  2261,  -115,  -641,  -641,  -641,
+    -641,  -255,  7989,  2261,  -153,  -641,  -641,  1871,  6870,  -641,
+    -641,  -641,  -641,  -122,  -160,  -641,  -641,  1871,  -116,  -641,
+    -641,  -641
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1225,108 +1256,109 @@ static const yytype_int16 yypact[] =
      means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-       0,   153,   154,   183,   181,   184,   182,   185,   152,   196,
-     186,   187,   194,   195,   192,   193,   190,   191,   188,   189,
-     169,   212,   213,   214,   215,   216,   217,   230,   231,   232,
-     227,   228,   229,   242,   243,   244,   224,   225,   226,   239,
-     240,   241,   221,   222,   223,   236,   237,   238,   218,   219,
-     220,   233,   234,   235,   197,   198,   199,   245,   246,   247,
-     158,   156,   157,   155,   161,   159,   160,   162,   163,   171,
-     164,   165,   166,   167,   168,   200,   201,   202,   257,   258,
-     259,   203,   204,   205,   269,   270,   271,   206,   207,   208,
-     281,   282,   283,   209,   210,   211,   293,   294,   295,   134,
-     133,   132,     0,   135,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   272,   273,   274,   275,   276,   277,   278,   279,
-     280,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
+       0,   153,   154,   188,   186,   189,   187,   190,   152,   201,
+     191,   192,   199,   200,   197,   198,   195,   196,   193,   194,
+     174,   217,   218,   219,   220,   221,   222,   235,   236,   237,
+     232,   233,   234,   247,   248,   249,   229,   230,   231,   244,
+     245,   246,   226,   227,   228,   241,   242,   243,   223,   224,
+     225,   238,   239,   240,   202,   203,   204,   250,   251,   252,
+     158,   156,   157,   155,   161,   159,   160,   162,   163,   176,
+     164,   170,   171,   172,   173,   165,   166,   167,   168,   169,
+     205,   206,   207,   262,   263,   264,   208,   209,   210,   274,
+     275,   276,   211,   212,   213,   286,   287,   288,   214,   215,
+     216,   298,   299,   300,   134,   133,   132,     0,   135,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   289,   290,   291,   292,
+     293,   294,   295,   296,   297,   301,   302,   303,   304,   305,
      306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   332,   333,   334,   335,   336,   337,   339,   340,   341,
-     342,   343,   344,   346,   347,   350,   351,   352,   354,   355,
-     317,   318,   338,   345,   356,   358,   359,   360,   362,   363,
-     454,   319,   320,   321,   348,   322,   326,   327,   330,   353,
-     357,   361,   323,   324,   328,   329,   349,   325,   331,   364,
-     365,   366,   368,   370,   372,   374,   376,   380,   381,   382,
-     383,   384,   385,   387,   388,   389,   390,   391,   392,   394,
-     396,   397,   398,   400,   401,   378,   386,   393,   402,   404,
-     405,   406,   408,   409,   367,   369,   371,   395,   373,   375,
-     377,   379,   399,   403,   407,   455,   456,   459,   460,   461,
-     462,   457,   458,   410,   412,   413,   414,   416,   417,   418,
-     420,   421,   422,   424,   425,   426,   428,   429,   430,   432,
-     433,   434,   436,   437,   438,   440,   441,   442,   444,   445,
-     446,   448,   449,   450,   452,   453,   411,   415,   419,   423,
-     427,   435,   439,   443,   431,   447,   451,     0,   180,   464,
-     549,   131,   142,   465,   466,   467,     0,   548,     0,   550,
-       0,   108,   107,     0,   119,   124,   149,   148,   146,   150,
-       0,   143,   145,   151,   129,   174,   147,   463,     0,   545,
-     547,     0,     0,     0,   470,     0,     0,    96,    93,     0,
-     106,     0,   115,   109,   117,     0,   118,     0,    94,   125,
-       0,    99,   144,   130,     0,   175,     1,   546,   172,     0,
-     141,   139,     0,   137,   468,     0,     0,    97,     0,     0,
-     551,   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,   176,
-      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,   170,     0,     0,   136,     0,     0,     0,     0,     0,
-     472,    95,    98,     0,     0,   530,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   496,   505,   509,    44,    77,
-      90,     0,   485,     0,   151,   129,   488,   507,   487,   486,
-       0,   489,   490,   511,   491,   518,   492,   493,   526,   494,
-       0,   113,     0,   121,     0,   480,   128,     0,     0,   104,
-       0,   101,    37,    38,     0,    21,    22,     0,     0,    27,
-      26,     0,   180,    30,    32,    39,     0,     0,     0,     0,
+     316,   317,   318,   319,   320,   321,   337,   338,   339,   340,
+     341,   342,   344,   345,   346,   347,   348,   349,   351,   352,
+     355,   356,   357,   359,   360,   322,   323,   343,   350,   361,
+     363,   364,   365,   367,   368,   459,   324,   325,   326,   353,
+     327,   331,   332,   335,   358,   362,   366,   328,   329,   333,
+     334,   354,   330,   336,   369,   370,   371,   373,   375,   377,
+     379,   381,   385,   386,   387,   388,   389,   390,   392,   393,
+     394,   395,   396,   397,   399,   401,   402,   403,   405,   406,
+     383,   391,   398,   407,   409,   410,   411,   413,   414,   372,
+     374,   376,   400,   378,   380,   382,   384,   404,   408,   412,
+     460,   461,   464,   465,   466,   467,   462,   463,   415,   417,
+     418,   419,   421,   422,   423,   425,   426,   427,   429,   430,
+     431,   433,   434,   435,   437,   438,   439,   441,   442,   443,
+     445,   446,   447,   449,   450,   451,   453,   454,   455,   457,
+     458,   416,   420,   424,   428,   432,   440,   444,   448,   436,
+     452,   456,     0,   185,   469,   554,   131,   142,   470,   471,
+     472,     0,   553,     0,   555,     0,   108,   107,     0,   119,
+     124,   149,   148,   146,   150,     0,   143,   145,   151,   129,
+     179,   147,   468,     0,   550,   552,     0,     0,     0,   475,
+       0,     0,    96,    93,     0,   106,     0,   115,   109,   117,
+       0,   118,     0,    94,   125,     0,    99,   144,   130,     0,
+     180,     1,   551,   177,     0,   141,   139,     0,   137,   473,
+       0,     0,    97,     0,     0,   556,   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,   181,    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,   175,     0,     0,   136,
+       0,     0,     0,     0,     0,   477,    95,    98,     0,     0,
+     535,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     501,   510,   514,    44,    77,    90,     0,   490,     0,   151,
+     129,   493,   512,   492,   491,     0,   494,   495,   516,   496,
+     523,   497,   498,   531,   499,     0,   113,     0,   121,     0,
+     485,   128,     0,     0,   104,     0,   101,    37,    38,     0,
+      21,    22,     0,     0,    27,    26,     0,   185,    30,    32,
+      39,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    75,   177,   178,     0,   173,
-      92,   140,   138,     0,     0,   478,     0,   476,   471,   473,
-     541,   540,     0,   532,     0,   544,   542,     0,     0,     0,
-     525,   528,     0,   495,     0,    80,    81,    83,    82,    85,
-      86,    87,    88,    89,    84,    79,     0,     0,   510,   506,
-     508,   512,   519,   527,   123,     0,   483,     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,   179,   469,     0,   479,
-       0,   474,     0,     0,     0,   543,     0,   524,     0,   555,
-       0,   553,   497,    78,    91,   122,   481,     0,   103,    18,
-       0,   475,   477,     0,   535,   534,   537,   503,   520,   516,
-       0,     0,     0,     0,     0,     0,     0,   482,   484,     0,
-       0,   536,     0,     0,   515,     0,     0,   513,     0,     0,
-       0,     0,   552,   554,   498,    76,     0,   538,     0,   503,
-     502,   504,   522,     0,   500,   529,   499,   556,     0,   539,
-     533,   514,   523,     0,   517,   531,   521
+      75,   182,   183,     0,   178,    92,   140,   138,     0,     0,
+     483,     0,   481,   476,   478,   546,   545,     0,   537,     0,
+     549,   547,     0,     0,     0,   530,   533,     0,   500,     0,
+      80,    81,    83,    82,    85,    86,    87,    88,    89,    84,
+      79,     0,     0,   515,   511,   513,   517,   524,   532,   123,
+       0,   488,     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,   184,   474,     0,   484,     0,   479,     0,     0,     0,
+     548,     0,   529,     0,   560,     0,   558,   502,    78,    91,
+     122,   486,     0,   103,    18,     0,   480,   482,     0,   540,
+     539,   542,   508,   525,   521,     0,     0,     0,     0,     0,
+       0,     0,   487,   489,     0,     0,   541,     0,     0,   520,
+       0,     0,   518,     0,     0,     0,     0,   557,   559,   503,
+      76,     0,   543,     0,   508,   507,   509,   527,     0,   505,
+     534,   504,   561,     0,   544,   538,   519,   528,     0,   522,
+     536,   526
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,  -634,  -289,  -634,  -358,  -355,  -401,  -364,  -279,  -307,
-    -276,  -280,  -273,  -281,  -634,  -354,  -634,  -378,  -634,  -367,
-    -397,     1,  -634,  -634,  -634,     2,  -634,  -634,  -634,   -98,
-     -93,   -92,  -634,  -634,  -600,  -634,  -634,  -634,  -634,  -181,
-    -634,  -319,  -326,  -634,     6,  -634,     0,  -332,  -634,   -54,
-    -634,  -634,  -634,  -428,  -433,  -272,  -353,  -477,  -634,  -357,
-    -467,  -633,  -400,  -634,  -634,  -410,  -408,  -634,  -634,   -80,
-    -545,  -350,  -634,  -216,  -634,  -371,  -634,  -214,  -634,  -634,
-    -634,  -634,  -212,  -634,  -634,  -634,  -634,  -634,  -634,  -634,
-    -634,   -61,  -634,  -634,  -634,  -634,  -375
+    -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,  -641,  -294,  -641,  -357,  -356,  -407,  -360,  -314,  -282,
+    -313,  -281,  -284,  -289,  -641,  -359,  -641,  -383,  -641,  -373,
+    -403,     1,  -641,  -641,  -641,     2,  -641,  -641,  -641,  -103,
+     -98,   -97,  -641,  -641,  -606,  -641,  -641,  -641,  -641,  -183,
+    -641,  -323,  -332,  -641,     6,  -641,     0,  -338,  -641,   -59,
+    -641,  -641,  -641,  -433,  -438,  -280,  -361,  -482,  -641,  -363,
+    -473,  -640,  -404,  -641,  -641,  -415,  -414,  -641,  -641,   -82,
+    -550,  -355,  -641,  -221,  -641,  -376,  -641,  -219,  -641,  -641,
+    -641,  -641,  -216,  -641,  -641,  -641,  -641,  -641,  -641,  -641,
+    -641,   -66,  -641,  -641,  -641,  -641,  -380
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,   414,   415,   416,   592,   417,   418,   419,   420,   421,
-     422,   423,   468,   425,   426,   427,   428,   429,   430,   431,
-     432,   433,   434,   435,   436,   469,   615,   470,   576,   471,
-     541,   472,   318,   498,   392,   473,   320,   321,   322,   352,
-     353,   354,   323,   324,   325,   326,   327,   328,   372,   373,
-     329,   330,   331,   332,   438,   369,   439,   365,   335,   336,
-     337,   446,   375,   449,   450,   546,   547,   496,   587,   476,
-     477,   478,   479,   564,   656,   685,   664,   665,   666,   686,
-     480,   481,   482,   483,   667,   652,   484,   485,   668,   693,
-     486,   487,   488,   628,   552,   623,   646,   662,   663,   489,
-     338,   339,   340,   349,   490,   630,   631
+      -1,   419,   420,   421,   597,   422,   423,   424,   425,   426,
+     427,   428,   473,   430,   431,   432,   433,   434,   435,   436,
+     437,   438,   439,   440,   441,   474,   620,   475,   581,   476,
+     546,   477,   323,   503,   397,   478,   325,   326,   327,   357,
+     358,   359,   328,   329,   330,   331,   332,   333,   377,   378,
+     334,   335,   336,   337,   443,   374,   444,   370,   340,   341,
+     342,   451,   380,   454,   455,   551,   552,   501,   592,   481,
+     482,   483,   484,   569,   661,   690,   669,   670,   671,   691,
+     485,   486,   487,   488,   672,   657,   489,   490,   673,   698,
+     491,   492,   493,   633,   557,   628,   651,   667,   668,   494,
+     343,   344,   345,   354,   495,   635,   636
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1334,118 +1366,119 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     334,   317,   319,   355,   362,   455,   333,   456,   457,   495,
-     437,   460,   370,   580,   378,   584,   549,   586,   543,   632,
-     588,   346,   343,   523,   524,   534,   348,   388,   650,   362,
-     505,   506,   355,   681,   386,   364,   364,   684,   521,   522,
-     364,   504,   492,   387,   513,   684,   650,   341,   377,   -34,
-     440,   507,   491,   493,   440,   508,   447,   497,   525,   526,
-     535,   344,   452,   342,   440,   357,   347,   441,   358,   350,
-     589,   585,   444,   442,   389,   424,   510,   390,   445,   654,
-     391,   591,   511,   655,   647,   622,   538,   577,   500,   540,
-     577,   501,   557,   636,   559,   637,   565,   566,   567,   568,
-     569,   570,   571,   572,   573,   574,   648,   519,   635,   520,
-     549,   351,   577,   359,   495,   575,   495,   502,   503,   495,
-     688,   362,   603,   604,   605,   606,   577,   447,   577,   620,
-     447,   578,   621,   595,   368,   577,   515,   692,   625,   620,
-     593,   364,   641,   313,   314,   315,   516,   517,   518,   527,
-     528,   424,   577,   627,   424,   374,   549,   577,   659,   379,
-     658,   599,   600,   607,   608,   580,   601,   602,   384,   385,
-     440,   443,   499,   451,   509,   514,   529,   530,   531,   447,
-     532,   533,   536,   539,   545,   553,   550,   624,   551,   554,
-     555,   626,   560,   562,   558,   561,   590,   -35,   633,   634,
-     -33,   563,   594,   -28,   616,   629,   694,   495,   639,   643,
-     653,   660,   669,   619,   670,   577,  -501,   672,   678,   677,
-     674,   679,   687,   610,   447,   580,   465,   596,   597,   598,
-     424,   424,   424,   424,   424,   424,   424,   424,   424,   424,
-     424,   424,   424,   424,   424,   424,   682,   683,   640,   695,
-     609,   696,   612,   614,   371,   611,   671,   382,   381,   495,
-     613,   649,   345,   383,   542,   680,   644,   642,   690,   380,
-     447,   691,   618,   645,   581,   661,   582,   367,   583,   649,
-     673,   675,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   676,     0,     0,     0,     0,     0,   540,
-       0,     0,     0,   463,     0,   495,     0,     0,     0,   651,
-     689,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   356,     0,     0,   362,     0,   651,   333,     0,
-     363,     0,     0,     0,     0,     0,   333,     0,   334,   317,
-     319,     0,     0,     0,   333,   376,     0,     0,     0,     0,
-       0,   356,     0,     0,     0,   356,     0,   333,     0,     0,
-       0,   333,     0,     0,   424,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   448,     0,     0,     0,   475,
-       0,   333,     0,     0,     0,   474,     0,     0,     0,     0,
+     339,   322,   324,   367,   360,   460,   338,   461,   462,   500,
+     442,   465,   585,   383,   375,   589,   554,   591,   548,   637,
+     593,   351,   348,   539,   528,   529,   393,   655,   367,   510,
+     511,   686,   391,   360,   369,   689,   532,   533,   369,   445,
+     509,   392,   346,   689,   518,   655,   382,   457,   -34,   369,
+     512,   496,   498,   353,   513,   445,   497,   452,   540,   530,
+     531,   349,   502,   347,   445,   362,   352,   446,   363,   355,
+     594,   590,   449,   447,   394,   429,   515,   395,   450,   596,
+     396,   652,   516,   356,   627,   582,   543,   582,   659,   545,
+     369,   562,   660,   564,   570,   571,   572,   573,   574,   575,
+     576,   577,   578,   579,   505,   364,   653,   506,   640,   693,
+     554,   373,   582,   580,   500,   582,   500,   507,   508,   500,
+     367,   608,   609,   610,   611,   379,   582,   625,   452,   583,
+     626,   452,   582,   600,   389,   630,   520,   697,   625,   598,
+     390,   646,   318,   319,   320,   521,   522,   523,   524,   384,
+     525,   429,   445,   641,   429,   642,   554,   526,   527,   456,
+     663,   582,   632,   504,   585,   582,   664,   604,   605,   448,
+     606,   607,   612,   613,   514,   534,   519,   535,   537,   536,
+     452,   538,   541,   544,   550,   558,   629,   555,   559,   563,
+     631,   556,   560,   566,   565,   568,   567,   -35,   638,   639,
+     -33,   595,   599,   -28,   621,   634,   699,   500,   644,   648,
+     582,   658,   624,   665,  -506,   674,   675,   677,   682,   684,
+     614,   679,   683,   616,   585,   452,   470,   601,   602,   603,
+     429,   429,   429,   429,   429,   429,   429,   429,   429,   429,
+     429,   429,   429,   429,   429,   429,   687,   645,   688,   692,
+     619,   700,   701,   615,   618,   676,   617,   387,   386,   500,
+     654,   376,   350,   388,   647,   649,   685,   547,   695,   623,
+     696,   452,   385,   650,   586,   666,   587,   372,   654,   588,
+     678,   680,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   681,     0,     0,     0,     0,     0,     0,   545,
+       0,     0,     0,     0,     0,   500,     0,     0,   468,   694,
+     656,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   367,     0,     0,   361,   656,     0,
+       0,     0,     0,   338,     0,   368,     0,     0,     0,     0,
+       0,   338,     0,   339,   322,   324,     0,     0,     0,   338,
+     381,     0,     0,     0,     0,     0,   361,     0,     0,     0,
+     361,     0,   338,     0,   429,     0,   338,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     453,     0,     0,     0,   480,     0,   338,     0,     0,     0,
+     479,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   448,   544,     0,   448,
-       0,     0,   333,   333,     0,   333,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   453,   549,     0,   453,     0,     0,   338,   338,     0,
+     338,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     475,     0,     0,     0,     0,     0,   474,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   448,     0,
-       0,     0,     0,     0,   333,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   480,     0,     0,     0,     0,
+       0,   479,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   453,     0,     0,     0,     0,     0,   338,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   448,     0,     0,     0,     0,     0,   333,
-       0,     0,   475,     0,     0,     0,     0,     0,   474,     0,
-       0,     0,     0,     0,   475,     0,     0,     0,     0,     0,
-     474,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   448,
-       0,     0,     0,     0,     0,   333,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   453,     0,
+       0,     0,     0,     0,   338,     0,     0,   480,     0,     0,
+       0,     0,     0,   479,     0,     0,     0,     0,     0,   480,
+       0,     0,     0,     0,     0,   479,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   453,     0,     0,     0,     0,     0,
+     338,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   475,     0,     0,     0,     0,   475,   474,
-       0,     0,   475,     0,   474,     0,     0,     0,   474,     0,
-       0,     0,     0,     0,     0,     0,   475,     0,     0,     0,
-       0,   363,   474,     0,     0,     0,     0,   333,     0,     0,
-       0,     0,     0,     0,     0,     0,   475,     0,     0,     0,
-     475,     0,   474,     0,     0,     0,   474,     0,   475,     0,
-       0,     0,   475,     0,   474,     0,     0,     0,   474,     0,
-       0,     0,   475,     0,     0,     0,   366,     0,   474,     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,     0,     0,
-     309,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   480,     0,
+       0,     0,     0,   480,   479,     0,     0,   480,     0,   479,
+       0,     0,     0,   479,     0,     0,     0,     0,     0,     0,
+       0,   480,     0,     0,     0,     0,   368,   479,     0,     0,
+       0,     0,   338,     0,     0,     0,     0,     0,     0,     0,
+       0,   480,     0,     0,     0,   480,     0,   479,     0,     0,
+       0,   479,     0,   480,     0,     0,     0,   480,     0,   479,
+       0,     0,     0,   479,     0,     0,     0,   480,     0,     0,
+       0,   371,     0,   479,     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,     0,     0,
+     314,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   310,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,   312,
-     313,   314,   315,   316,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   315,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,   453,   454,   455,     0,   456,   457,   458,
-     459,   460,   461,   462,    20,    21,    22,    23,    24,    25,
+      17,    18,    19,   458,   459,   460,     0,   461,   462,   463,
+     464,   465,   466,   467,    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,
@@ -1474,55 +1507,17 @@ static const yytype_int16 yytable[] =
      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,   463,   393,   309,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,     0,     0,
-     406,   407,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   408,
-       0,   464,     0,   465,   466,     0,     0,     0,     0,   467,
-     410,   411,   412,   413,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   311,   312,   313,   314,   315,   316,     1,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,   453,   454,
-     455,     0,   456,   457,   458,   459,   460,   461,   462,    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,   463,   393,
-     309,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,     0,     0,   406,   407,     0,     0,     0,
+     306,   307,   308,   309,   310,   311,   312,   313,   468,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   408,     0,   464,     0,   465,   579,
-       0,     0,     0,     0,   467,   410,   411,   412,   413,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,   312,
-     313,   314,   315,   316,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   413,     0,   469,     0,   470,   471,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,   453,   454,   455,     0,   456,   457,   458,
-     459,   460,   461,   462,    20,    21,    22,    23,    24,    25,
+      17,    18,    19,   458,   459,   460,     0,   461,   462,   463,
+     464,   465,   466,   467,    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,
@@ -1551,55 +1546,17 @@ static const yytype_int16 yytable[] =
      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,   463,   393,   309,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,     0,     0,
-     406,   407,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   408,
-       0,   464,     0,   465,     0,     0,     0,     0,     0,   467,
-     410,   411,   412,   413,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   311,   312,   313,   314,   315,   316,     1,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,   453,   454,
-     455,     0,   456,   457,   458,   459,   460,   461,   462,    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,   463,   393,
-     309,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,     0,     0,   406,   407,     0,     0,     0,
+     306,   307,   308,   309,   310,   311,   312,   313,   468,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   408,     0,   464,     0,   379,     0,
-       0,     0,     0,     0,   467,   410,   411,   412,   413,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,   312,
-     313,   314,   315,   316,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   413,     0,   469,     0,   470,   584,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,   453,   454,   455,     0,   456,   457,   458,
-     459,   460,   461,   462,    20,    21,    22,    23,    24,    25,
+      17,    18,    19,   458,   459,   460,     0,   461,   462,   463,
+     464,   465,   466,   467,    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,
@@ -1628,55 +1585,17 @@ static const yytype_int16 yytable[] =
      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,   463,   393,   309,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,     0,     0,
-     406,   407,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   408,
-       0,   464,     0,     0,     0,     0,     0,     0,     0,   467,
-     410,   411,   412,   413,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   311,   312,   313,   314,   315,   316,     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,     0,   393,
-     309,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,     0,     0,   406,   407,     0,     0,     0,
+     306,   307,   308,   309,   310,   311,   312,   313,   468,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   408,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   467,   410,   411,   412,   413,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,   312,
-     313,   314,   315,   316,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   413,     0,   469,     0,   470,     0,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     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,
+      17,    18,    19,   458,   459,   460,     0,   461,   462,   463,
+     464,   465,   466,   467,    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,
@@ -1705,52 +1624,170 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   309,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     306,   307,   308,   309,   310,   311,   312,   313,   468,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   413,     0,   469,     0,   384,     0,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,   458,   459,   460,     0,   461,   462,   463,
+     464,   465,   466,   467,    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,   468,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   310,
+       0,     0,     0,     0,   413,     0,   469,     0,     0,     0,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     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,     0,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   311,   312,   313,   314,   315,   316,     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,     0,   393,
-     309,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,     0,     0,   406,   407,     0,     0,     0,
+       0,     0,     0,     0,   413,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   472,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     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,     0,     0,
+     314,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   315,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,   321,     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,     0,   398,
+     314,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,     0,     0,   411,   412,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   408,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   410,   411,   412,   413,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,   312,
-     313,   314,   315,     1,     2,     3,     4,     5,     6,     7,
+       0,     0,     0,     0,   413,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   415,   416,   417,   418,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   316,   317,
+     318,   319,   320,     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,
@@ -1782,52 +1819,53 @@ static const yytype_int16 yytable[] =
      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
      287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
      297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,     0,   360,   309,     0,     0,     0,     0,     0,
+     307,   308,   309,   310,   311,   312,   313,     0,   365,   314,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   361,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   311,   312,   313,   314,   315,     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,     0,     0,   309,     0,
+       0,     0,     0,   366,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   316,   317,   318,
+     319,   320,     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,     0,     0,   314,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   548,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   553,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   311,   312,   313,   314,
-     315,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+       0,     0,     0,     0,     0,     0,   316,   317,   318,   319,
+     320,     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,
@@ -1859,51 +1897,52 @@ static const yytype_int16 yytable[] =
      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-       0,     0,   309,     0,     0,     0,     0,     0,     0,     0,
+     309,   310,   311,   312,   313,     0,     0,   314,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   617,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   622,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     311,   312,   313,   314,   315,     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,     0,     0,   309,     0,     0,     0,
+       0,     0,     0,     0,     0,   316,   317,   318,   319,   320,
+       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,     0,     0,   314,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   638,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   311,   312,   313,   314,   315,     1,
+       0,     0,     0,     0,     0,   643,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   316,   317,   318,   319,   320,     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,
@@ -1935,48 +1974,49 @@ static const yytype_int16 yytable[] =
      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,     0,     0,
-     309,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
+     311,   312,   313,     0,     0,   314,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       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,   311,   312,
-     313,   314,   315,    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,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,     0,     0,     0,     0,     0,   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,     0,   393,   309,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,     0,     0,   406,   407,
+       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,   316,   317,   318,   319,   320,    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,    80,    81,    82,
+      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
+     103,     0,     0,     0,     0,     0,   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,     0,   398,   314,   399,   400,   401,   402,   403,   404,
+     405,   406,   407,   408,   409,   410,     0,     0,   411,   412,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   408,     0,     0,
-       0,   494,   657,     0,     0,     0,     0,     0,   410,   411,
-     412,   413,     3,     4,     5,     6,     7,     0,     9,    10,
+       0,     0,     0,     0,     0,     0,     0,   413,     0,     0,
+       0,   499,   662,     0,     0,     0,     0,     0,   415,   416,
+     417,   418,     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,
@@ -1984,10 +2024,10 @@ static const yytype_int16 yytable[] =
       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,    75,    76,    77,    78,    79,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,     0,
-       0,     0,     0,     0,   104,   105,   106,   107,   108,   109,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,     0,     0,     0,     0,     0,   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,
@@ -2007,49 +2047,50 @@ static const yytype_int16 yytable[] =
      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,     0,
-     393,   309,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,     0,     0,   406,   407,     0,     0,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,     0,   398,   314,   399,   400,   401,
+     402,   403,   404,   405,   406,   407,   408,   409,   410,     0,
+       0,   411,   412,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   408,     0,     0,   409,     0,
-       0,     0,     0,     0,     0,     0,   410,   411,   412,   413,
-       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,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,     0,     0,     0,
-       0,     0,   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,     0,   393,   309,
-     394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
-     404,   405,     0,     0,   406,   407,     0,     0,     0,     0,
+     413,     0,     0,   414,     0,     0,     0,     0,     0,     0,
+       0,   415,   416,   417,   418,     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,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,     0,     0,     0,
+       0,     0,   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,     0,   398,   314,
+     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
+     409,   410,     0,     0,   411,   412,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   408,     0,     0,     0,   494,     0,     0,
-       0,     0,     0,     0,   410,   411,   412,   413,     3,     4,
+       0,     0,     0,   413,     0,     0,     0,   499,     0,     0,
+       0,     0,     0,     0,   415,   416,   417,   418,     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,
@@ -2058,10 +2099,10 @@ static const yytype_int16 yytable[] =
       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,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+       0,     0,     0,     0,     0,     0,    80,    81,    82,    83,
       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      94,    95,    96,    97,    98,     0,     0,     0,     0,     0,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+       0,     0,     0,     0,     0,   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,
@@ -2081,49 +2122,50 @@ static const yytype_int16 yytable[] =
      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,     0,   393,   309,   394,   395,
-     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
-       0,     0,   406,   407,     0,     0,     0,     0,     0,     0,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+       0,   398,   314,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,   410,     0,     0,   411,   412,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   408,     0,     0,   537,     0,     0,     0,     0,     0,
-       0,     0,   410,   411,   412,   413,     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,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,     0,     0,     0,     0,     0,   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,     0,   393,   309,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,     0,     0,
-     406,   407,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   408,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   556,
-     410,   411,   412,   413,     3,     4,     5,     6,     7,     0,
+       0,     0,     0,     0,     0,     0,   413,     0,     0,   542,
+       0,     0,     0,     0,     0,     0,     0,   415,   416,   417,
+     418,     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,    80,
+      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
+      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+     101,   102,   103,     0,     0,     0,     0,     0,   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,     0,   398,   314,   399,   400,   401,   402,
+     403,   404,   405,   406,   407,   408,   409,   410,     0,     0,
+     411,   412,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   413,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   561,
+     415,   416,   417,   418,     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,
@@ -2131,11 +2173,11 @@ static const yytype_int16 yytable[] =
       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,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+       0,    69,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    80,    81,    82,    83,    84,    85,    86,    87,
       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,     0,     0,     0,     0,     0,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+      98,    99,   100,   101,   102,   103,     0,     0,     0,     0,
+       0,   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,
@@ -2155,48 +2197,49 @@ static const yytype_int16 yytable[] =
      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
      288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
      298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
-     308,     0,   393,   309,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,     0,     0,   406,   407,
+     308,   309,   310,   311,   312,   313,     0,   398,   314,   399,
+     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
+     410,     0,     0,   411,   412,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   408,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   410,   411,
-     412,   413,     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,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,     0,
-       0,     0,     0,     0,   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,   512,     0,
-     393,   309,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,     0,     0,   406,   407,     0,     0,
+       0,     0,   413,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   415,   416,   417,   418,     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,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,     0,
+       0,     0,     0,     0,   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,   517,     0,
+     398,   314,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,   409,   410,     0,     0,   411,   412,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   408,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   410,   411,   412,   413,
+       0,     0,     0,     0,     0,   413,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   415,   416,   417,   418,
        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,
@@ -2205,10 +2248,10 @@ static const yytype_int16 yytable[] =
       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,    75,    76,    77,    78,    79,    80,    81,
+       0,     0,     0,     0,     0,     0,     0,     0,    80,    81,
       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,     0,     0,     0,
-       0,     0,   104,   105,   106,   107,   108,   109,   110,   111,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,     0,     0,     0,     0,     0,   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,
@@ -2228,123 +2271,86 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   309
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,     0,     0,   314
 };
 
 static const yytype_int16 yycheck[] =
 {
-       0,     0,     0,   322,   330,    24,     0,    26,    27,   387,
-     364,    30,    81,   480,   346,   492,   449,   494,   446,   564,
-     497,   323,   323,   341,   342,   346,   368,   359,   628,   355,
-     339,   340,   351,   666,   358,   360,   360,   670,   337,   338,
-     360,   408,   367,   367,   422,   678,   646,   358,   368,   358,
-     360,   360,   384,   385,   360,   364,   375,   367,   376,   377,
-     381,   362,   368,   358,   360,   365,   368,   359,   368,   359,
-     498,   367,   359,   365,   362,   364,   359,   365,   365,   361,
-     368,   359,   365,   365,   359,   552,   440,   365,   365,   443,
-     365,   368,   459,   363,   461,   365,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   359,   370,   585,   372,
-     543,   365,   365,   323,   492,   367,   494,   406,   407,   497,
-     359,   447,   523,   524,   525,   526,   365,   446,   365,   365,
-     449,   368,   368,   511,   323,   365,   425,   682,   368,   365,
-     507,   360,   368,   384,   385,   386,   373,   374,   375,   343,
-     344,   440,   365,   366,   443,   362,   589,   365,   366,   362,
-     637,   519,   520,   527,   528,   632,   521,   522,   323,   323,
-     360,   367,   323,   368,   359,   358,   380,   379,   378,   498,
-     345,   347,   361,   323,   323,   358,   368,   554,   368,   358,
-     368,   558,   366,   360,   358,   358,   323,   358,   576,   577,
-     358,   363,   323,   359,   361,   323,   683,   585,   361,   322,
-     358,   358,   323,   545,   359,   365,   362,   361,   359,   368,
-     363,    25,   359,   530,   543,   692,   362,   516,   517,   518,
-     519,   520,   521,   522,   523,   524,   525,   526,   527,   528,
-     529,   530,   531,   532,   533,   534,   362,   367,   615,   368,
-     529,   363,   532,   534,   323,   531,   653,   355,   351,   637,
-     533,   628,   316,   355,   445,   665,   623,   620,   678,   349,
-     589,   679,   544,   623,   490,   646,   490,   338,   490,   646,
-     655,   659,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   660,    -1,    -1,    -1,    -1,    -1,   653,
-      -1,    -1,    -1,   322,    -1,   683,    -1,    -1,    -1,   628,
-     677,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   322,    -1,    -1,   651,    -1,   646,   322,    -1,
-     330,    -1,    -1,    -1,    -1,    -1,   330,    -1,   338,   338,
-     338,    -1,    -1,    -1,   338,   345,    -1,    -1,    -1,    -1,
-      -1,   351,    -1,    -1,    -1,   355,    -1,   351,    -1,    -1,
-      -1,   355,    -1,    -1,   653,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,    -1,   379,
-      -1,   375,    -1,    -1,    -1,   379,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -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,     0,     0,   335,   327,    24,     0,    26,    27,   392,
+     369,    30,   485,   351,    81,   497,   454,   499,   451,   569,
+     502,   328,   328,   351,   346,   347,   364,   633,   360,   344,
+     345,   671,   363,   356,   365,   675,   348,   349,   365,   365,
+     413,   372,   363,   683,   427,   651,   373,   373,   363,   365,
+     365,   389,   390,   373,   369,   365,   372,   380,   386,   381,
+     382,   367,   372,   363,   365,   370,   373,   364,   373,   364,
+     503,   372,   364,   370,   367,   369,   364,   370,   370,   364,
+     373,   364,   370,   370,   557,   370,   445,   370,   366,   448,
+     365,   464,   370,   466,   353,   354,   355,   356,   357,   358,
+     359,   360,   361,   362,   370,   328,   364,   373,   590,   364,
+     548,   328,   370,   372,   497,   370,   499,   411,   412,   502,
+     452,   528,   529,   530,   531,   367,   370,   370,   451,   373,
+     373,   454,   370,   516,   328,   373,   430,   687,   370,   512,
+     328,   373,   389,   390,   391,   378,   379,   380,   375,   367,
+     377,   445,   365,   368,   448,   370,   594,   342,   343,   373,
+     642,   370,   371,   328,   637,   370,   371,   524,   525,   372,
+     526,   527,   532,   533,   364,   385,   363,   384,   350,   383,
+     503,   352,   366,   328,   328,   363,   559,   373,   363,   363,
+     563,   373,   373,   363,   371,   368,   365,   363,   581,   582,
+     363,   328,   328,   364,   366,   328,   688,   590,   366,   327,
+     370,   363,   550,   363,   367,   328,   364,   366,   373,    25,
+     534,   368,   364,   536,   697,   548,   367,   521,   522,   523,
+     524,   525,   526,   527,   528,   529,   530,   531,   532,   533,
+     534,   535,   536,   537,   538,   539,   367,   620,   372,   364,
+     539,   373,   368,   535,   538,   658,   537,   360,   356,   642,
+     633,   328,   321,   360,   625,   628,   670,   450,   683,   549,
+     684,   594,   354,   628,   495,   651,   495,   343,   651,   495,
+     660,   664,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   665,    -1,    -1,    -1,    -1,    -1,    -1,   658,
+      -1,    -1,    -1,    -1,    -1,   688,    -1,    -1,   327,   682,
+     633,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   656,    -1,    -1,   327,   651,    -1,
+      -1,    -1,    -1,   327,    -1,   335,    -1,    -1,    -1,    -1,
+      -1,   335,    -1,   343,   343,   343,    -1,    -1,    -1,   343,
+     350,    -1,    -1,    -1,    -1,    -1,   356,    -1,    -1,    -1,
+     360,    -1,   356,    -1,   658,    -1,   360,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     380,    -1,    -1,    -1,   384,    -1,   380,    -1,    -1,    -1,
+     384,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   446,   447,    -1,   449,
-      -1,    -1,   446,   447,    -1,   449,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     480,    -1,    -1,    -1,    -1,    -1,   480,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,    -1,
-      -1,    -1,    -1,    -1,   498,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   451,   452,    -1,   454,    -1,    -1,   451,   452,    -1,
+     454,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   543,    -1,    -1,    -1,    -1,    -1,   543,
-      -1,    -1,   552,    -1,    -1,    -1,    -1,    -1,   552,    -1,
-      -1,    -1,    -1,    -1,   564,    -1,    -1,    -1,    -1,    -1,
-     564,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   589,
-      -1,    -1,    -1,    -1,    -1,   589,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   485,    -1,    -1,    -1,    -1,
+      -1,   485,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   503,    -1,    -1,    -1,    -1,    -1,   503,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   623,    -1,    -1,    -1,    -1,   628,   623,
-      -1,    -1,   632,    -1,   628,    -1,    -1,    -1,   632,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   646,    -1,    -1,    -1,
-      -1,   651,   646,    -1,    -1,    -1,    -1,   651,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   666,    -1,    -1,    -1,
-     670,    -1,   666,    -1,    -1,    -1,   670,    -1,   678,    -1,
-      -1,    -1,   682,    -1,   678,    -1,    -1,    -1,   682,    -1,
-      -1,    -1,   692,    -1,    -1,    -1,     0,    -1,   692,     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,    -1,    -1,
-     324,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   548,    -1,
+      -1,    -1,    -1,    -1,   548,    -1,    -1,   557,    -1,    -1,
+      -1,    -1,    -1,   557,    -1,    -1,    -1,    -1,    -1,   569,
+      -1,    -1,    -1,    -1,    -1,   569,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   594,    -1,    -1,    -1,    -1,    -1,
+     594,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   368,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,   383,
-     384,   385,   386,   387,     3,     4,     5,     6,     7,     8,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   628,    -1,
+      -1,    -1,    -1,   633,   628,    -1,    -1,   637,    -1,   633,
+      -1,    -1,    -1,   637,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   651,    -1,    -1,    -1,    -1,   656,   651,    -1,    -1,
+      -1,    -1,   656,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   671,    -1,    -1,    -1,   675,    -1,   671,    -1,    -1,
+      -1,   675,    -1,   683,    -1,    -1,    -1,   687,    -1,   683,
+      -1,    -1,    -1,   687,    -1,    -1,    -1,   697,    -1,    -1,
+      -1,     0,    -1,   697,     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,
+      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,
@@ -2373,52 +2379,14 @@ static const yytype_int16 yycheck[] =
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
      309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,    -1,    -1,
-     339,   340,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
-      -1,   360,    -1,   362,   363,    -1,    -1,    -1,    -1,   368,
-     369,   370,   371,   372,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   382,   383,   384,   385,   386,   387,     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,    -1,    -1,   339,   340,    -1,    -1,    -1,
+     319,   320,   321,   322,   323,   324,   325,   326,    -1,    -1,
+     329,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   358,    -1,   360,    -1,   362,   363,
-      -1,    -1,    -1,    -1,   368,   369,   370,   371,   372,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,   383,
-     384,   385,   386,   387,     3,     4,     5,     6,     7,     8,
+      -1,    -1,    -1,    -1,   373,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,
@@ -2451,51 +2419,13 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,
-     339,   340,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
-      -1,   360,    -1,   362,    -1,    -1,    -1,    -1,    -1,   368,
-     369,   370,   371,   372,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   382,   383,   384,   385,   386,   387,     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,    -1,    -1,   339,   340,    -1,    -1,    -1,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,    -1,    -1,   344,   345,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   358,    -1,   360,    -1,   362,    -1,
-      -1,    -1,    -1,    -1,   368,   369,   370,   371,   372,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,   383,
-     384,   385,   386,   387,     3,     4,     5,     6,     7,     8,
+      -1,    -1,    -1,    -1,   363,    -1,   365,    -1,   367,   368,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,
@@ -2528,51 +2458,130 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,
-     339,   340,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
-      -1,   360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,
-     369,   370,   371,   372,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   382,   383,   384,   385,   386,   387,     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,    -1,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
-     334,   335,   336,    -1,    -1,   339,   340,    -1,    -1,    -1,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,    -1,    -1,   344,   345,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   363,    -1,   365,    -1,   367,   368,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,    -1,    -1,   344,   345,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   363,    -1,   365,    -1,   367,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,    -1,    -1,   344,   345,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   363,    -1,   365,    -1,   367,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,    -1,    -1,   344,   345,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   358,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   368,   369,   370,   371,   372,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,   383,
-     384,   385,   386,   387,     3,     4,     5,     6,     7,     8,
+      -1,    -1,    -1,    -1,   363,    -1,   365,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,
@@ -2604,52 +2613,92 @@ static const yytype_int16 yycheck[] =
      289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
      309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,    -1,    -1,   324,    -1,    -1,    -1,    -1,
+     319,   320,   321,   322,   323,   324,   325,   326,    -1,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,    -1,    -1,   344,   345,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   363,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,    -1,    -1,
+     329,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   382,   383,   384,   385,   386,   387,     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,    -1,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
-     334,   335,   336,    -1,    -1,   339,   340,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,   392,     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,    -1,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,    -1,    -1,   344,   345,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   358,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   369,   370,   371,   372,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   382,   383,
-     384,   385,   386,     3,     4,     5,     6,     7,     8,     9,
+      -1,    -1,    -1,    -1,   363,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   374,   375,   376,   377,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,
+     389,   390,   391,     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,
@@ -2681,52 +2730,53 @@ 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,    -1,   323,   324,    -1,    -1,    -1,    -1,    -1,
+     320,   321,   322,   323,   324,   325,   326,    -1,   328,   329,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   382,   383,   384,   385,   386,     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,    -1,    -1,   324,    -1,
+      -1,    -1,    -1,   373,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,   388,   389,
+     390,   391,     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,    -1,    -1,   329,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   382,   383,   384,   385,
-     386,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      -1,    -1,    -1,    -1,    -1,    -1,   387,   388,   389,   390,
+     391,     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,
@@ -2758,51 +2808,52 @@ static const yytype_int16 yycheck[] =
      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,
-      -1,    -1,   324,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     322,   323,   324,   325,   326,    -1,    -1,   329,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   368,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     382,   383,   384,   385,   386,     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,    -1,    -1,   324,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   387,   388,   389,   390,   391,
+       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,    -1,    -1,   329,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   363,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   368,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   382,   383,   384,   385,   386,     3,
+      -1,    -1,    -1,    -1,   387,   388,   389,   390,   391,     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,
@@ -2834,48 +2885,49 @@ static const yytype_int16 yycheck[] =
      284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
      294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
      304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,    -1,    -1,
-     324,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,    -1,    -1,   329,    -1,    -1,    -1,    -1,
       -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,   382,   383,
-     384,   385,   386,    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,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,    -1,    -1,    -1,    -1,    -1,   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,    -1,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,    -1,    -1,   339,   340,
+      -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,   387,   388,   389,   390,   391,    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,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
+     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
+     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
+     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
+     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
+     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+     216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
+     226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
+     236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
+     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
+     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
+     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+     286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
+     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
+     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
+     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
+     326,    -1,   328,   329,   330,   331,   332,   333,   334,   335,
+     336,   337,   338,   339,   340,   341,    -1,    -1,   344,   345,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,    -1,    -1,
-      -1,   362,   363,    -1,    -1,    -1,    -1,    -1,   369,   370,
-     371,   372,     5,     6,     7,     8,     9,    -1,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,    -1,    -1,
+      -1,   367,   368,    -1,    -1,    -1,    -1,    -1,   374,   375,
+     376,   377,     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,
@@ -2883,72 +2935,73 @@ static const yytype_int16 yycheck[] =
       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,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,    -1,
-      -1,    -1,    -1,    -1,   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,    -1,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,    -1,    -1,   339,   340,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   358,    -1,    -1,   361,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   369,   370,   371,   372,
-       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,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,    -1,    -1,    -1,
-      -1,    -1,   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,    -1,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,    -1,    -1,   339,   340,    -1,    -1,    -1,    -1,
+      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
+     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
+     113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
+     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
+     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
+     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
+     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
+     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
+     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
+     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
+     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
+     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
+     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
+     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
+     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
+     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
+     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
+     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
+     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
+     323,   324,   325,   326,    -1,   328,   329,   330,   331,   332,
+     333,   334,   335,   336,   337,   338,   339,   340,   341,    -1,
+      -1,   344,   345,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     363,    -1,    -1,   366,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   374,   375,   376,   377,     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,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,    -1,    -1,    -1,
+      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,    -1,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
+     340,   341,    -1,    -1,   344,   345,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   358,    -1,    -1,    -1,   362,    -1,    -1,
-      -1,    -1,    -1,    -1,   369,   370,   371,   372,     5,     6,
+      -1,    -1,    -1,   363,    -1,    -1,    -1,   367,    -1,    -1,
+      -1,    -1,    -1,    -1,   374,   375,   376,   377,     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,
@@ -2957,10 +3010,10 @@ static const yytype_int16 yycheck[] =
       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,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      -1,    -1,    -1,    -1,    -1,    -1,    93,    94,    95,    96,
       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,    -1,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+      -1,    -1,    -1,    -1,    -1,   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,
@@ -2980,49 +3033,50 @@ 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,    -1,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-      -1,    -1,   339,   340,    -1,    -1,    -1,    -1,    -1,    -1,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+      -1,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+     337,   338,   339,   340,   341,    -1,    -1,   344,   345,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   358,    -1,    -1,   361,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   369,   370,   371,   372,     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,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,    -1,    -1,    -1,    -1,    -1,   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,    -1,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,    -1,    -1,
-     339,   340,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,
-     369,   370,   371,   372,     5,     6,     7,     8,     9,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   363,    -1,    -1,   366,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   374,   375,   376,
+     377,     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,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,    -1,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,    -1,    -1,
+     344,   345,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,
+     374,   375,   376,   377,     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,
@@ -3030,11 +3084,11 @@ static const yytype_int16 yycheck[] =
       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,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+      -1,    82,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    93,    94,    95,    96,    97,    98,    99,   100,
      101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,    -1,    -1,    -1,    -1,    -1,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     111,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
+      -1,   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,
@@ -3054,48 +3108,49 @@ static const yytype_int16 yycheck[] =
      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,    -1,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,    -1,    -1,   339,   340,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   369,   370,
-     371,   372,     5,     6,     7,     8,     9,    -1,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
+     321,   322,   323,   324,   325,   326,    -1,   328,   329,   330,
+     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
+     341,    -1,    -1,   344,   345,    -1,    -1,    -1,    -1,    -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,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,    -1,
-      -1,    -1,    -1,    -1,   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,    -1,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,    -1,    -1,   339,   340,    -1,    -1,
+      -1,    -1,   363,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   374,   375,   376,   377,     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,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,    -1,
+      -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
+     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
+     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
+     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
+     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
+     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
+     288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
+     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
+     308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
+     318,   319,   320,   321,   322,   323,   324,   325,   326,    -1,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,   339,   340,   341,    -1,    -1,   344,   345,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   358,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   369,   370,   371,   372,
+      -1,    -1,    -1,    -1,    -1,   363,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   374,   375,   376,   377,
        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,
@@ -3104,10 +3159,10 @@ static const yytype_int16 yycheck[] =
       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,    -1,    -1,    -1,
-      -1,    -1,    -1,    88,    89,    90,    91,    92,    93,    94,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    93,    94,
       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,    -1,    -1,    -1,
-      -1,    -1,   117,   118,   119,   120,   121,   122,   123,   124,
+     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
+     115,   116,    -1,    -1,    -1,    -1,    -1,   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,
@@ -3127,7 +3182,8 @@ static const yytype_int16 yycheck[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,    -1,    -1,   324
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,    -1,    -1,   329
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -3164,107 +3220,109 @@ static const yytype_uint16 yystos[] =
      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,   324,
-     368,   382,   383,   384,   385,   386,   387,   422,   423,   426,
-     427,   428,   429,   433,   434,   435,   436,   437,   438,   441,
-     442,   443,   444,   445,   447,   449,   450,   451,   491,   492,
-     493,   358,   358,   323,   362,   450,   323,   368,   368,   494,
-     359,   365,   430,   431,   432,   442,   447,   365,   368,   323,
-     323,   368,   443,   447,   360,   448,     0,   492,   323,   446,
-      81,   323,   439,   440,   362,   453,   447,   368,   448,   362,
-     470,   431,   430,   432,   323,   323,   358,   367,   448,   362,
-     365,   368,   425,   323,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   339,   340,   358,   361,
-     369,   370,   371,   372,   392,   393,   394,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   445,   447,
-     360,   359,   365,   367,   359,   365,   452,   442,   447,   454,
-     455,   368,   368,    22,    23,    24,    26,    27,    28,    29,
-      30,    31,    32,   322,   360,   362,   363,   368,   403,   416,
-     418,   420,   422,   426,   445,   447,   460,   461,   462,   463,
-     471,   472,   473,   474,   477,   478,   481,   482,   483,   490,
-     495,   448,   367,   448,   362,   418,   458,   367,   424,   323,
-     365,   368,   403,   403,   420,   339,   340,   360,   364,   359,
-     359,   365,   321,   418,   358,   403,   373,   374,   375,   370,
-     372,   337,   338,   341,   342,   376,   377,   343,   344,   380,
-     379,   378,   345,   347,   346,   381,   361,   361,   416,   323,
-     416,   421,   440,   454,   447,   323,   456,   457,   363,   455,
-     368,   368,   485,   358,   358,   368,   368,   420,   358,   420,
-     366,   358,   360,   363,   464,   348,   349,   350,   351,   352,
-     353,   354,   355,   356,   357,   367,   419,   365,   368,   363,
-     461,   474,   478,   483,   458,   367,   458,   459,   458,   454,
-     323,   359,   395,   420,   323,   418,   403,   403,   403,   405,
-     405,   406,   406,   407,   407,   407,   407,   408,   408,   409,
-     410,   411,   412,   413,   414,   417,   361,   363,   456,   448,
-     365,   368,   461,   486,   420,   368,   420,   366,   484,   323,
-     496,   497,   471,   418,   418,   458,   363,   365,   363,   361,
-     420,   368,   457,   322,   460,   472,   487,   359,   359,   420,
-     435,   442,   476,   358,   361,   365,   465,   363,   458,   366,
-     358,   476,   488,   489,   467,   468,   469,   475,   479,   323,
-     359,   421,   361,   497,   363,   418,   420,   368,   359,    25,
-     463,   462,   362,   367,   462,   466,   470,   359,   359,   420,
-     466,   467,   471,   480,   458,   368,   363
+     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
+     323,   324,   325,   326,   329,   373,   387,   388,   389,   390,
+     391,   392,   427,   428,   431,   432,   433,   434,   438,   439,
+     440,   441,   442,   443,   446,   447,   448,   449,   450,   452,
+     454,   455,   456,   496,   497,   498,   363,   363,   328,   367,
+     455,   328,   373,   373,   499,   364,   370,   435,   436,   437,
+     447,   452,   370,   373,   328,   328,   373,   448,   452,   365,
+     453,     0,   497,   328,   451,    81,   328,   444,   445,   367,
+     458,   452,   373,   453,   367,   475,   436,   435,   437,   328,
+     328,   363,   372,   453,   367,   370,   373,   430,   328,   330,
+     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
+     341,   344,   345,   363,   366,   374,   375,   376,   377,   397,
+     398,   399,   401,   402,   403,   404,   405,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,   450,   452,   365,   364,   370,   372,   364,
+     370,   457,   447,   452,   459,   460,   373,   373,    22,    23,
+      24,    26,    27,    28,    29,    30,    31,    32,   327,   365,
+     367,   368,   373,   408,   421,   423,   425,   427,   431,   450,
+     452,   465,   466,   467,   468,   476,   477,   478,   479,   482,
+     483,   486,   487,   488,   495,   500,   453,   372,   453,   367,
+     423,   463,   372,   429,   328,   370,   373,   408,   408,   425,
+     344,   345,   365,   369,   364,   364,   370,   326,   423,   363,
+     408,   378,   379,   380,   375,   377,   342,   343,   346,   347,
+     381,   382,   348,   349,   385,   384,   383,   350,   352,   351,
+     386,   366,   366,   421,   328,   421,   426,   445,   459,   452,
+     328,   461,   462,   368,   460,   373,   373,   490,   363,   363,
+     373,   373,   425,   363,   425,   371,   363,   365,   368,   469,
+     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
+     372,   424,   370,   373,   368,   466,   479,   483,   488,   463,
+     372,   463,   464,   463,   459,   328,   364,   400,   425,   328,
+     423,   408,   408,   408,   410,   410,   411,   411,   412,   412,
+     412,   412,   413,   413,   414,   415,   416,   417,   418,   419,
+     422,   366,   368,   461,   453,   370,   373,   466,   491,   425,
+     373,   425,   371,   489,   328,   501,   502,   476,   423,   423,
+     463,   368,   370,   368,   366,   425,   373,   462,   327,   465,
+     477,   492,   364,   364,   425,   440,   447,   481,   363,   366,
+     370,   470,   368,   463,   371,   363,   481,   493,   494,   472,
+     473,   474,   480,   484,   328,   364,   426,   366,   502,   368,
+     423,   425,   373,   364,    25,   468,   467,   367,   372,   467,
+     471,   475,   364,   364,   425,   471,   472,   476,   485,   463,
+     373,   368
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint16 yyr1[] =
 {
-       0,   391,   392,   393,   393,   393,   393,   393,   393,   393,
-     393,   393,   393,   393,   393,   393,   393,   394,   394,   394,
-     394,   394,   394,   395,   396,   397,   398,   398,   399,   399,
-     400,   400,   401,   402,   402,   402,   403,   403,   403,   403,
-     404,   404,   404,   404,   405,   405,   405,   405,   406,   406,
-     406,   407,   407,   407,   408,   408,   408,   408,   408,   409,
-     409,   409,   410,   410,   411,   411,   412,   412,   413,   413,
-     414,   414,   415,   415,   416,   417,   416,   418,   418,   419,
-     419,   419,   419,   419,   419,   419,   419,   419,   419,   419,
-     420,   420,   421,   422,   422,   422,   422,   422,   422,   422,
-     422,   422,   424,   423,   425,   425,   426,   427,   427,   428,
-     428,   429,   430,   430,   431,   431,   431,   431,   432,   433,
-     433,   433,   433,   433,   434,   434,   434,   434,   434,   435,
-     435,   436,   437,   437,   437,   437,   438,   439,   439,   440,
-     440,   440,   441,   442,   442,   443,   443,   443,   443,   443,
-     443,   443,   444,   444,   444,   444,   444,   444,   444,   444,
-     444,   444,   444,   444,   444,   444,   444,   444,   444,   444,
-     444,   445,   446,   446,   447,   447,   448,   448,   448,   448,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
+       0,   396,   397,   398,   398,   398,   398,   398,   398,   398,
+     398,   398,   398,   398,   398,   398,   398,   399,   399,   399,
+     399,   399,   399,   400,   401,   402,   403,   403,   404,   404,
+     405,   405,   406,   407,   407,   407,   408,   408,   408,   408,
+     409,   409,   409,   409,   410,   410,   410,   410,   411,   411,
+     411,   412,   412,   412,   413,   413,   413,   413,   413,   414,
+     414,   414,   415,   415,   416,   416,   417,   417,   418,   418,
+     419,   419,   420,   420,   421,   422,   421,   423,   423,   424,
+     424,   424,   424,   424,   424,   424,   424,   424,   424,   424,
+     425,   425,   426,   427,   427,   427,   427,   427,   427,   427,
+     427,   427,   429,   428,   430,   430,   431,   432,   432,   433,
+     433,   434,   435,   435,   436,   436,   436,   436,   437,   438,
+     438,   438,   438,   438,   439,   439,   439,   439,   439,   440,
+     440,   441,   442,   442,   442,   442,   443,   444,   444,   445,
+     445,   445,   446,   447,   447,   448,   448,   448,   448,   448,
+     448,   448,   449,   449,   449,   449,   449,   449,   449,   449,
      449,   449,   449,   449,   449,   449,   449,   449,   449,   449,
-     449,   449,   449,   449,   449,   450,   450,   450,   452,   451,
-     453,   451,   454,   454,   455,   455,   456,   456,   457,   457,
-     458,   458,   458,   459,   459,   460,   461,   461,   462,   462,
-     462,   462,   462,   462,   462,   463,   464,   465,   463,   466,
-     466,   468,   467,   469,   467,   470,   470,   471,   471,   472,
-     472,   473,   473,   474,   475,   475,   476,   476,   477,   477,
-     479,   478,   480,   480,   481,   481,   482,   482,   484,   483,
-     485,   483,   486,   483,   487,   487,   488,   488,   489,   489,
-     490,   490,   490,   490,   490,   491,   491,   492,   492,   492,
-     494,   493,   495,   496,   496,   497,   497
+     449,   449,   449,   449,   449,   449,   450,   451,   451,   452,
+     452,   453,   453,   453,   453,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     454,   454,   454,   454,   454,   454,   454,   454,   454,   454,
+     455,   455,   455,   457,   456,   458,   456,   459,   459,   460,
+     460,   461,   461,   462,   462,   463,   463,   463,   464,   464,
+     465,   466,   466,   467,   467,   467,   467,   467,   467,   467,
+     468,   469,   470,   468,   471,   471,   473,   472,   474,   472,
+     475,   475,   476,   476,   477,   477,   478,   478,   479,   480,
+     480,   481,   481,   482,   482,   484,   483,   485,   485,   486,
+     486,   487,   487,   489,   488,   490,   488,   491,   488,   492,
+     492,   493,   493,   494,   494,   495,   495,   495,   495,   495,
+     496,   496,   497,   497,   497,   499,   498,   500,   501,   501,
+     502,   502
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -3287,7 +3345,8 @@ static const yytype_uint8 yyr2[] =
        3,     1,     1,     1,     2,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       4,     1,     1,     3,     1,     2,     2,     3,     3,     4,
+       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,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
@@ -3316,16 +3375,16 @@ 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,     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
+       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
 };
 
 
@@ -3610,11 +3669,11 @@ static int
 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yytype_int16 *yyssp, int yytoken)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
+  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
   YYSIZE_T yysize = yysize0;
   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
   /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
+  const char *yyformat = YY_NULLPTR;
   /* Arguments of yyformat. */
   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
   /* Number of reported tokens (one for the "unexpected", one per
@@ -3671,7 +3730,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                   }
                 yyarg[yycount++] = yytname[yyx];
                 {
-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
+                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                   if (! (yysize <= yysize1
                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                     return 2;
@@ -4012,7 +4071,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
     }
-#line 4016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 3:
@@ -4020,7 +4079,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 4:
@@ -4029,7 +4088,7 @@ yyreduce:
         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 4033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 5:
@@ -4038,7 +4097,7 @@ yyreduce:
         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 4042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 6:
@@ -4046,7 +4105,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 7:
@@ -4055,7 +4114,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 8:
@@ -4064,7 +4123,7 @@ yyreduce:
         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 4068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 9:
@@ -4073,7 +4132,7 @@ yyreduce:
         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 4077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 10:
@@ -4082,7 +4141,7 @@ yyreduce:
         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 4086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 11:
@@ -4091,7 +4150,7 @@ yyreduce:
         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 4095 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4154 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 12:
@@ -4099,7 +4158,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 4103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 13:
@@ -4108,7 +4167,7 @@ yyreduce:
         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 4112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 14:
@@ -4117,7 +4176,7 @@ yyreduce:
         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 4121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 15:
@@ -4125,7 +4184,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 4129 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 16:
@@ -4135,7 +4194,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
     }
-#line 4139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 17:
@@ -4143,7 +4202,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 18:
@@ -4151,7 +4210,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4214 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 19:
@@ -4159,7 +4218,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 20:
@@ -4167,7 +4226,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
     }
-#line 4171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4230 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 21:
@@ -4177,7 +4236,7 @@ yyreduce:
         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 4181 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4240 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 22:
@@ -4187,7 +4246,7 @@ yyreduce:
         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 4191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 23:
@@ -4196,7 +4255,7 @@ yyreduce:
         parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 24:
@@ -4205,7 +4264,7 @@ yyreduce:
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
         delete (yyvsp[0].interm).function;
     }
-#line 4209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 25:
@@ -4213,7 +4272,7 @@ yyreduce:
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 26:
@@ -4222,7 +4281,7 @@ yyreduce:
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 27:
@@ -4231,7 +4290,7 @@ yyreduce:
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 28:
@@ -4239,7 +4298,7 @@ yyreduce:
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 29:
@@ -4247,7 +4306,7 @@ yyreduce:
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4310 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 30:
@@ -4259,7 +4318,7 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-1].interm).function;
         (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 31:
@@ -4271,7 +4330,7 @@ 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 4275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 32:
@@ -4279,7 +4338,7 @@ yyreduce:
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 33:
@@ -4289,7 +4348,7 @@ yyreduce:
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 34:
@@ -4321,7 +4380,7 @@ yyreduce:
             (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull);
         }
     }
-#line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4384 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 35:
@@ -4331,7 +4390,7 @@ yyreduce:
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4335 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 36:
@@ -4342,7 +4401,7 @@ yyreduce:
         if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
     }
-#line 4346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 37:
@@ -4351,7 +4410,7 @@ yyreduce:
         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 4355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 38:
@@ -4360,7 +4419,7 @@ yyreduce:
         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 4364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 39:
@@ -4381,38 +4440,38 @@ yyreduce:
                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
         }
     }
-#line 4385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 40:
 #line 519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
-#line 4391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 41:
 #line 520 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
-#line 4397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 42:
 #line 521 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
-#line 4403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 43:
 #line 522 "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 4410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 44:
 #line 528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4475 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 45:
@@ -4422,7 +4481,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 46:
@@ -4432,7 +4491,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 47:
@@ -4443,13 +4502,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 48:
 #line 548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4453 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 49:
@@ -4459,7 +4518,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 50:
@@ -4469,13 +4528,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 51:
 #line 562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 52:
@@ -4486,7 +4545,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 53:
@@ -4497,13 +4556,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4560 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 54:
 #line 578 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 55:
@@ -4513,7 +4572,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 56:
@@ -4523,7 +4582,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 57:
@@ -4533,7 +4592,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 58:
@@ -4543,13 +4602,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 59:
 #line 602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 60:
@@ -4562,7 +4621,7 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 61:
@@ -4575,13 +4634,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 62:
 #line 622 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 63:
@@ -4592,13 +4651,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 64:
 #line 632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 65:
@@ -4609,13 +4668,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 66:
 #line 642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 67:
@@ -4626,13 +4685,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 68:
 #line 652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4695 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 69:
@@ -4642,13 +4701,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 70:
 #line 661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 71:
@@ -4658,13 +4717,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 72:
 #line 670 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 73:
@@ -4674,13 +4733,13 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 74:
 #line 679 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4684 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 75:
@@ -4688,7 +4747,7 @@ yyreduce:
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 4692 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 76:
@@ -4705,13 +4764,13 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4768 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 77:
 #line 698 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 78:
@@ -4729,7 +4788,7 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
         }
     }
-#line 4733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 79:
@@ -4738,7 +4797,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
-#line 4742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 80:
@@ -4747,7 +4806,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
-#line 4751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 81:
@@ -4756,7 +4815,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
-#line 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 82:
@@ -4766,7 +4825,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpModAssign;
     }
-#line 4770 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 83:
@@ -4775,7 +4834,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
-#line 4779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 84:
@@ -4784,7 +4843,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
-#line 4788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 85:
@@ -4793,7 +4852,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
-#line 4797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4856 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 86:
@@ -4802,7 +4861,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
-#line 4806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 87:
@@ -4811,7 +4870,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
-#line 4815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 88:
@@ -4820,7 +4879,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
-#line 4824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 89:
@@ -4829,7 +4888,7 @@ yyreduce:
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
-#line 4833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 90:
@@ -4837,7 +4896,7 @@ yyreduce:
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 91:
@@ -4850,7 +4909,7 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 4854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 92:
@@ -4859,7 +4918,7 @@ yyreduce:
         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 93:
@@ -4869,7 +4928,7 @@ yyreduce:
         (yyval.interm.intermNode) = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
-#line 4873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 94:
@@ -4879,7 +4938,7 @@ yyreduce:
             (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
     }
-#line 4883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 95:
@@ -4892,7 +4951,7 @@ yyreduce:
         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
         (yyval.interm.intermNode) = 0;
     }
-#line 4896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 96:
@@ -4901,7 +4960,7 @@ yyreduce:
         parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
         (yyval.interm.intermNode) = 0;
     }
-#line 4905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4964 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 97:
@@ -4910,7 +4969,7 @@ yyreduce:
         parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 4914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 98:
@@ -4919,7 +4978,7 @@ yyreduce:
         parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
         (yyval.interm.intermNode) = 0;
     }
-#line 4923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 99:
@@ -4929,7 +4988,7 @@ yyreduce:
         parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
         (yyval.interm.intermNode) = 0;
     }
-#line 4933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 100:
@@ -4939,7 +4998,7 @@ yyreduce:
         parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 4943 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 101:
@@ -4950,13 +5009,13 @@ yyreduce:
         parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
         (yyval.interm.intermNode) = 0;
     }
-#line 4954 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5013 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 102:
 #line 833 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
-#line 4960 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 103:
@@ -4970,7 +5029,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
     }
-#line 4974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 104:
@@ -4979,7 +5038,7 @@ yyreduce:
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 4983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 105:
@@ -4988,7 +5047,7 @@ yyreduce:
         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 4992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 106:
@@ -4997,7 +5056,7 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-1].interm.function);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 5001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 107:
@@ -5005,7 +5064,7 @@ yyreduce:
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5009 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 108:
@@ -5013,7 +5072,7 @@ yyreduce:
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 109:
@@ -5026,7 +5085,7 @@ yyreduce:
         else
             delete (yyvsp[0].interm).param.type;
     }
-#line 5030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 110:
@@ -5048,7 +5107,7 @@ yyreduce:
             (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
         }
     }
-#line 5052 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 111:
@@ -5072,7 +5131,7 @@ yyreduce:
         function = new TFunction((yyvsp[-1].lex).string, type);
         (yyval.interm.function) = function;
     }
-#line 5076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 112:
@@ -5092,7 +5151,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 113:
@@ -5116,7 +5175,7 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 114:
@@ -5132,7 +5191,7 @@ yyreduce:
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
 
     }
-#line 5136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 115:
@@ -5144,7 +5203,7 @@ 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 5148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 116:
@@ -5159,7 +5218,7 @@ 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 5163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 117:
@@ -5171,7 +5230,7 @@ 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 5175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 118:
@@ -5182,7 +5241,7 @@ yyreduce:
         if ((yyvsp[0].interm.type).arraySizes)
             parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
     }
-#line 5186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 119:
@@ -5190,7 +5249,7 @@ yyreduce:
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 5194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 120:
@@ -5199,7 +5258,7 @@ yyreduce:
         (yyval.interm) = (yyvsp[-2].interm);
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
     }
-#line 5203 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 121:
@@ -5208,7 +5267,7 @@ yyreduce:
         (yyval.interm) = (yyvsp[-3].interm);
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
     }
-#line 5212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 122:
@@ -5218,7 +5277,7 @@ yyreduce:
         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 5222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 123:
@@ -5228,7 +5287,7 @@ yyreduce:
         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 5232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 124:
@@ -5238,7 +5297,7 @@ yyreduce:
         (yyval.interm).intermNode = 0;
         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
     }
-#line 5242 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 125:
@@ -5248,7 +5307,7 @@ yyreduce:
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
     }
-#line 5252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 126:
@@ -5258,7 +5317,7 @@ yyreduce:
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
     }
-#line 5262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 127:
@@ -5268,7 +5327,7 @@ yyreduce:
         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 5272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 128:
@@ -5278,7 +5337,7 @@ yyreduce:
         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 5282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 129:
@@ -5294,7 +5353,7 @@ yyreduce:
 
         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
     }
-#line 5298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 130:
@@ -5323,7 +5382,7 @@ yyreduce:
              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
             (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 131:
@@ -5334,7 +5393,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.invariant = true;
     }
-#line 5338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 132:
@@ -5346,7 +5405,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5350 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 133:
@@ -5358,7 +5417,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.flat = true;
     }
-#line 5362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 134:
@@ -5374,7 +5433,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nopersp = true;
     }
-#line 5378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5437 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 135:
@@ -5388,7 +5447,7 @@ yyreduce:
         (yyval.interm.type).qualifier.explicitInterp = true;
 #endif
     }
-#line 5392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5451 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 136:
@@ -5396,7 +5455,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
     }
-#line 5400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5459 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 137:
@@ -5404,7 +5463,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 138:
@@ -5414,7 +5473,7 @@ yyreduce:
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 5418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5477 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 139:
@@ -5423,7 +5482,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
     }
-#line 5427 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 140:
@@ -5432,7 +5491,7 @@ yyreduce:
         (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 5436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 141:
@@ -5442,7 +5501,7 @@ yyreduce:
         TString strShared("shared");
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
     }
-#line 5446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 142:
@@ -5453,7 +5512,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.noContraction = true;
     }
-#line 5457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 143:
@@ -5461,7 +5520,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5465 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5524 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 144:
@@ -5474,7 +5533,7 @@ 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 5478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 145:
@@ -5482,7 +5541,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 146:
@@ -5490,7 +5549,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 147:
@@ -5499,7 +5558,7 @@ yyreduce:
         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 148:
@@ -5508,7 +5567,7 @@ yyreduce:
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 149:
@@ -5517,7 +5576,7 @@ yyreduce:
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 150:
@@ -5526,7 +5585,7 @@ yyreduce:
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5530 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 151:
@@ -5534,7 +5593,7 @@ yyreduce:
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 152:
@@ -5543,7 +5602,7 @@ yyreduce:
         (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 5547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 153:
@@ -5560,7 +5619,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 154:
@@ -5579,7 +5638,7 @@ yyreduce:
         else
             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5583 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 155:
@@ -5589,7 +5648,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqInOut;
     }
-#line 5593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 156:
@@ -5600,7 +5659,7 @@ yyreduce:
         // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqIn;
     }
-#line 5604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 157:
@@ -5611,7 +5670,7 @@ yyreduce:
         // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqOut;
     }
-#line 5615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 158:
@@ -5623,7 +5682,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.centroid = true;
     }
-#line 5627 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 159:
@@ -5634,7 +5693,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.patch = true;
     }
-#line 5638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 160:
@@ -5644,7 +5703,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.sample = true;
     }
-#line 5648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 161:
@@ -5654,7 +5713,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqUniform;
     }
-#line 5658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 162:
@@ -5664,7 +5723,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqBuffer;
     }
-#line 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 163:
@@ -5677,7 +5736,7 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqShared;
     }
-#line 5681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 164:
@@ -5686,126 +5745,176 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
-#line 5690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 165:
 #line 1320 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
-        (yyval.interm.type).qualifier.volatil = true;
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
+        (yyval.interm.type).qualifier.devicecoherent = true;
     }
-#line 5699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 166:
-#line 1324 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1325 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
-        (yyval.interm.type).qualifier.restrict = true;
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
+        (yyval.interm.type).qualifier.queuefamilycoherent = true;
     }
-#line 5708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 167:
-#line 1328 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
-        (yyval.interm.type).qualifier.readonly = true;
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
+        (yyval.interm.type).qualifier.workgroupcoherent = true;
     }
-#line 5717 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 168:
-#line 1332 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1335 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
-        (yyval.interm.type).qualifier.writeonly = true;
+        parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
+        (yyval.interm.type).qualifier.subgroupcoherent = true;
     }
-#line 5726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 169:
-#line 1336 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1340 "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 5799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 170:
+#line 1345 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.volatil = true;
+    }
+#line 5808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 171:
+#line 1349 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.restrict = true;
+    }
+#line 5817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 172:
+#line 1353 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.readonly = true;
+    }
+#line 5826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 173:
+#line 1357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+    {
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.writeonly = true;
+    }
+#line 5835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 174:
+#line 1361 "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 5737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5846 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 170:
-#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 175:
+#line 1367 "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 5748 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 171:
-#line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 176:
+#line 1376 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nonUniform = true;
     }
-#line 5757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 172:
-#line 1358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 177:
+#line 1383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // TODO
     }
-#line 5765 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 173:
-#line 1361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 178:
+#line 1386 "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 5775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 174:
-#line 1369 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 179:
+#line 1394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
     }
-#line 5784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5893 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 175:
-#line 1373 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 180:
+#line 1398 "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).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
     }
-#line 5795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 176:
-#line 1382 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 181:
+#line 1407 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 5805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 177:
-#line 1387 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 182:
+#line 1412 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[-2].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -5814,20 +5923,20 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 178:
-#line 1395 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 183:
+#line 1420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-2].interm);
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 5827 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 179:
-#line 1399 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 184:
+#line 1424 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-3].interm);
 
@@ -5835,1484 +5944,1484 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 5839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5948 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 180:
-#line 1409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 185:
+#line 1434 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
-#line 5848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 181:
-#line 1413 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 186:
+#line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 5857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 182:
-#line 1417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 187:
+#line 1442 "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 5867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 183:
-#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 188:
+#line 1447 "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 5877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 184:
-#line 1427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 189:
+#line 1452 "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 5887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 185:
-#line 1432 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 190:
+#line 1457 "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 5897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 186:
-#line 1437 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 191:
+#line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 5906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 187:
-#line 1441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 192:
+#line 1466 "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 5916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 188:
-#line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 193:
+#line 1471 "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 5926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 189:
-#line 1451 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 194:
+#line 1476 "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 5936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 190:
-#line 1456 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 195:
+#line 1481 "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 5946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 191:
-#line 1461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 196:
+#line 1486 "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 5956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 192:
-#line 1466 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 197:
+#line 1491 "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 5966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 193:
-#line 1471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 198:
+#line 1496 "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 5976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 194:
-#line 1476 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 199:
+#line 1501 "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 5986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6095 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 195:
-#line 1481 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 200:
+#line 1506 "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 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 196:
-#line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 201:
+#line 1511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
     }
-#line 6005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 197:
-#line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 202:
+#line 1515 "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 6015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6124 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 198:
-#line 1495 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 203:
+#line 1520 "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 6025 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 199:
-#line 1500 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 204:
+#line 1525 "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 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 200:
-#line 1505 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 205:
+#line 1530 "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 6046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 201:
-#line 1511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 206:
+#line 1536 "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 6057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 202:
-#line 1517 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 207:
+#line 1542 "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 6068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 203:
-#line 1523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 208:
+#line 1548 "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 6079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 204:
-#line 1529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 209:
+#line 1554 "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 6090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 205:
-#line 1535 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 210:
+#line 1560 "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 6101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 206:
-#line 1541 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 211:
+#line 1566 "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 6112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 207:
-#line 1547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 212:
+#line 1572 "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 6123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 208:
-#line 1553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 213:
+#line 1578 "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 6134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 209:
-#line 1559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 214:
+#line 1584 "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 6145 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 210:
-#line 1565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 215:
+#line 1590 "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 6156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 211:
-#line 1571 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 216:
+#line 1596 "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 6167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 212:
-#line 1577 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 217:
+#line 1602 "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 6177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 213:
-#line 1582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 218:
+#line 1607 "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 6187 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 214:
-#line 1587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 219:
+#line 1612 "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 6197 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 215:
-#line 1592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 220:
+#line 1617 "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 6207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 216:
-#line 1597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 221:
+#line 1622 "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 6217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 217:
-#line 1602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 222:
+#line 1627 "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 6227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 218:
-#line 1607 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 223:
+#line 1632 "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 6238 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 219:
-#line 1613 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 224:
+#line 1638 "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 6249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 220:
-#line 1619 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 225:
+#line 1644 "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 6260 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 221:
-#line 1625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 226:
+#line 1650 "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 6271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6380 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 222:
-#line 1631 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 227:
+#line 1656 "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 6282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 223:
-#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 228:
+#line 1662 "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 6293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 224:
-#line 1643 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 229:
+#line 1668 "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 6304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 225:
-#line 1649 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 230:
+#line 1674 "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 6315 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 226:
-#line 1655 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 231:
+#line 1680 "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 6326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6435 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 227:
-#line 1661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 232:
+#line 1686 "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 6337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 228:
-#line 1667 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 233:
+#line 1692 "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 6348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 229:
-#line 1673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 234:
+#line 1698 "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 6359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 230:
-#line 1679 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 235:
+#line 1704 "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 6370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 231:
-#line 1685 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 236:
+#line 1710 "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 6381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 232:
-#line 1691 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 237:
+#line 1716 "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 6392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 233:
-#line 1697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 238:
+#line 1722 "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 6403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 234:
-#line 1703 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 239:
+#line 1728 "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 6414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6523 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 235:
-#line 1709 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 240:
+#line 1734 "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 6425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 236:
-#line 1715 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 241:
+#line 1740 "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 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6545 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 237:
-#line 1721 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 242:
+#line 1746 "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 6447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 238:
-#line 1727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 243:
+#line 1752 "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 6458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 239:
-#line 1733 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 244:
+#line 1758 "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 6469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 240:
-#line 1739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 245:
+#line 1764 "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 6480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 241:
-#line 1745 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 246:
+#line 1770 "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 6491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 242:
-#line 1751 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 247:
+#line 1776 "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 6502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 243:
-#line 1757 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 248:
+#line 1782 "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 6513 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 244:
-#line 1763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 249:
+#line 1788 "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 6524 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 245:
-#line 1769 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 250:
+#line 1794 "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 6534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 246:
-#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 251:
+#line 1799 "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 6544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 247:
-#line 1779 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 252:
+#line 1804 "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 6554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 248:
-#line 1784 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 253:
+#line 1809 "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 6564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 249:
-#line 1789 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 254:
+#line 1814 "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 6574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 250:
-#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 255:
+#line 1819 "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 6584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 251:
-#line 1799 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 256:
+#line 1824 "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 6594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 252:
-#line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 257:
+#line 1829 "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 6604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6713 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 253:
-#line 1809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 258:
+#line 1834 "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 6614 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 254:
-#line 1814 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 259:
+#line 1839 "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 6624 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 255:
-#line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 260:
+#line 1844 "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 6634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 256:
-#line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 261:
+#line 1849 "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 6644 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 257:
-#line 1829 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 262:
+#line 1854 "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 6655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 258:
-#line 1835 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 263:
+#line 1860 "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 6666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 259:
-#line 1841 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 264:
+#line 1866 "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 6677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 260:
-#line 1847 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 265:
+#line 1872 "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 6688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6797 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 261:
-#line 1853 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 266:
+#line 1878 "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 6699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6808 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 262:
-#line 1859 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 267:
+#line 1884 "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 6710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 263:
-#line 1865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 268:
+#line 1890 "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 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 264:
-#line 1871 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 269:
+#line 1896 "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 6732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 265:
-#line 1877 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 270:
+#line 1902 "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 6743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 266:
-#line 1883 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 271:
+#line 1908 "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 6754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 267:
-#line 1889 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 272:
+#line 1914 "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 6765 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 268:
-#line 1895 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 273:
+#line 1920 "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 6776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 269:
-#line 1901 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 274:
+#line 1926 "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 6787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 270:
-#line 1907 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 275:
+#line 1932 "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 6798 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 271:
-#line 1913 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 276:
+#line 1938 "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 6809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 272:
-#line 1919 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 277:
+#line 1944 "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 6820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 273:
-#line 1925 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 278:
+#line 1950 "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 6831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 274:
-#line 1931 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 279:
+#line 1956 "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 6842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 275:
-#line 1937 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 280:
+#line 1962 "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 6853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 276:
-#line 1943 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 281:
+#line 1968 "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 6864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 277:
-#line 1949 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 282:
+#line 1974 "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 6875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 278:
-#line 1955 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 283:
+#line 1980 "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 6886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 279:
-#line 1961 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 284:
+#line 1986 "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 6897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 280:
-#line 1967 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 285:
+#line 1992 "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 6908 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 281:
-#line 1973 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 286:
+#line 1998 "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 6919 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 282:
-#line 1979 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 287:
+#line 2004 "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 6930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 283:
-#line 1985 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 288:
+#line 2010 "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 6941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 284:
-#line 1991 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 289:
+#line 2016 "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 6952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 285:
-#line 1997 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 290:
+#line 2022 "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 6963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 286:
-#line 2003 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 291:
+#line 2028 "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 6974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 287:
-#line 2009 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 292:
+#line 2034 "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 6985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 288:
-#line 2015 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 293:
+#line 2040 "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 6996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 289:
-#line 2021 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 294:
+#line 2046 "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 7007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 290:
-#line 2027 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 295:
+#line 2052 "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 7018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 291:
-#line 2033 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 296:
+#line 2058 "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 7029 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 292:
-#line 2039 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 297:
+#line 2064 "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 7040 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 293:
-#line 2045 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 298:
+#line 2070 "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 7051 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 294:
-#line 2051 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 299:
+#line 2076 "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 7062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 295:
-#line 2057 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 300:
+#line 2082 "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 7073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 296:
-#line 2063 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 301:
+#line 2088 "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 7084 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 297:
-#line 2069 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 302:
+#line 2094 "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 7095 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 298:
-#line 2075 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 303:
+#line 2100 "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 7106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 299:
-#line 2081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 304:
+#line 2106 "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 7117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 300:
-#line 2087 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 305:
+#line 2112 "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 7128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 301:
-#line 2093 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 306:
+#line 2118 "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 7139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 302:
-#line 2099 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 307:
+#line 2124 "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 7150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 303:
-#line 2105 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 308:
+#line 2130 "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 7161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7270 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 304:
-#line 2111 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 309:
+#line 2136 "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 7172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7281 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 305:
-#line 2117 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 310:
+#line 2142 "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 7182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 306:
-#line 2122 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 311:
+#line 2147 "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 7192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 307:
-#line 2127 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 312:
+#line 2152 "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 7202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 308:
-#line 2132 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 313:
+#line 2157 "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 7212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 309:
-#line 2137 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 314:
+#line 2162 "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 7222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 310:
-#line 2142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 315:
+#line 2167 "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 7232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 311:
-#line 2147 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 316:
+#line 2172 "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 7242 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 312:
-#line 2152 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 317:
+#line 2177 "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 7252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 313:
-#line 2157 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 318:
+#line 2182 "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 7262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 314:
-#line 2162 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 319:
+#line 2187 "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 7272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 315:
-#line 2167 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 320:
+#line 2192 "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 7282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 316:
-#line 2172 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 321:
+#line 2197 "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 7292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 317:
-#line 2177 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 322:
+#line 2202 "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 7302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 318:
-#line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 323:
+#line 2207 "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 7312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 319:
-#line 2187 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 324:
+#line 2212 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7321,11 +7430,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
 #endif
     }
-#line 7325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 320:
-#line 2195 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 325:
+#line 2220 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7334,11 +7443,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
 #endif
     }
-#line 7338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 321:
-#line 2203 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 326:
+#line 2228 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7347,11 +7456,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
 #endif
     }
-#line 7351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 322:
-#line 2211 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 327:
+#line 2236 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7360,11 +7469,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
 #endif
     }
-#line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 323:
-#line 2219 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 328:
+#line 2244 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7373,11 +7482,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
 #endif
     }
-#line 7377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 324:
-#line 2227 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 329:
+#line 2252 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7386,11 +7495,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
 #endif
     }
-#line 7390 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 325:
-#line 2235 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 330:
+#line 2260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7399,11 +7508,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
 #endif
     }
-#line 7403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 326:
-#line 2243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 331:
+#line 2268 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7412,11 +7521,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 7416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 327:
-#line 2251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 332:
+#line 2276 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7425,11 +7534,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 7429 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 328:
-#line 2259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 333:
+#line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7438,11 +7547,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
 #endif
     }
-#line 7442 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 329:
-#line 2267 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 334:
+#line 2292 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7451,11 +7560,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
 #endif
     }
-#line 7455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7564 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 330:
-#line 2275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 335:
+#line 2300 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7464,11 +7573,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 7468 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 331:
-#line 2283 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 336:
+#line 2308 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7477,171 +7586,171 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
 #endif
     }
-#line 7481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 332:
-#line 2291 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 337:
+#line 2316 "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 7491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 333:
-#line 2296 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 338:
+#line 2321 "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 7501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 334:
-#line 2301 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 339:
+#line 2326 "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 7511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 335:
-#line 2306 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 340:
+#line 2331 "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 7521 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 336:
-#line 2311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 341:
+#line 2336 "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 7531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7640 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 337:
-#line 2316 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 342:
+#line 2341 "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 7541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 338:
-#line 2321 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 343:
+#line 2346 "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 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 339:
-#line 2326 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 344:
+#line 2351 "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 7561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 340:
-#line 2331 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 345:
+#line 2356 "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 7571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7680 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 341:
-#line 2336 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 346:
+#line 2361 "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 7581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 342:
-#line 2341 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 347:
+#line 2366 "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 7591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 343:
-#line 2346 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 348:
+#line 2371 "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 7601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 344:
-#line 2351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 349:
+#line 2376 "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 7611 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 345:
-#line 2356 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 350:
+#line 2381 "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 7621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 346:
-#line 2361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 351:
+#line 2386 "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 7631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 347:
-#line 2366 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 352:
+#line 2391 "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 7641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 348:
-#line 2371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 353:
+#line 2396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7650,11 +7759,11 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
 #endif
     }
-#line 7654 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 349:
-#line 2379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 354:
+#line 2404 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7663,41 +7772,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
 #endif
     }
-#line 7667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 350:
-#line 2387 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 355:
+#line 2412 "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 7677 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 351:
-#line 2392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 356:
+#line 2417 "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 7687 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 352:
-#line 2397 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 357:
+#line 2422 "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 7697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 353:
-#line 2402 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 358:
+#line 2427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7706,41 +7815,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 7710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 354:
-#line 2410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 359:
+#line 2435 "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 7720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 355:
-#line 2415 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 360:
+#line 2440 "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 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 356:
-#line 2420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 361:
+#line 2445 "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 7740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 357:
-#line 2425 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 362:
+#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7749,41 +7858,41 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 7753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 358:
-#line 2433 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 363:
+#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, Esd2D, false, false, true);
     }
-#line 7763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 359:
-#line 2438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 364:
+#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(EbtUint, Esd2D, false, false, true);
     }
-#line 7773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 360:
-#line 2443 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 365:
+#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(EbtFloat, Esd2D, true, false, true);
     }
-#line 7783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 361:
-#line 2448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 366:
+#line 2473 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
@@ -7792,61 +7901,61 @@ yyreduce:
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 7796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 362:
-#line 2456 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 367:
+#line 2481 "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 7806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 363:
-#line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 368:
+#line 2486 "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 7816 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 364:
-#line 2466 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 369:
+#line 2491 "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 7826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 365:
-#line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 370:
+#line 2496 "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 7836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 366:
-#line 2476 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 371:
+#line 2501 "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 7846 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 367:
-#line 2481 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 372:
+#line 2506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7855,21 +7964,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
 #endif
     }
-#line 7859 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 368:
-#line 2489 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 373:
+#line 2514 "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 7869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 369:
-#line 2494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 374:
+#line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7878,21 +7987,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
 #endif
     }
-#line 7882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 370:
-#line 2502 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 375:
+#line 2527 "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 7892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 371:
-#line 2507 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 376:
+#line 2532 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7901,21 +8010,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
 #endif
     }
-#line 7905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8014 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 372:
-#line 2515 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 377:
+#line 2540 "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 7915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 373:
-#line 2520 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 378:
+#line 2545 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7924,21 +8033,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
 #endif
     }
-#line 7928 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 374:
-#line 2528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 379:
+#line 2553 "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 7938 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 375:
-#line 2533 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 380:
+#line 2558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7947,21 +8056,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 7951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 376:
-#line 2541 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 381:
+#line 2566 "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 7961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8070 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 377:
-#line 2546 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 382:
+#line 2571 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7970,21 +8079,21 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 7974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 378:
-#line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 383:
+#line 2579 "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 7984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 379:
-#line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 384:
+#line 2584 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -7993,161 +8102,161 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 7997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 380:
-#line 2567 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 385:
+#line 2592 "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 8007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 381:
-#line 2572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 386:
+#line 2597 "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 8017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 382:
-#line 2577 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 387:
+#line 2602 "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 8027 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 383:
-#line 2582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 388:
+#line 2607 "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 8037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 384:
-#line 2587 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 389:
+#line 2612 "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 8047 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 385:
-#line 2592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 390:
+#line 2617 "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 8057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 386:
-#line 2597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 391:
+#line 2622 "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 8067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 387:
-#line 2602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 392:
+#line 2627 "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 8077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 388:
-#line 2607 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 393:
+#line 2632 "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 8087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 389:
-#line 2612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 394:
+#line 2637 "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 8097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 390:
-#line 2617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 395:
+#line 2642 "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 8107 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 391:
-#line 2622 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 396:
+#line 2647 "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 8117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 392:
-#line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 397:
+#line 2652 "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 8127 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 393:
-#line 2632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 398:
+#line 2657 "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 8137 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 394:
-#line 2637 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 399:
+#line 2662 "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 8147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 395:
-#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 400:
+#line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8156,41 +8265,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
 #endif
     }
-#line 8160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 396:
-#line 2650 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 401:
+#line 2675 "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 8170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 397:
-#line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 402:
+#line 2680 "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 8180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 398:
-#line 2660 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 403:
+#line 2685 "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 8190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 399:
-#line 2665 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 404:
+#line 2690 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8199,41 +8308,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 8203 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 400:
-#line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 405:
+#line 2698 "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 8213 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 401:
-#line 2678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 406:
+#line 2703 "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 8223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 402:
-#line 2683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 407:
+#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, false, false, true);
     }
-#line 8233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 403:
-#line 2688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 408:
+#line 2713 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8242,41 +8351,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 8246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8355 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 404:
-#line 2696 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 409:
+#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(EbtInt, Esd2D, false, false, true);
     }
-#line 8256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 405:
-#line 2701 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 410:
+#line 2726 "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 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 406:
-#line 2706 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 411:
+#line 2731 "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 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 407:
-#line 2711 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 412:
+#line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
@@ -8285,41 +8394,41 @@ yyreduce:
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 8289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8398 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 408:
-#line 2719 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 413:
+#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, Esd2D, true, false, true);
     }
-#line 8299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 409:
-#line 2724 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 414:
+#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(EbtUint, Esd2D, true, false, true);
     }
-#line 8309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 410:
-#line 2729 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 415:
+#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.setImage(EbtFloat, Esd1D);
     }
-#line 8319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 411:
-#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 416:
+#line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8328,41 +8437,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
 #endif
     }
-#line 8332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 412:
-#line 2742 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 417:
+#line 2767 "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 8342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8451 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 413:
-#line 2747 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 418:
+#line 2772 "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 8352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 414:
-#line 2752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 419:
+#line 2777 "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 8362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 415:
-#line 2757 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 420:
+#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8371,41 +8480,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
 #endif
     }
-#line 8375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 416:
-#line 2765 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 421:
+#line 2790 "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 8385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 417:
-#line 2770 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 422:
+#line 2795 "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 8395 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 418:
-#line 2775 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 423:
+#line 2800 "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 8405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 419:
-#line 2780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 424:
+#line 2805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8414,41 +8523,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
 #endif
     }
-#line 8418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 420:
-#line 2788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 425:
+#line 2813 "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 8428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 421:
-#line 2793 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 426:
+#line 2818 "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 8438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 422:
-#line 2798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 427:
+#line 2823 "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 8448 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 423:
-#line 2803 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 428:
+#line 2828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8457,41 +8566,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
 #endif
     }
-#line 8461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 424:
-#line 2811 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 429:
+#line 2836 "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 8471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 425:
-#line 2816 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 430:
+#line 2841 "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 8481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 426:
-#line 2821 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 431:
+#line 2846 "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 8491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 427:
-#line 2826 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 432:
+#line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8500,41 +8609,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
 #endif
     }
-#line 8504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 428:
-#line 2834 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 433:
+#line 2859 "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 8514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 429:
-#line 2839 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 434:
+#line 2864 "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 8524 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 430:
-#line 2844 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 435:
+#line 2869 "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 8534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 431:
-#line 2849 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 436:
+#line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8543,41 +8652,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
 #endif
     }
-#line 8547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8656 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 432:
-#line 2857 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 437:
+#line 2882 "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 8557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 433:
-#line 2862 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 438:
+#line 2887 "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 8567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 434:
-#line 2867 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 439:
+#line 2892 "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 8577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 435:
-#line 2872 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 440:
+#line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8586,41 +8695,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
 #endif
     }
-#line 8590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 436:
-#line 2880 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 441:
+#line 2905 "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 8600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 437:
-#line 2885 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 442:
+#line 2910 "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 8610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 438:
-#line 2890 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 443:
+#line 2915 "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 8620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 439:
-#line 2895 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 444:
+#line 2920 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8629,41 +8738,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
 #endif
     }
-#line 8633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 440:
-#line 2903 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 445:
+#line 2928 "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 8643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 441:
-#line 2908 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 446:
+#line 2933 "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 8653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 442:
-#line 2913 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 447:
+#line 2938 "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 8663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 443:
-#line 2918 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 448:
+#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8672,41 +8781,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
 #endif
     }
-#line 8676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8785 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 444:
-#line 2926 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 449:
+#line 2951 "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 8686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 445:
-#line 2931 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 450:
+#line 2956 "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 8696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 446:
-#line 2936 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 451:
+#line 2961 "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 8706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 447:
-#line 2941 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 452:
+#line 2966 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8715,41 +8824,41 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
 #endif
     }
-#line 8719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 448:
-#line 2949 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 453:
+#line 2974 "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 8729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 449:
-#line 2954 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 454:
+#line 2979 "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 8739 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 450:
-#line 2959 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 455:
+#line 2984 "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 8749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 451:
-#line 2964 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 456:
+#line 2989 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
@@ -8758,64 +8867,64 @@ yyreduce:
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
 #endif
     }
-#line 8762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 452:
-#line 2972 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 457:
+#line 2997 "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 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 453:
-#line 2977 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 458:
+#line 3002 "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 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 454:
-#line 2982 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 459:
+#line 3007 "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 8793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 455:
-#line 2988 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 460:
+#line 3013 "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 8804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 456:
-#line 2994 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 461:
+#line 3019 "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 8815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 457:
-#line 3000 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 462:
+#line 3025 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
@@ -8825,11 +8934,11 @@ yyreduce:
         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
 #endif
     }
-#line 8829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8938 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 458:
-#line 3009 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 463:
+#line 3034 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
 #ifdef AMD_EXTENSIONS
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
@@ -8839,65 +8948,65 @@ yyreduce:
         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
 #endif
     }
-#line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 459:
-#line 3018 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 464:
+#line 3043 "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 8854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 460:
-#line 3024 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 465:
+#line 3049 "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 8865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 461:
-#line 3030 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 466:
+#line 3055 "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 8876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 462:
-#line 3036 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 467:
+#line 3061 "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 8887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 463:
-#line 3042 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 468:
+#line 3067 "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 8897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 464:
-#line 3047 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 469:
+#line 3072 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -8911,47 +9020,47 @@ yyreduce:
         } else
             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
     }
-#line 8915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 465:
-#line 3063 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 470:
+#line 3088 "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 8925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 466:
-#line 3068 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 471:
+#line 3093 "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 8935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 467:
-#line 3073 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 472:
+#line 3098 "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 8945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 468:
-#line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 473:
+#line 3106 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
-#line 8951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 469:
-#line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 474:
+#line 3106 "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);
@@ -8963,17 +9072,17 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 8967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 470:
-#line 3092 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 475:
+#line 3117 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
-#line 8973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 471:
-#line 3092 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 476:
+#line 3117 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[-4].lex).loc);
@@ -8981,19 +9090,19 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 8985 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9094 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 472:
-#line 3102 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 477:
+#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
     }
-#line 8993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 473:
-#line 3105 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 478:
+#line 3130 "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) {
@@ -9004,11 +9113,11 @@ yyreduce:
             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
         }
     }
-#line 9008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 474:
-#line 3118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 479:
+#line 3143 "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");
@@ -9031,11 +9140,11 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 475:
-#line 3140 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 480:
+#line 3165 "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");
@@ -9060,38 +9169,38 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 476:
-#line 3167 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 481:
+#line 3192 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 477:
-#line 3171 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 482:
+#line 3196 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 478:
-#line 3177 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 483:
+#line 3202 "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 9091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 479:
-#line 3182 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 484:
+#line 3207 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
 
@@ -9100,219 +9209,219 @@ yyreduce:
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
     }
-#line 9104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9213 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 480:
-#line 3193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 485:
+#line 3218 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 481:
-#line 3196 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 486:
+#line 3221 "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 9123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 482:
-#line 3202 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 487:
+#line 3227 "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 9134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 483:
-#line 3211 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 488:
+#line 3236 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
     }
-#line 9142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 484:
-#line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 489:
+#line 3239 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 9150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 485:
-#line 3220 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 490:
+#line 3245 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 486:
-#line 3224 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 491:
+#line 3249 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 487:
-#line 3225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 492:
+#line 3250 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 488:
-#line 3231 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 493:
+#line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 489:
-#line 3232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 494:
+#line 3257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 490:
-#line 3233 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 495:
+#line 3258 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 491:
-#line 3234 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 496:
+#line 3259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 492:
-#line 3235 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 497:
+#line 3260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 493:
-#line 3236 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 498:
+#line 3261 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 494:
-#line 3237 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 499:
+#line 3262 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 495:
-#line 3241 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 500:
+#line 3266 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 496:
-#line 3242 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 501:
+#line 3267 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
-#line 9225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 497:
-#line 3246 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 502:
+#line 3271 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
-#line 9234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 498:
-#line 3250 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 503:
+#line 3275 "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 9244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 499:
-#line 3258 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 504:
+#line 3283 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 500:
-#line 3259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 505:
+#line 3284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 501:
-#line 3263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 506:
+#line 3288 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 502:
-#line 3266 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 507:
+#line 3291 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 503:
-#line 3270 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 508:
+#line 3295 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 504:
-#line 3275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 509:
+#line 3300 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9294 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 505:
-#line 3284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 510:
+#line 3309 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9302 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 506:
-#line 3287 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 511:
+#line 3312 "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 9312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 507:
-#line 3295 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 512:
+#line 3320 "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 ||
@@ -9321,11 +9430,11 @@ yyreduce:
             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
         }
     }
-#line 9325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 508:
-#line 3303 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 513:
+#line 3328 "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)) {
@@ -9334,76 +9443,76 @@ yyreduce:
         } else
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 9338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 509:
-#line 3314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 514:
+#line 3339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9344 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9453 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 510:
-#line 3315 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 515:
+#line 3340 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
-#line 9350 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9459 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 511:
-#line 3319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 516:
+#line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 512:
-#line 3322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 517:
+#line 3347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 513:
-#line 3328 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 518:
+#line 3353 "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 9376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 514:
-#line 3335 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 519:
+#line 3360 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
     }
-#line 9385 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 515:
-#line 3339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 520:
+#line 3364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 9394 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 516:
-#line 3347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 521:
+#line 3372 "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 9403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9512 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 517:
-#line 3351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 522:
+#line 3376 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
 
@@ -9414,28 +9523,28 @@ yyreduce:
         else
             (yyval.interm.intermTypedNode) = 0;
     }
-#line 9418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 518:
-#line 3364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 523:
+#line 3389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 519:
-#line 3367 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 524:
+#line 3392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9435 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 520:
-#line 3373 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 525:
+#line 3398 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -9444,11 +9553,11 @@ yyreduce:
         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
         parseContext.symbolTable.push();
     }
-#line 9448 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 521:
-#line 3381 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 526:
+#line 3406 "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();
@@ -9458,27 +9567,27 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 522:
-#line 3393 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 527:
+#line 3418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 523:
-#line 3396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 528:
+#line 3421 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 524:
-#line 3402 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 529:
+#line 3427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -9491,11 +9600,11 @@ yyreduce:
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
         }
     }
-#line 9495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 525:
-#line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 530:
+#line 3439 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -9505,28 +9614,28 @@ yyreduce:
         else
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
     }
-#line 9509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 526:
-#line 3426 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 531:
+#line 3451 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 527:
-#line 3429 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 532:
+#line 3454 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9635 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 528:
-#line 3435 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 533:
+#line 3460 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
@@ -9535,11 +9644,11 @@ yyreduce:
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9539 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 529:
-#line 3443 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 534:
+#line 3468 "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);
@@ -9547,21 +9656,21 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 530:
-#line 3450 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 535:
+#line 3475 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 531:
-#line 3455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 536:
+#line 3480 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
@@ -9573,22 +9682,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 532:
-#line 3466 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 537:
+#line 3491 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 533:
-#line 3472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 538:
+#line 3497 "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);
@@ -9601,81 +9710,81 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9605 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 534:
-#line 3487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 539:
+#line 3512 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 535:
-#line 3490 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 540:
+#line 3515 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 536:
-#line 3496 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 541:
+#line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 537:
-#line 3499 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 542:
+#line 3524 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = 0;
     }
-#line 9637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9746 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 538:
-#line 3505 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 543:
+#line 3530 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 9646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9755 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 539:
-#line 3509 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 544:
+#line 3534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 540:
-#line 3516 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 545:
+#line 3541 "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 9665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 541:
-#line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 546:
+#line 3546 "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 9675 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 542:
-#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 547:
+#line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -9683,83 +9792,83 @@ yyreduce:
         if (parseContext.inMain)
             parseContext.postEntryPointReturn = true;
     }
-#line 9687 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 543:
-#line 3533 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 548:
+#line 3558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 9695 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 544:
-#line 3536 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 549:
+#line 3561 "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 9704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 545:
-#line 3545 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 550:
+#line 3570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
-#line 9713 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9822 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 546:
-#line 3549 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 551:
+#line 3574 "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 9724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 547:
-#line 3558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 552:
+#line 3583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 548:
-#line 3561 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 553:
+#line 3586 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9849 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 549:
-#line 3564 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 554:
+#line 3589 "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 9750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9859 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 550:
-#line 3572 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 555:
+#line 3597 "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 9759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9868 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 551:
-#line 3576 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 556:
+#line 3601 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -9775,52 +9884,52 @@ yyreduce:
         (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
         (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
     }
-#line 9779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9888 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 552:
-#line 3594 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 557:
+#line 3619 "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 9788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 553:
-#line 3600 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 558:
+#line 3625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
     }
-#line 9796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 554:
-#line 3603 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 559:
+#line 3628 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
     }
-#line 9804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 555:
-#line 3608 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 560:
+#line 3633 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
     }
-#line 9812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9921 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 556:
-#line 3611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 561:
+#line 3636 "MachineIndependent/glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 9820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
 
-#line 9824 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -10048,5 +10157,5 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 3615 "MachineIndependent/glslang.y" /* yacc.c:1906  */
+#line 3640 "MachineIndependent/glslang.y" /* yacc.c:1906  */
 

diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
index 9085dd0..7534eea 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.0.4.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -130,315 +130,320 @@ extern int yydebug;
     RESTRICT = 340,
     READONLY = 341,
     WRITEONLY = 342,
-    DVEC2 = 343,
-    DVEC3 = 344,
-    DVEC4 = 345,
-    DMAT2 = 346,
-    DMAT3 = 347,
-    DMAT4 = 348,
-    F16VEC2 = 349,
-    F16VEC3 = 350,
-    F16VEC4 = 351,
-    F16MAT2 = 352,
-    F16MAT3 = 353,
-    F16MAT4 = 354,
-    F32VEC2 = 355,
-    F32VEC3 = 356,
-    F32VEC4 = 357,
-    F32MAT2 = 358,
-    F32MAT3 = 359,
-    F32MAT4 = 360,
-    F64VEC2 = 361,
-    F64VEC3 = 362,
-    F64VEC4 = 363,
-    F64MAT2 = 364,
-    F64MAT3 = 365,
-    F64MAT4 = 366,
-    NOPERSPECTIVE = 367,
-    FLAT = 368,
-    SMOOTH = 369,
-    LAYOUT = 370,
-    EXPLICITINTERPAMD = 371,
-    MAT2X2 = 372,
-    MAT2X3 = 373,
-    MAT2X4 = 374,
-    MAT3X2 = 375,
-    MAT3X3 = 376,
-    MAT3X4 = 377,
-    MAT4X2 = 378,
-    MAT4X3 = 379,
-    MAT4X4 = 380,
-    DMAT2X2 = 381,
-    DMAT2X3 = 382,
-    DMAT2X4 = 383,
-    DMAT3X2 = 384,
-    DMAT3X3 = 385,
-    DMAT3X4 = 386,
-    DMAT4X2 = 387,
-    DMAT4X3 = 388,
-    DMAT4X4 = 389,
-    F16MAT2X2 = 390,
-    F16MAT2X3 = 391,
-    F16MAT2X4 = 392,
-    F16MAT3X2 = 393,
-    F16MAT3X3 = 394,
-    F16MAT3X4 = 395,
-    F16MAT4X2 = 396,
-    F16MAT4X3 = 397,
-    F16MAT4X4 = 398,
-    F32MAT2X2 = 399,
-    F32MAT2X3 = 400,
-    F32MAT2X4 = 401,
-    F32MAT3X2 = 402,
-    F32MAT3X3 = 403,
-    F32MAT3X4 = 404,
-    F32MAT4X2 = 405,
-    F32MAT4X3 = 406,
-    F32MAT4X4 = 407,
-    F64MAT2X2 = 408,
-    F64MAT2X3 = 409,
-    F64MAT2X4 = 410,
-    F64MAT3X2 = 411,
-    F64MAT3X3 = 412,
-    F64MAT3X4 = 413,
-    F64MAT4X2 = 414,
-    F64MAT4X3 = 415,
-    F64MAT4X4 = 416,
-    ATOMIC_UINT = 417,
-    SAMPLER1D = 418,
-    SAMPLER2D = 419,
-    SAMPLER3D = 420,
-    SAMPLERCUBE = 421,
-    SAMPLER1DSHADOW = 422,
-    SAMPLER2DSHADOW = 423,
-    SAMPLERCUBESHADOW = 424,
-    SAMPLER1DARRAY = 425,
-    SAMPLER2DARRAY = 426,
-    SAMPLER1DARRAYSHADOW = 427,
-    SAMPLER2DARRAYSHADOW = 428,
-    ISAMPLER1D = 429,
-    ISAMPLER2D = 430,
-    ISAMPLER3D = 431,
-    ISAMPLERCUBE = 432,
-    ISAMPLER1DARRAY = 433,
-    ISAMPLER2DARRAY = 434,
-    USAMPLER1D = 435,
-    USAMPLER2D = 436,
-    USAMPLER3D = 437,
-    USAMPLERCUBE = 438,
-    USAMPLER1DARRAY = 439,
-    USAMPLER2DARRAY = 440,
-    SAMPLER2DRECT = 441,
-    SAMPLER2DRECTSHADOW = 442,
-    ISAMPLER2DRECT = 443,
-    USAMPLER2DRECT = 444,
-    SAMPLERBUFFER = 445,
-    ISAMPLERBUFFER = 446,
-    USAMPLERBUFFER = 447,
-    SAMPLERCUBEARRAY = 448,
-    SAMPLERCUBEARRAYSHADOW = 449,
-    ISAMPLERCUBEARRAY = 450,
-    USAMPLERCUBEARRAY = 451,
-    SAMPLER2DMS = 452,
-    ISAMPLER2DMS = 453,
-    USAMPLER2DMS = 454,
-    SAMPLER2DMSARRAY = 455,
-    ISAMPLER2DMSARRAY = 456,
-    USAMPLER2DMSARRAY = 457,
-    SAMPLEREXTERNALOES = 458,
-    F16SAMPLER1D = 459,
-    F16SAMPLER2D = 460,
-    F16SAMPLER3D = 461,
-    F16SAMPLER2DRECT = 462,
-    F16SAMPLERCUBE = 463,
-    F16SAMPLER1DARRAY = 464,
-    F16SAMPLER2DARRAY = 465,
-    F16SAMPLERCUBEARRAY = 466,
-    F16SAMPLERBUFFER = 467,
-    F16SAMPLER2DMS = 468,
-    F16SAMPLER2DMSARRAY = 469,
-    F16SAMPLER1DSHADOW = 470,
-    F16SAMPLER2DSHADOW = 471,
-    F16SAMPLER1DARRAYSHADOW = 472,
-    F16SAMPLER2DARRAYSHADOW = 473,
-    F16SAMPLER2DRECTSHADOW = 474,
-    F16SAMPLERCUBESHADOW = 475,
-    F16SAMPLERCUBEARRAYSHADOW = 476,
-    SAMPLER = 477,
-    SAMPLERSHADOW = 478,
-    TEXTURE1D = 479,
-    TEXTURE2D = 480,
-    TEXTURE3D = 481,
-    TEXTURECUBE = 482,
-    TEXTURE1DARRAY = 483,
-    TEXTURE2DARRAY = 484,
-    ITEXTURE1D = 485,
-    ITEXTURE2D = 486,
-    ITEXTURE3D = 487,
-    ITEXTURECUBE = 488,
-    ITEXTURE1DARRAY = 489,
-    ITEXTURE2DARRAY = 490,
-    UTEXTURE1D = 491,
-    UTEXTURE2D = 492,
-    UTEXTURE3D = 493,
-    UTEXTURECUBE = 494,
-    UTEXTURE1DARRAY = 495,
-    UTEXTURE2DARRAY = 496,
-    TEXTURE2DRECT = 497,
-    ITEXTURE2DRECT = 498,
-    UTEXTURE2DRECT = 499,
-    TEXTUREBUFFER = 500,
-    ITEXTUREBUFFER = 501,
-    UTEXTUREBUFFER = 502,
-    TEXTURECUBEARRAY = 503,
-    ITEXTURECUBEARRAY = 504,
-    UTEXTURECUBEARRAY = 505,
-    TEXTURE2DMS = 506,
-    ITEXTURE2DMS = 507,
-    UTEXTURE2DMS = 508,
-    TEXTURE2DMSARRAY = 509,
-    ITEXTURE2DMSARRAY = 510,
-    UTEXTURE2DMSARRAY = 511,
-    F16TEXTURE1D = 512,
-    F16TEXTURE2D = 513,
-    F16TEXTURE3D = 514,
-    F16TEXTURE2DRECT = 515,
-    F16TEXTURECUBE = 516,
-    F16TEXTURE1DARRAY = 517,
-    F16TEXTURE2DARRAY = 518,
-    F16TEXTURECUBEARRAY = 519,
-    F16TEXTUREBUFFER = 520,
-    F16TEXTURE2DMS = 521,
-    F16TEXTURE2DMSARRAY = 522,
-    SUBPASSINPUT = 523,
-    SUBPASSINPUTMS = 524,
-    ISUBPASSINPUT = 525,
-    ISUBPASSINPUTMS = 526,
-    USUBPASSINPUT = 527,
-    USUBPASSINPUTMS = 528,
-    F16SUBPASSINPUT = 529,
-    F16SUBPASSINPUTMS = 530,
-    IMAGE1D = 531,
-    IIMAGE1D = 532,
-    UIMAGE1D = 533,
-    IMAGE2D = 534,
-    IIMAGE2D = 535,
-    UIMAGE2D = 536,
-    IMAGE3D = 537,
-    IIMAGE3D = 538,
-    UIMAGE3D = 539,
-    IMAGE2DRECT = 540,
-    IIMAGE2DRECT = 541,
-    UIMAGE2DRECT = 542,
-    IMAGECUBE = 543,
-    IIMAGECUBE = 544,
-    UIMAGECUBE = 545,
-    IMAGEBUFFER = 546,
-    IIMAGEBUFFER = 547,
-    UIMAGEBUFFER = 548,
-    IMAGE1DARRAY = 549,
-    IIMAGE1DARRAY = 550,
-    UIMAGE1DARRAY = 551,
-    IMAGE2DARRAY = 552,
-    IIMAGE2DARRAY = 553,
-    UIMAGE2DARRAY = 554,
-    IMAGECUBEARRAY = 555,
-    IIMAGECUBEARRAY = 556,
-    UIMAGECUBEARRAY = 557,
-    IMAGE2DMS = 558,
-    IIMAGE2DMS = 559,
-    UIMAGE2DMS = 560,
-    IMAGE2DMSARRAY = 561,
-    IIMAGE2DMSARRAY = 562,
-    UIMAGE2DMSARRAY = 563,
-    F16IMAGE1D = 564,
-    F16IMAGE2D = 565,
-    F16IMAGE3D = 566,
-    F16IMAGE2DRECT = 567,
-    F16IMAGECUBE = 568,
-    F16IMAGE1DARRAY = 569,
-    F16IMAGE2DARRAY = 570,
-    F16IMAGECUBEARRAY = 571,
-    F16IMAGEBUFFER = 572,
-    F16IMAGE2DMS = 573,
-    F16IMAGE2DMSARRAY = 574,
-    STRUCT = 575,
-    VOID = 576,
-    WHILE = 577,
-    IDENTIFIER = 578,
-    TYPE_NAME = 579,
-    FLOATCONSTANT = 580,
-    DOUBLECONSTANT = 581,
-    INT16CONSTANT = 582,
-    UINT16CONSTANT = 583,
-    INT32CONSTANT = 584,
-    UINT32CONSTANT = 585,
-    INTCONSTANT = 586,
-    UINTCONSTANT = 587,
-    INT64CONSTANT = 588,
-    UINT64CONSTANT = 589,
-    BOOLCONSTANT = 590,
-    FLOAT16CONSTANT = 591,
-    LEFT_OP = 592,
-    RIGHT_OP = 593,
-    INC_OP = 594,
-    DEC_OP = 595,
-    LE_OP = 596,
-    GE_OP = 597,
-    EQ_OP = 598,
-    NE_OP = 599,
-    AND_OP = 600,
-    OR_OP = 601,
-    XOR_OP = 602,
-    MUL_ASSIGN = 603,
-    DIV_ASSIGN = 604,
-    ADD_ASSIGN = 605,
-    MOD_ASSIGN = 606,
-    LEFT_ASSIGN = 607,
-    RIGHT_ASSIGN = 608,
-    AND_ASSIGN = 609,
-    XOR_ASSIGN = 610,
-    OR_ASSIGN = 611,
-    SUB_ASSIGN = 612,
-    LEFT_PAREN = 613,
-    RIGHT_PAREN = 614,
-    LEFT_BRACKET = 615,
-    RIGHT_BRACKET = 616,
-    LEFT_BRACE = 617,
-    RIGHT_BRACE = 618,
-    DOT = 619,
-    COMMA = 620,
-    COLON = 621,
-    EQUAL = 622,
-    SEMICOLON = 623,
-    BANG = 624,
-    DASH = 625,
-    TILDE = 626,
-    PLUS = 627,
-    STAR = 628,
-    SLASH = 629,
-    PERCENT = 630,
-    LEFT_ANGLE = 631,
-    RIGHT_ANGLE = 632,
-    VERTICAL_BAR = 633,
-    CARET = 634,
-    AMPERSAND = 635,
-    QUESTION = 636,
-    INVARIANT = 637,
-    PRECISE = 638,
-    HIGH_PRECISION = 639,
-    MEDIUM_PRECISION = 640,
-    LOW_PRECISION = 641,
-    PRECISION = 642,
-    PACKED = 643,
-    RESOURCE = 644,
-    SUPERP = 645
+    DEVICECOHERENT = 343,
+    QUEUEFAMILYCOHERENT = 344,
+    WORKGROUPCOHERENT = 345,
+    SUBGROUPCOHERENT = 346,
+    NONPRIVATE = 347,
+    DVEC2 = 348,
+    DVEC3 = 349,
+    DVEC4 = 350,
+    DMAT2 = 351,
+    DMAT3 = 352,
+    DMAT4 = 353,
+    F16VEC2 = 354,
+    F16VEC3 = 355,
+    F16VEC4 = 356,
+    F16MAT2 = 357,
+    F16MAT3 = 358,
+    F16MAT4 = 359,
+    F32VEC2 = 360,
+    F32VEC3 = 361,
+    F32VEC4 = 362,
+    F32MAT2 = 363,
+    F32MAT3 = 364,
+    F32MAT4 = 365,
+    F64VEC2 = 366,
+    F64VEC3 = 367,
+    F64VEC4 = 368,
+    F64MAT2 = 369,
+    F64MAT3 = 370,
+    F64MAT4 = 371,
+    NOPERSPECTIVE = 372,
+    FLAT = 373,
+    SMOOTH = 374,
+    LAYOUT = 375,
+    EXPLICITINTERPAMD = 376,
+    MAT2X2 = 377,
+    MAT2X3 = 378,
+    MAT2X4 = 379,
+    MAT3X2 = 380,
+    MAT3X3 = 381,
+    MAT3X4 = 382,
+    MAT4X2 = 383,
+    MAT4X3 = 384,
+    MAT4X4 = 385,
+    DMAT2X2 = 386,
+    DMAT2X3 = 387,
+    DMAT2X4 = 388,
+    DMAT3X2 = 389,
+    DMAT3X3 = 390,
+    DMAT3X4 = 391,
+    DMAT4X2 = 392,
+    DMAT4X3 = 393,
+    DMAT4X4 = 394,
+    F16MAT2X2 = 395,
+    F16MAT2X3 = 396,
+    F16MAT2X4 = 397,
+    F16MAT3X2 = 398,
+    F16MAT3X3 = 399,
+    F16MAT3X4 = 400,
+    F16MAT4X2 = 401,
+    F16MAT4X3 = 402,
+    F16MAT4X4 = 403,
+    F32MAT2X2 = 404,
+    F32MAT2X3 = 405,
+    F32MAT2X4 = 406,
+    F32MAT3X2 = 407,
+    F32MAT3X3 = 408,
+    F32MAT3X4 = 409,
+    F32MAT4X2 = 410,
+    F32MAT4X3 = 411,
+    F32MAT4X4 = 412,
+    F64MAT2X2 = 413,
+    F64MAT2X3 = 414,
+    F64MAT2X4 = 415,
+    F64MAT3X2 = 416,
+    F64MAT3X3 = 417,
+    F64MAT3X4 = 418,
+    F64MAT4X2 = 419,
+    F64MAT4X3 = 420,
+    F64MAT4X4 = 421,
+    ATOMIC_UINT = 422,
+    SAMPLER1D = 423,
+    SAMPLER2D = 424,
+    SAMPLER3D = 425,
+    SAMPLERCUBE = 426,
+    SAMPLER1DSHADOW = 427,
+    SAMPLER2DSHADOW = 428,
+    SAMPLERCUBESHADOW = 429,
+    SAMPLER1DARRAY = 430,
+    SAMPLER2DARRAY = 431,
+    SAMPLER1DARRAYSHADOW = 432,
+    SAMPLER2DARRAYSHADOW = 433,
+    ISAMPLER1D = 434,
+    ISAMPLER2D = 435,
+    ISAMPLER3D = 436,
+    ISAMPLERCUBE = 437,
+    ISAMPLER1DARRAY = 438,
+    ISAMPLER2DARRAY = 439,
+    USAMPLER1D = 440,
+    USAMPLER2D = 441,
+    USAMPLER3D = 442,
+    USAMPLERCUBE = 443,
+    USAMPLER1DARRAY = 444,
+    USAMPLER2DARRAY = 445,
+    SAMPLER2DRECT = 446,
+    SAMPLER2DRECTSHADOW = 447,
+    ISAMPLER2DRECT = 448,
+    USAMPLER2DRECT = 449,
+    SAMPLERBUFFER = 450,
+    ISAMPLERBUFFER = 451,
+    USAMPLERBUFFER = 452,
+    SAMPLERCUBEARRAY = 453,
+    SAMPLERCUBEARRAYSHADOW = 454,
+    ISAMPLERCUBEARRAY = 455,
+    USAMPLERCUBEARRAY = 456,
+    SAMPLER2DMS = 457,
+    ISAMPLER2DMS = 458,
+    USAMPLER2DMS = 459,
+    SAMPLER2DMSARRAY = 460,
+    ISAMPLER2DMSARRAY = 461,
+    USAMPLER2DMSARRAY = 462,
+    SAMPLEREXTERNALOES = 463,
+    F16SAMPLER1D = 464,
+    F16SAMPLER2D = 465,
+    F16SAMPLER3D = 466,
+    F16SAMPLER2DRECT = 467,
+    F16SAMPLERCUBE = 468,
+    F16SAMPLER1DARRAY = 469,
+    F16SAMPLER2DARRAY = 470,
+    F16SAMPLERCUBEARRAY = 471,
+    F16SAMPLERBUFFER = 472,
+    F16SAMPLER2DMS = 473,
+    F16SAMPLER2DMSARRAY = 474,
+    F16SAMPLER1DSHADOW = 475,
+    F16SAMPLER2DSHADOW = 476,
+    F16SAMPLER1DARRAYSHADOW = 477,
+    F16SAMPLER2DARRAYSHADOW = 478,
+    F16SAMPLER2DRECTSHADOW = 479,
+    F16SAMPLERCUBESHADOW = 480,
+    F16SAMPLERCUBEARRAYSHADOW = 481,
+    SAMPLER = 482,
+    SAMPLERSHADOW = 483,
+    TEXTURE1D = 484,
+    TEXTURE2D = 485,
+    TEXTURE3D = 486,
+    TEXTURECUBE = 487,
+    TEXTURE1DARRAY = 488,
+    TEXTURE2DARRAY = 489,
+    ITEXTURE1D = 490,
+    ITEXTURE2D = 491,
+    ITEXTURE3D = 492,
+    ITEXTURECUBE = 493,
+    ITEXTURE1DARRAY = 494,
+    ITEXTURE2DARRAY = 495,
+    UTEXTURE1D = 496,
+    UTEXTURE2D = 497,
+    UTEXTURE3D = 498,
+    UTEXTURECUBE = 499,
+    UTEXTURE1DARRAY = 500,
+    UTEXTURE2DARRAY = 501,
+    TEXTURE2DRECT = 502,
+    ITEXTURE2DRECT = 503,
+    UTEXTURE2DRECT = 504,
+    TEXTUREBUFFER = 505,
+    ITEXTUREBUFFER = 506,
+    UTEXTUREBUFFER = 507,
+    TEXTURECUBEARRAY = 508,
+    ITEXTURECUBEARRAY = 509,
+    UTEXTURECUBEARRAY = 510,
+    TEXTURE2DMS = 511,
+    ITEXTURE2DMS = 512,
+    UTEXTURE2DMS = 513,
+    TEXTURE2DMSARRAY = 514,
+    ITEXTURE2DMSARRAY = 515,
+    UTEXTURE2DMSARRAY = 516,
+    F16TEXTURE1D = 517,
+    F16TEXTURE2D = 518,
+    F16TEXTURE3D = 519,
+    F16TEXTURE2DRECT = 520,
+    F16TEXTURECUBE = 521,
+    F16TEXTURE1DARRAY = 522,
+    F16TEXTURE2DARRAY = 523,
+    F16TEXTURECUBEARRAY = 524,
+    F16TEXTUREBUFFER = 525,
+    F16TEXTURE2DMS = 526,
+    F16TEXTURE2DMSARRAY = 527,
+    SUBPASSINPUT = 528,
+    SUBPASSINPUTMS = 529,
+    ISUBPASSINPUT = 530,
+    ISUBPASSINPUTMS = 531,
+    USUBPASSINPUT = 532,
+    USUBPASSINPUTMS = 533,
+    F16SUBPASSINPUT = 534,
+    F16SUBPASSINPUTMS = 535,
+    IMAGE1D = 536,
+    IIMAGE1D = 537,
+    UIMAGE1D = 538,
+    IMAGE2D = 539,
+    IIMAGE2D = 540,
+    UIMAGE2D = 541,
+    IMAGE3D = 542,
+    IIMAGE3D = 543,
+    UIMAGE3D = 544,
+    IMAGE2DRECT = 545,
+    IIMAGE2DRECT = 546,
+    UIMAGE2DRECT = 547,
+    IMAGECUBE = 548,
+    IIMAGECUBE = 549,
+    UIMAGECUBE = 550,
+    IMAGEBUFFER = 551,
+    IIMAGEBUFFER = 552,
+    UIMAGEBUFFER = 553,
+    IMAGE1DARRAY = 554,
+    IIMAGE1DARRAY = 555,
+    UIMAGE1DARRAY = 556,
+    IMAGE2DARRAY = 557,
+    IIMAGE2DARRAY = 558,
+    UIMAGE2DARRAY = 559,
+    IMAGECUBEARRAY = 560,
+    IIMAGECUBEARRAY = 561,
+    UIMAGECUBEARRAY = 562,
+    IMAGE2DMS = 563,
+    IIMAGE2DMS = 564,
+    UIMAGE2DMS = 565,
+    IMAGE2DMSARRAY = 566,
+    IIMAGE2DMSARRAY = 567,
+    UIMAGE2DMSARRAY = 568,
+    F16IMAGE1D = 569,
+    F16IMAGE2D = 570,
+    F16IMAGE3D = 571,
+    F16IMAGE2DRECT = 572,
+    F16IMAGECUBE = 573,
+    F16IMAGE1DARRAY = 574,
+    F16IMAGE2DARRAY = 575,
+    F16IMAGECUBEARRAY = 576,
+    F16IMAGEBUFFER = 577,
+    F16IMAGE2DMS = 578,
+    F16IMAGE2DMSARRAY = 579,
+    STRUCT = 580,
+    VOID = 581,
+    WHILE = 582,
+    IDENTIFIER = 583,
+    TYPE_NAME = 584,
+    FLOATCONSTANT = 585,
+    DOUBLECONSTANT = 586,
+    INT16CONSTANT = 587,
+    UINT16CONSTANT = 588,
+    INT32CONSTANT = 589,
+    UINT32CONSTANT = 590,
+    INTCONSTANT = 591,
+    UINTCONSTANT = 592,
+    INT64CONSTANT = 593,
+    UINT64CONSTANT = 594,
+    BOOLCONSTANT = 595,
+    FLOAT16CONSTANT = 596,
+    LEFT_OP = 597,
+    RIGHT_OP = 598,
+    INC_OP = 599,
+    DEC_OP = 600,
+    LE_OP = 601,
+    GE_OP = 602,
+    EQ_OP = 603,
+    NE_OP = 604,
+    AND_OP = 605,
+    OR_OP = 606,
+    XOR_OP = 607,
+    MUL_ASSIGN = 608,
+    DIV_ASSIGN = 609,
+    ADD_ASSIGN = 610,
+    MOD_ASSIGN = 611,
+    LEFT_ASSIGN = 612,
+    RIGHT_ASSIGN = 613,
+    AND_ASSIGN = 614,
+    XOR_ASSIGN = 615,
+    OR_ASSIGN = 616,
+    SUB_ASSIGN = 617,
+    LEFT_PAREN = 618,
+    RIGHT_PAREN = 619,
+    LEFT_BRACKET = 620,
+    RIGHT_BRACKET = 621,
+    LEFT_BRACE = 622,
+    RIGHT_BRACE = 623,
+    DOT = 624,
+    COMMA = 625,
+    COLON = 626,
+    EQUAL = 627,
+    SEMICOLON = 628,
+    BANG = 629,
+    DASH = 630,
+    TILDE = 631,
+    PLUS = 632,
+    STAR = 633,
+    SLASH = 634,
+    PERCENT = 635,
+    LEFT_ANGLE = 636,
+    RIGHT_ANGLE = 637,
+    VERTICAL_BAR = 638,
+    CARET = 639,
+    AMPERSAND = 640,
+    QUESTION = 641,
+    INVARIANT = 642,
+    PRECISE = 643,
+    HIGH_PRECISION = 644,
+    MEDIUM_PRECISION = 645,
+    LOW_PRECISION = 646,
+    PRECISION = 647,
+    PACKED = 648,
+    RESOURCE = 649,
+    SUPERP = 650
   };
 #endif
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
+
 union YYSTYPE
 {
 #line 70 "MachineIndependent/glslang.y" /* yacc.c:1909  */
@@ -476,8 +481,10 @@ union YYSTYPE
         };
     } interm;
 
-#line 480 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
+#line 485 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
 };
+
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif

diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp
index fc75964..5251141 100644 (file)
--- a/glslang/MachineIndependent/intermOut.cpp
+++ b/glslang/MachineIndependent/intermOut.cpp
@@ -871,6 +871,8 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpAtomicXor:                  out.debug << "AtomicXor";             break;
     case EOpAtomicExchange:             out.debug << "AtomicExchange";        break;
     case EOpAtomicCompSwap:             out.debug << "AtomicCompSwap";        break;
+    case EOpAtomicLoad:                 out.debug << "AtomicLoad";            break;
+    case EOpAtomicStore:                out.debug << "AtomicStore";           break;
 
     case EOpAtomicCounterAdd:           out.debug << "AtomicCounterAdd";      break;
     case EOpAtomicCounterSubtract:      out.debug << "AtomicCounterSubtract"; break;
@@ -894,6 +896,8 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpImageAtomicXor:             out.debug << "imageAtomicXor";        break;
     case EOpImageAtomicExchange:        out.debug << "imageAtomicExchange";   break;
     case EOpImageAtomicCompSwap:        out.debug << "imageAtomicCompSwap";   break;
+    case EOpImageAtomicLoad:            out.debug << "imageAtomicLoad";       break;
+    case EOpImageAtomicStore:           out.debug << "imageAtomicStore";      break;
 #ifdef AMD_EXTENSIONS
     case EOpImageLoadLod:               out.debug << "imageLoadLod";          break;
     case EOpImageStoreLod:              out.debug << "imageStoreLod";         break;

diff --git a/glslang/MachineIndependent/linkValidate.cpp b/glslang/MachineIndependent/linkValidate.cpp
index 5089062..4c89c8b 100644 (file)
--- a/glslang/MachineIndependent/linkValidate.cpp
+++ b/glslang/MachineIndependent/linkValidate.cpp
@@ -524,11 +524,16 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
     }
 
     // Memory...
-    if (symbol.getQualifier().coherent  != unitSymbol.getQualifier().coherent ||
-        symbol.getQualifier().volatil   != unitSymbol.getQualifier().volatil ||
-        symbol.getQualifier().restrict  != unitSymbol.getQualifier().restrict ||
-        symbol.getQualifier().readonly  != unitSymbol.getQualifier().readonly ||
-        symbol.getQualifier().writeonly != unitSymbol.getQualifier().writeonly) {
+    if (symbol.getQualifier().coherent          != unitSymbol.getQualifier().coherent ||
+        symbol.getQualifier().devicecoherent    != unitSymbol.getQualifier().devicecoherent ||
+        symbol.getQualifier().queuefamilycoherent  != unitSymbol.getQualifier().queuefamilycoherent ||
+        symbol.getQualifier().workgroupcoherent != unitSymbol.getQualifier().workgroupcoherent ||
+        symbol.getQualifier().subgroupcoherent  != unitSymbol.getQualifier().subgroupcoherent ||
+        symbol.getQualifier().nonprivate        != unitSymbol.getQualifier().nonprivate ||
+        symbol.getQualifier().volatil           != unitSymbol.getQualifier().volatil ||
+        symbol.getQualifier().restrict          != unitSymbol.getQualifier().restrict ||
+        symbol.getQualifier().readonly          != unitSymbol.getQualifier().readonly ||
+        symbol.getQualifier().writeonly         != unitSymbol.getQualifier().writeonly) {
         error(infoSink, "Memory qualifiers must match:");
         writeTypeComparison = true;
     }

diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h
index e0dab97..e9fe0e4 100644 (file)
--- a/glslang/MachineIndependent/localintermediate.h
+++ b/glslang/MachineIndependent/localintermediate.h
@@ -233,6 +233,7 @@ public:
         useUnknownFormat(false),
         hlslOffsets(false),
         useStorageBuffer(false),
+        useVulkanMemoryModel(false),
         hlslIoMapping(false),
         textureSamplerTransformMode(EShTexSampTransKeep),
         needToLegalize(false),
@@ -365,6 +366,12 @@ public:
             processes.addProcess("hlsl-iomap");
     }
     bool usingHlslIoMapping() { return hlslIoMapping; }
+    void setUseVulkanMemoryModel()
+    {
+        useVulkanMemoryModel = true;
+        processes.addProcess("use-vulkan-memory-model");
+    }
+    bool usingVulkanMemoryModel() const { return useVulkanMemoryModel; }
 
     template<class T> T addCounterBufferName(const T& name) const { return name + implicitCounterName; }
     bool hasCounterBufferName(const TString& name) const {
@@ -734,6 +741,7 @@ protected:
     bool useUnknownFormat;
     bool hlslOffsets;
     bool useStorageBuffer;
+    bool useVulkanMemoryModel;
     bool hlslIoMapping;
 
     std::set<TString> ioAccessed;           // set of names of statically read/written I/O that might need extra checking

diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp
index 786d9ff..060232a 100644 (file)
--- a/gtests/Spv.FromFile.cpp
+++ b/gtests/Spv.FromFile.cpp
@@ -286,6 +286,8 @@ INSTANTIATE_TEST_CASE_P(
         "spv.matrix.frag",
         "spv.matrix2.frag",
         "spv.memoryQualifier.frag",
+        "spv.memoryScopeSemantics.comp",
+        "spv.memoryScopeSemantics_Error.comp",
         "spv.merge-unreachable.frag",
         "spv.multiStruct.comp",
         "spv.multiStructFuncall.frag",

diff --git a/known_good.json b/known_good.json
index e7a83ce..1f89de9 100755 (executable)
--- a/known_good.json
+++ b/known_good.json
@@ -5,14 +5,14 @@
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Tools",
       "subdir" : "External/spirv-tools",
-      "commit" : "6d27a8350fbc339909834a6ef339c805cb1ab69b"
+      "commit" : "7600fc0e19c3a99bd3ef2c24515cc508ca1d3cfb"
     },
     {
       "name" : "spirv-tools/external/spirv-headers",
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Headers",
       "subdir" : "External/spirv-tools/external/spirv-headers",
-      "commit" : "ff684ffc6a35d2a58f0f63108877d0064ea33feb"
+      "commit" : "dcf23bdabacc3c54b83b1f9367e7a8adb27f8d87"
     }
   ]
 }