diff --git a/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h b/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h
index a5c242526..bed1f0704 100644
--- a/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h
+++ b/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h
@@ -44,5 +44,6 @@ static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader";
 static const char* const E_SPV_EXT_float8 = "SPV_EXT_float8";
 static const char* const E_SPV_EXT_shader_64bit_indexing = "SPV_EXT_shader_64bit_indexing";
 static const char* const E_SPV_EXT_shader_invocation_reorder = "SPV_EXT_shader_invocation_reorder";
+static const char* const E_SPV_EXT_long_vector = "SPV_EXT_long_vector";
 
 #endif  // #ifndef GLSLextEXT_H
diff --git a/3rdparty/glslang/SPIRV/GLSL.ext.KHR.h b/3rdparty/glslang/SPIRV/GLSL.ext.KHR.h
index 25dd88ff2..de8896d16 100644
--- a/3rdparty/glslang/SPIRV/GLSL.ext.KHR.h
+++ b/3rdparty/glslang/SPIRV/GLSL.ext.KHR.h
@@ -66,5 +66,6 @@ static const char* const E_SPV_KHR_relaxed_extended_instruction = "SPV_KHR_relax
 static const char* const E_SPV_KHR_integer_dot_product          = "SPV_KHR_integer_dot_product";
 static const char* const E_SPV_NV_cooperative_vector            = "SPV_NV_cooperative_vector";
 static const char* const E_SPV_KHR_bfloat16                     = "SPV_KHR_bfloat16";
-
+static const char* const E_SPV_EXT_descriptor_heap              = "SPV_EXT_descriptor_heap";
+static const char* const E_SPV_KHR_untyped_pointers             = "SPV_KHR_untyped_pointers";
 #endif  // #ifndef GLSLextKHR_H
diff --git a/3rdparty/glslang/SPIRV/GLSL.ext.NV.h b/3rdparty/glslang/SPIRV/GLSL.ext.NV.h
index 4516d2d54..3666cd88a 100644
--- a/3rdparty/glslang/SPIRV/GLSL.ext.NV.h
+++ b/3rdparty/glslang/SPIRV/GLSL.ext.NV.h
@@ -101,4 +101,8 @@ const char* const E_SPV_NV_cluster_acceleration_structure = "SPV_NV_cluster_acce
 
 //SPV_NV_linear_swept_spheres
 const char* const E_SPV_NV_linear_swept_spheres = "SPV_NV_linear_swept_spheres";
+
+//SPV_NV_push_constant_bank
+const char* const E_SPV_NV_push_constant_bank = "SPV_NV_push_constant_bank";
+
 #endif  // #ifndef GLSLextNV_H
diff --git a/3rdparty/glslang/SPIRV/GlslangToSpv.cpp b/3rdparty/glslang/SPIRV/GlslangToSpv.cpp
index 1a5c40c53..ff9c8b04a 100644
--- a/3rdparty/glslang/SPIRV/GlslangToSpv.cpp
+++ b/3rdparty/glslang/SPIRV/GlslangToSpv.cpp
@@ -174,6 +174,8 @@ protected:
     spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
                                           glslang::TLayoutPacking, const glslang::TQualifier&);
     spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType);
+    spv::Id decorateDescHeapType(const glslang::TType& type, spv::Id& memberBaseOffset, spv::Id& alignment,
+                                 int& maxPlainDataAlignment);
     void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,
                             const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);
     spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false, bool boolType = false);
@@ -243,6 +245,7 @@ protected:
     std::pair<spv::Id, spv::Id> getForcedType(glslang::TBuiltInVariable builtIn, const glslang::TType&);
     spv::Id translateForcedType(spv::Id object);
     spv::Id createCompositeConstruct(spv::Id typeId, std::vector<spv::Id> constituents);
+    void recordDescHeapAccessChainInfo(glslang::TIntermBinary* node);
 
     glslang::SpvOptions& options;
     spv::Function* shaderEntry;
@@ -288,6 +291,15 @@ protected:
     // Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData
     std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];
     std::unordered_map<spv::Id, std::vector<spv::Decoration> > idToQCOMDecorations;
+    // For nested or inner resource heap structure's alignment and offset records.
+    typedef struct heapMetaData {
+        spv::Id typeStride;
+        spv::Id maxRsrcTypeAlignment;
+        int maxPlainDataAlignment;
+    } HeapMetaData;
+    std::unordered_map<const glslang::TType*, HeapMetaData> heapStructureTypeMetaData;
+    std::unordered_map<spv::Id, spv::Id> heapStructureTypeSize;
+    std::vector<spv::Id> heapStructureMemberOffsets;
 };
 
 //
@@ -391,6 +403,8 @@ spv::Decoration TranslateBlockDecoration(const glslang::TStorageQualifier storag
     case glslang::EvqCallableDataIn: return spv::Decoration::Block;
     case glslang::EvqHitObjectAttrNV: return spv::Decoration::Block;
     case glslang::EvqHitObjectAttrEXT: return spv::Decoration::Block;
+    case glslang::EvqResourceHeap:  return spv::Decoration::Block;
+    case glslang::EvqSamplerHeap:   return spv::Decoration::Block;
     default:
         assert(0);
         break;
@@ -467,6 +481,8 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T
             case glslang::EvqCallableDataIn:
             case glslang::EvqHitObjectAttrNV:
             case glslang::EvqHitObjectAttrEXT:
+            case glslang::EvqResourceHeap:
+            case glslang::EvqSamplerHeap:
                 return spv::Decoration::Max;
             default:
                 assert(0);
@@ -1160,6 +1176,38 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
         builder.addExtension(spv::E_SPV_QCOM_tile_shading);
         return spv::BuiltIn::TileApronSizeQCOM;
 
+    // SPV_EXT_descriptor_heap
+    case glslang::EbvSamplerHeapEXT:
+        builder.addExtension(spv::E_SPV_EXT_descriptor_heap);
+        builder.addExtension(spv::E_SPV_KHR_untyped_pointers);
+        builder.addCapability(spv::Capability::DescriptorHeapEXT);
+        builder.addCapability(spv::Capability::UntypedPointersKHR);
+        // Add SamplerHeapEXT Symbol for spv level.
+        if (builtInVariableIds.find(uint32_t(spv::BuiltIn::SamplerHeapEXT)) == builtInVariableIds.end()) {
+            spv::Id samplerHeapEXT =
+                builder.createUntypedVariable(spv::NoPrecision, spv::StorageClass::UniformConstant, "sampler_heap");
+            if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4)
+                entryPoint->addIdOperand(samplerHeapEXT);
+            builder.addDecoration(samplerHeapEXT, spv::Decoration::BuiltIn, (int)spv::BuiltIn::SamplerHeapEXT);
+            builtInVariableIds.insert({uint32_t(spv::BuiltIn::SamplerHeapEXT), samplerHeapEXT});
+        }
+        return spv::BuiltIn::SamplerHeapEXT;
+    case glslang::EbvResourceHeapEXT:
+        builder.addExtension(spv::E_SPV_EXT_descriptor_heap);
+        builder.addExtension(spv::E_SPV_KHR_untyped_pointers);
+        builder.addCapability(spv::Capability::DescriptorHeapEXT);
+        builder.addCapability(spv::Capability::UntypedPointersKHR);
+        // Add ResourceHeapEXT Symbol for spv level.
+        if (builtInVariableIds.find(uint32_t(spv::BuiltIn::ResourceHeapEXT)) == builtInVariableIds.end()) {
+            spv::Id resourceHeapEXT =
+                builder.createUntypedVariable(spv::NoPrecision, spv::StorageClass::UniformConstant, "resource_heap");
+            if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4)
+                entryPoint->addIdOperand(resourceHeapEXT);
+            builder.addDecoration(resourceHeapEXT, spv::Decoration::BuiltIn, (int)spv::BuiltIn::ResourceHeapEXT);
+            builtInVariableIds.insert({uint32_t(spv::BuiltIn::ResourceHeapEXT), resourceHeapEXT});
+        }
+        return spv::BuiltIn::ResourceHeapEXT;
+
     default:
         return spv::BuiltIn::Max;
     }
@@ -1352,8 +1400,13 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
             type.getQualifier().storage == glslang::EvqUniform) {
         if (type.isAtomic())
             return spv::StorageClass::AtomicCounter;
-        if (type.containsOpaque() && !glslangIntermediate->getBindlessMode())
-            return spv::StorageClass::UniformConstant;
+        if (type.containsOpaque() && !glslangIntermediate->getBindlessMode()) {
+            if (type.getQualifier().storage == glslang::EvqResourceHeap ||
+                type.getQualifier().storage == glslang::EvqSamplerHeap)
+                return spv::StorageClass::Uniform;
+            else
+                return spv::StorageClass::UniformConstant;
+        }
     }
 
     if (type.getQualifier().isUniformOrBuffer() &&
@@ -1369,7 +1422,8 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
     if (type.getQualifier().isUniformOrBuffer()) {
         if (type.getQualifier().isPushConstant())
             return spv::StorageClass::PushConstant;
-        if (type.getBasicType() == glslang::EbtBlock)
+        if (type.getBasicType() == glslang::EbtBlock ||
+            type.getQualifier().layoutDescriptorHeap)
             return spv::StorageClass::Uniform;
         return spv::StorageClass::UniformConstant;
     }
@@ -2207,7 +2261,7 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
         // C) R-Values from type translation, see above call to translateForcedType()
         glslang::TQualifier qualifier = symbol->getQualifier();
         if (qualifier.isSpecConstant() || rValueParameters.find(symbol->getId()) != rValueParameters.end() ||
-            !builder.isPointerType(builder.getTypeId(id)))
+            (!builder.isPointerType(builder.getTypeId(id)) && !builder.isUntypedPointer(id)))
             builder.setAccessChainRValue(id);
         else
             builder.setAccessChainLValue(id);
@@ -2248,6 +2302,28 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
 #endif
 }
 
+// Create new untyped access chain instruction to descriptor heap, based on EXT_descriptor_heap extension.
+void TGlslangToSpvTraverser::recordDescHeapAccessChainInfo(glslang::TIntermBinary* node)
+{
+    // EXT_descriptor_heap
+    glslang::TType* nodeTy = node->getWritableType().clone();
+    // For buffer/structure type, using its basic structure type:
+    // data ptr will be first loaded into a BufferPointerType before finally gets chained accessed.
+    if (node->getLeft()->getQualifier().isUniformOrBuffer())
+        nodeTy = node->getLeft()->getType().clone();
+    if (nodeTy->isArray())
+        nodeTy->clearArraySizes();
+    spv::BuiltIn bt = spv::BuiltIn::Max;
+    unsigned int firstArrIndex = 0;
+    auto rsrcOffsetIdx = builder.isStructureHeapMember(builder.getTypeId(builder.getAccessChain().base),
+                                                       builder.getAccessChain().indexChain, 0, &bt, &firstArrIndex);
+    spv::Id remappedBuiltin = bt == spv::BuiltIn::Max ? 0 : builtInVariableIds[unsigned(bt)];
+    nodeTy->getQualifier().layoutDescriptorInnerBlock = false;
+    // Extra dimension is not needed when translate storage and type. Real loading type is based on orignal AST nodes.
+    builder.setAccessChainDescHeapInfo(TranslateStorageClass(*nodeTy), convertGlslangToSpvType(*nodeTy),
+          nodeTy->getQualifier().layoutDescriptorStride, rsrcOffsetIdx, remappedBuiltin, firstArrIndex);
+}
+
 bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::TIntermBinary* node)
 {
     builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
@@ -2402,6 +2478,14 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
                 // We have deferred generation of associated capabilities until now.
                 if (node->getLeft()->getType().isStruct() && ! node->getLeft()->getType().isArray())
                     declareUseOfStructMember(*(node->getLeft()->getType().getStruct()), glslangIndex);
+
+                // EXT_descriptor_heap
+                // Record untyped descriptor heap access info.
+                if (node->getLeft()->getType().isBuiltIn() &&
+                    (node->getLeft()->getQualifier().builtIn == glslang::EbvResourceHeapEXT ||
+                     node->getLeft()->getQualifier().builtIn == glslang::EbvSamplerHeapEXT)) {
+                    recordDescHeapAccessChainInfo(node);
+                }
             }
         }
         return false;
@@ -2459,6 +2543,14 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
                 builder.accessChainPush(index, coherent_flags,
                                         node->getLeft()->getType().getBufferReferenceAlignment());
             }
+
+            // EXT_descriptor_heap
+            // Record untyped descriptor heap access info.
+            if (node->getLeft()->getType().isBuiltIn() &&
+                (node->getLeft()->getQualifier().builtIn == glslang::EbvResourceHeapEXT ||
+                 node->getLeft()->getQualifier().builtIn == glslang::EbvSamplerHeapEXT)) {
+                recordDescHeapAccessChainInfo(node);
+            }
         }
         return false;
     case glslang::EOpVectorSwizzle:
@@ -2698,9 +2790,13 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
                 spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
                 length = builder.createCooperativeMatrixLengthNV(typeId);
             }
-        } else if (node->getOperand()->getType().isCoopVecNV()) {
+        } else if (node->getOperand()->getType().isCoopVecOrLongVector()) {
             spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
-            length = builder.getCooperativeVectorNumComponents(typeId);
+            if (builder.isCooperativeVectorType(typeId)) {
+                length = builder.getCooperativeVectorNumComponents(typeId);
+            } else {
+                length = builder.makeIntConstant(builder.getNumTypeConstituents(typeId));
+            }
         } else {
             glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
             block->traverse(this);
@@ -3351,7 +3447,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             builder.addCapability(spv::Capability::CooperativeMatrixConversionsNV);
             builder.addExtension(spv::E_SPV_NV_cooperative_matrix2);
             constructed = builder.createCooperativeMatrixConversion(resultType(), arguments[0]);
-        } else if (node->getOp() == glslang::EOpConstructCooperativeVectorNV &&
+        } else if (node->getType().isCoopVecOrLongVector() &&
                    arguments.size() == 1 &&
                    builder.getTypeId(arguments[0]) == resultType()) {
             constructed = arguments[0];
@@ -3361,7 +3457,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                  node->getType().isArray() ||
                  // Handle constructing coopvec from one component here, to avoid the component
                  // getting smeared
-                 (node->getOp() == glslang::EOpConstructCooperativeVectorNV && arguments.size() == 1 && builder.isScalar(arguments[0]))) {
+                 (node->getType().hasSpecConstantVectorComponents() && arguments.size() == 1 && builder.isScalar(arguments[0]))) {
             std::vector<spv::Id> constituents;
             for (int c = 0; c < (int)arguments.size(); ++c)
                 constituents.push_back(arguments[c]);
@@ -3423,7 +3519,8 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     {
         // for scalar dot product, use multiply
         glslang::TIntermSequence& glslangOperands = node->getSequence();
-        if (glslangOperands[0]->getAsTyped()->getVectorSize() == 1)
+        if (!glslangOperands[0]->getAsTyped()->getType().isLongVector() &&
+            glslangOperands[0]->getAsTyped()->getVectorSize() == 1)
             binOp = glslang::EOpMul;
         break;
     }
@@ -5430,6 +5527,14 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
     case glslang::EbtStruct:
     case glslang::EbtBlock:
         {
+            // If it's an inner declared heap buffer or uniform block, using OpTypeBufferEXT
+            // to convert it to an untyped type.
+            if (type.getQualifier().isUniformOrBuffer() &&
+                type.getQualifier().layoutDescriptorHeap && type.getQualifier().layoutDescriptorInnerBlock) {
+                spvType = builder.makeUntypedPointer(TranslateStorageClass(type), true);
+                break;
+            }
+
             // If we've seen this struct type, return it
             const glslang::TTypeList* glslangMembers = type.getStruct();
 
@@ -5647,6 +5752,24 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
         spvType = builder.makeCooperativeVectorTypeNV(spvType, components);
     }
 
+    if (type.isLongVector()) {
+        builder.addCapability(spv::Capability::LongVectorEXT);
+        builder.addExtension(spv::E_SPV_EXT_long_vector);
+
+        if (type.getBasicType() == glslang::EbtFloat16)
+            builder.addCapability(spv::Capability::Float16);
+        if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) {
+            builder.addCapability(spv::Capability::Int8);
+        }
+
+        if (type.hasSpecConstantVectorComponents()) {
+            spv::Id components = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0);
+            spvType = builder.makeCooperativeVectorTypeNV(spvType, components);
+        } else {
+            spvType = builder.makeVectorType(spvType, type.getTypeParameters()->arraySizes->getDimSize(0));
+        }
+    }
+
     if (type.isArray()) {
         int stride = 0;  // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride
 
@@ -5680,9 +5803,15 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
                 stride = getArrayStride(type, explicitLayout, qualifier.layoutMatrix);
         }
 
+        if (type.getQualifier().storage == glslang::EvqResourceHeap ||
+            type.getQualifier().storage == glslang::EvqSamplerHeap) {
+            auto structSize = heapStructureTypeSize[spvType];
+            spvType = builder.makeRuntimeArray(spvType);
+            builder.addDecorationId(spvType, spv::Decoration::ArrayStrideIdEXT, structSize);
+        }
         // Do the outer dimension, which might not be known for a runtime-sized array.
         // (Unsized arrays that survive through linking will be runtime-sized arrays)
-        if (type.isSizedArray())
+        else if (type.isSizedArray())
             spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), 0), stride);
         else {
             // If we see an runtime array in a buffer_reference, it is not a descriptor
@@ -5888,11 +6017,41 @@ spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TTy
         }
     }
 
+    // For those whose storage is ResourceHeap or SamplerHeap, we needs to recursively add
+    // member decorator for inner structure member declaration with spec Constant.
+    spv::Id heapStructSize = 0;
+    if (qualifier.storage == glslang::EvqResourceHeap || qualifier.storage == glslang::EvqSamplerHeap ||
+        qualifier.layoutDescriptorInnerBlock) {
+        auto memberBaseOffset = builder.makeUintConstant(0);
+        int maxPlainDataTypeAlignment = 0;
+        spv::Id descTypeMaxAlignment = 0;
+        auto structLastMemberSize =
+            decorateDescHeapType(type, memberBaseOffset, descTypeMaxAlignment, maxPlainDataTypeAlignment);
+        auto structureUnaligned = builder.createSpecConstantOp(
+            spv::Op::OpIAdd, builder.makeUintType(32), {memberBaseOffset, structLastMemberSize}, {});
+        auto structurePadding = builder.createSpecConstantOp(
+            spv::Op::OpUMod, builder.makeUintType(32), {descTypeMaxAlignment, structureUnaligned}, {});
+        heapStructSize = builder.createSpecConstantOp(
+            spv::Op::OpIAdd, builder.makeUintType(32), {structureUnaligned, structurePadding}, {});
+        HeapMetaData meta = {heapStructSize, descTypeMaxAlignment, maxPlainDataTypeAlignment};
+        heapStructureTypeMetaData[&type] = meta;
+    }
+
     // Make the SPIR-V type
     spv::Id spvType = builder.makeStructType(spvMembers, memberDebugInfo, type.getTypeName().c_str(), false);
     if (! HasNonLayoutQualifiers(type, qualifier))
         structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
 
+    // Keep decoration data order after spv structure type.
+    if (qualifier.storage == glslang::EvqResourceHeap || qualifier.storage == glslang::EvqSamplerHeap ||
+        qualifier.layoutDescriptorInnerBlock) {
+        heapStructureTypeSize[spvType] = heapStructSize;
+        for (unsigned int i = 0; i < spvMembers.size(); i++) {
+            builder.addMemberDecorationIdEXT(spvType, i, spv::Decoration::OffsetIdEXT, {heapStructureMemberOffsets[i]});
+        }
+        heapStructureMemberOffsets.clear();
+    }
+
     // Decorate it
     decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType, spvMembers);
 
@@ -5904,6 +6063,126 @@ spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TTy
     return spvType;
 }
 
+// Return not aligned size of current type.
+spv::Id TGlslangToSpvTraverser::decorateDescHeapType(
+    const glslang::TType& type,
+    spv::Id &memberBaseOffset,
+    spv::Id &descTypeAlignment,
+    int& maxPlainDataAlignment)
+{
+    glslang::TLayoutPacking explicitLayout = glslang::ElpScalar;
+    auto selectMaxRsrcTyAlign = [&](spv::Id typeSize) {
+        if (descTypeAlignment != 0) {
+            auto compareInst = builder.createSpecConstantOp(spv::Op::OpUGreaterThan, builder.makeBoolType(),
+                                                            {descTypeAlignment, typeSize}, {});
+            auto selectMaxAlign = builder.createSpecConstantOp(spv::Op::OpSelect, builder.makeUintType(32),
+                                                               {compareInst, descTypeAlignment, typeSize}, {});
+            descTypeAlignment = selectMaxAlign;
+        } else
+            descTypeAlignment = typeSize;
+    };
+
+    // Get or calculate following info ordered.
+    //  Member Type | Type size | Type alignment within current structure | Type offset.
+    // PS. resource blocks declared within a structure will not be processed as a normal declaration before,
+    //  and its' size is dependent on constantSizeOfEXT op, so we won't trigger it as a normal structure here.
+    bool isArray = type.isArray();
+    if (type.isStruct() && !type.getQualifier().layoutDescriptorInnerBlock) {
+        // 1. Structure type is processed from inner to higher level.
+        //    If member is a sturcture, it will be processed earlier,
+        //    parent structure could just load early results.
+        if (heapStructureTypeMetaData.find(&type) != heapStructureTypeMetaData.end()) {
+            auto metadata = heapStructureTypeMetaData[&type];
+            selectMaxRsrcTyAlign(metadata.maxRsrcTypeAlignment);
+            maxPlainDataAlignment = std::max(metadata.maxPlainDataAlignment, maxPlainDataAlignment);
+            return metadata.typeStride;
+        }
+        //  For other nested structure, it would be declared before its parent,
+        //  so it should be directly returned a result in above check.
+        const glslang::TTypeList* structTyList = type.getStruct();
+        spv::Id previousTypeSize = 0;
+        auto currentOffset = memberBaseOffset;
+        for (int i = 0; i < (int)structTyList->size(); i++) {
+            // Get offset :
+            // OffsetsBase = default ? 0 : OffsetInLayout;
+            // OffsetsBase = OffsetsBase + previousOffset + previousPadding.
+            const glslang::TType& memberTy = *(*structTyList)[i].type;
+            spv::Id typeSize = decorateDescHeapType(memberTy, currentOffset, descTypeAlignment, maxPlainDataAlignment);
+            // 2. Get each member's unaligned offset, padding and aligned offset.
+            //    As this function is processed recursively, from bottom to upper, so in here,
+            //    non-structure member's alignment should have been known.
+            if (i != 0) {
+                auto offsetNotAligned = builder.createSpecConstantOp(spv::Op::OpIAdd, builder.makeUintType(32),
+                                                                     {currentOffset, previousTypeSize}, {});
+                auto offsetPadding = builder.createSpecConstantOp(spv::Op::OpUMod, builder.makeUintType(32),
+                                                                  {typeSize, offsetNotAligned}, {});
+                currentOffset = builder.createSpecConstantOp(spv::Op::OpIAdd, builder.makeUintType(32),
+                                                             {offsetNotAligned, offsetPadding}, {});
+            }
+            heapStructureMemberOffsets.push_back(currentOffset);
+            previousTypeSize = typeSize;
+        }
+        // 3. Structure level, get max resource type's alignment, max plain data alignment and final
+        //    structure inner alignment.
+        // Get compared result for alignment within whole structure.
+        spv::Id maxPlainAlignmentSize = builder.makeIntConstant(maxPlainDataAlignment);
+
+        // Select biggest alignemnt size between desc types and plain old types.
+        selectMaxRsrcTyAlign(maxPlainAlignmentSize);
+        memberBaseOffset = currentOffset;
+
+        // Now, return generates size of the MaterialData type
+        // Get structure level unaligned offset, padding and final offset outside.
+        return previousTypeSize;
+    }
+
+    // Following are normal types, structures/blocks have been processed in above part.
+    // Normal type or member type within a structure.
+    bool useConstantSizeOf =
+        ((type.getQualifier().isUniformOrBuffer() && type.getQualifier().layoutDescriptorHeap) ||
+         type.isImage() || type.isTexture() || type.isTensorARM() || type.getBasicType() == glslang::EbtAccStruct);
+
+    // Get single type and layout info.
+    int elemCurrentOffset, elemAlignedSize;
+    int memberSize, dummyStride, typeAlignment;
+    spv::Id spvType = 0; 
+    if (isArray) {
+        glslang::TType elemTy(type, 0);
+        elemTy.clearArraySizes();
+        if (!useConstantSizeOf) {
+            typeAlignment = glslangIntermediate->getMemberAlignment(
+                elemTy, memberSize, dummyStride, glslang::ElpScalar, elemTy.getQualifier().layoutMatrix == glslang::ElmRowMajor);
+            updateMemberOffset(elemTy, elemTy, elemCurrentOffset, elemAlignedSize, explicitLayout, elemTy.getQualifier().layoutMatrix);
+            elemAlignedSize *= type.getCumulativeArraySize();
+        }
+        spvType = convertGlslangToSpvType(elemTy);
+    } else {
+        if (!useConstantSizeOf) {
+            typeAlignment = glslangIntermediate->getMemberAlignment(
+                type, memberSize, dummyStride, glslang::ElpScalar, type.getQualifier().layoutMatrix == glslang::ElmRowMajor);
+            updateMemberOffset(type, type, elemCurrentOffset, elemAlignedSize, explicitLayout, type.getQualifier().layoutMatrix);
+        }
+        spvType = convertGlslangToSpvType(type);
+    }
+
+    // Get alignment and type size.
+    spv::Id typeSize = 0;
+    if (useConstantSizeOf) {
+        typeSize = builder.createConstantSizeOfEXT(spvType);
+        // For resource type, needs to check current's largest alignment to select.
+        // New parent structure's alignment is equal to:
+        //     maxInnerAlignment = currentAlignment > maxInnerAlignment
+        //                                            ? currentAlignment
+        //                                            : maxInnerAlignment;
+        selectMaxRsrcTyAlign(typeSize);
+    } else {
+        typeSize = builder.makeIntConstant(elemAlignedSize);
+        maxPlainDataAlignment = std::max(typeAlignment, maxPlainDataAlignment);
+    }
+
+    return typeSize;
+}
+
 void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
                                                 const glslang::TTypeList* glslangMembers,
                                                 glslang::TLayoutPacking explicitLayout,
@@ -5972,7 +6251,12 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
         if (glslangMember.getQualifier().hasXfbOffset())
             builder.addMemberDecoration(spvType, member, spv::Decoration::Offset,
                                         glslangMember.getQualifier().layoutXfbOffset);
-        else if (explicitLayout != glslang::ElpNone) {
+        else if (glslangMember.getQualifier().hasMemberOffset()) {
+            builder.addExtension(spv::E_SPV_NV_push_constant_bank);
+            builder.addCapability(spv::Capability::PushConstantBanksNV);
+            builder.addMemberDecoration(spvType, member, spv::Decoration::MemberOffsetNV,
+                                        glslangMember.getQualifier().layoutMemberOffset);
+        } else if (explicitLayout != glslang::ElpNone) {
             // figure out what to do with offset, which is accumulating
             int nextOffset;
             updateMemberOffset(type, glslangMember, offset, nextOffset, explicitLayout, memberQualifier.layoutMatrix);
@@ -5987,7 +6271,9 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
 
         // built-in variable decorations
         spv::BuiltIn builtIn = TranslateBuiltInDecoration(glslangMember.getQualifier().builtIn, true);
-        if (builtIn != spv::BuiltIn::Max)
+        // built-in decoration is used to detect AST nodes, but won't be decorated on member variables.
+        if (builtIn != spv::BuiltIn::Max &&
+            builtIn != spv::BuiltIn::ResourceHeapEXT && builtIn != spv::BuiltIn::SamplerHeapEXT)
             builder.addMemberDecoration(spvType, member, spv::Decoration::BuiltIn, (int)builtIn);
 
         // nonuniform
@@ -6040,6 +6326,13 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
 
     if (qualifier.hasHitObjectShaderRecordNV())
         builder.addDecoration(spvType, spv::Decoration::HitObjectShaderRecordBufferNV);
+
+    if (qualifier.hasBank()) {
+        builder.addExtension(spv::E_SPV_NV_push_constant_bank);
+        builder.addCapability(spv::Capability::PushConstantBanksNV);
+        builder.addDecoration(spvType, spv::Decoration::BankNV, qualifier.layoutBank);
+    }
+  
     if (qualifier.hasHitObjectShaderRecordEXT())
         builder.addDecoration(spvType, spv::Decoration::HitObjectShaderRecordBufferEXT);
 }
@@ -6111,6 +6404,12 @@ spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
         loadedId = convertLoadedBoolInUniformToUint(type, nominalTypeId, loadedId);
     }
 
+    if (!builder.getAccessChain().descHeapInfo.descHeapInstId.empty()) {
+        for (auto heapInst : builder.getAccessChain().descHeapInfo.descHeapInstId)
+            heapInst->setTypeId(convertGlslangToSpvType(type));
+        builder.clearAccessChain();
+    }
+
     return loadedId;
 }
 
@@ -7082,7 +7381,18 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
             } else {
                 resultTypeId = builder.makePointer(spv::StorageClass::Image, resultType());
             }
-            spv::Id pointer = builder.createOp(spv::Op::OpImageTexelPointer, resultTypeId, operands);
+
+            // EXT_descriptor_heap
+            // For image atomic parameter, using untyped image texel pointer to carry on type metadata.
+            spv::Op imgTexelOp = spv::Op::OpImageTexelPointer;
+            if (node->getQualifier().isUsedByAtomic() &&
+                imageType.getQualifier().builtIn == glslang::EbvResourceHeapEXT) {
+                operands.insert(operands.begin(), {true, convertGlslangToSpvType(imageType)});
+                imgTexelOp = spv::Op::OpUntypedImageTexelPointerEXT;
+                resultTypeId = builder.makeUntypedPointer(spv::StorageClass::Image);
+            }
+
+            spv::Id pointer = builder.createOp(imgTexelOp, resultTypeId, operands);
             if (imageType.getQualifier().nonUniform) {
                 builder.addDecoration(pointer, spv::Decoration::NonUniformEXT);
             }
@@ -9843,9 +10153,12 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
                 builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
             if (builder.getNumComponents(operands[0]) == 1)
                 frexpIntType = builder.makeIntegerType(width, true);
+            else if (builder.isCooperativeVector(operands[0]))
+                frexpIntType = builder.makeCooperativeVectorTypeNV(builder.makeIntegerType(width, true),
+                                                                   builder.getCooperativeVectorNumComponents(builder.getTypeId(operands[0])));
             else
                 frexpIntType = builder.makeVectorType(builder.makeIntegerType(width, true),
-                    builder.getNumComponents(operands[0]));
+                                                      builder.getNumComponents(operands[0]));
             typeId = builder.makeStructResultType(typeId0, frexpIntType);
             consumedOperands = 1;
         }
@@ -10755,7 +11068,11 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
         builtIn == spv::BuiltIn::ObjectToWorldKHR ||
         builtIn == spv::BuiltIn::WorldToObjectKHR;
 
-    if (mayNeedToReuseBuiltIn) {
+    // EXT_descriptor_heap
+    const bool needToRemapDescHeap =
+        builtIn == spv::BuiltIn::ResourceHeapEXT || builtIn == spv::BuiltIn::SamplerHeapEXT;
+
+    if (mayNeedToReuseBuiltIn || needToRemapDescHeap) {
         auto iter = builtInVariableIds.find(uint32_t(builtIn));
         if (builtInVariableIds.end() != iter) {
             id = iter->second;
@@ -10929,6 +11246,18 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
     if (symbol->getType().getQualifier().hasSpirvDecorate())
         applySpirvDecorate(symbol->getType(), id, {});
 
+    if (symbol->getQualifier().hasBank()) {
+        builder.addExtension(spv::E_SPV_NV_push_constant_bank);
+        builder.addCapability(spv::Capability::PushConstantBanksNV);
+        builder.addDecoration(id, spv::Decoration::BankNV, symbol->getQualifier().layoutBank);
+    }
+
+    if (symbol->getQualifier().hasMemberOffset()) {
+        builder.addExtension(spv::E_SPV_NV_push_constant_bank);
+        builder.addCapability(spv::Capability::PushConstantBanksNV);
+        builder.addDecoration(id, spv::Decoration::MemberOffsetNV, symbol->getQualifier().layoutMemberOffset);
+    }
+
     return id;
 }
 
@@ -11149,8 +11478,8 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla
         glslang::TVector<glslang::TTypeLoc>::const_iterator iter;
         for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter)
             spvConsts.push_back(createSpvConstantFromConstUnionArray(*iter->type, consts, nextConst, false));
-    } else if (glslangType.getVectorSize() > 1 || glslangType.isCoopVecNV()) {
-        unsigned int numComponents = glslangType.isCoopVecNV() ? glslangType.getTypeParameters()->arraySizes->getDimSize(0) : glslangType.getVectorSize();
+    } else if (glslangType.getVectorSize() > 1 || glslangType.isCoopVecOrLongVector()) {
+        unsigned int numComponents = glslangType.isCoopVecOrLongVector() ? glslangType.getTypeParameters()->arraySizes->getDimSize(0) : glslangType.getVectorSize();
         for (unsigned int i = 0; i < numComponents; ++i) {
             bool zero = nextConst >= consts.size();
             switch (glslangType.getBasicType()) {
diff --git a/3rdparty/glslang/SPIRV/SpvBuilder.cpp b/3rdparty/glslang/SPIRV/SpvBuilder.cpp
index 993eda520..52e484c26 100644
--- a/3rdparty/glslang/SPIRV/SpvBuilder.cpp
+++ b/3rdparty/glslang/SPIRV/SpvBuilder.cpp
@@ -190,6 +190,27 @@ Id Builder::makeForwardPointer(StorageClass storageClass)
     return type->getResultId();
 }
 
+Id Builder::makeUntypedPointer(StorageClass storageClass, bool setBufferPointer)
+{
+    // try to find it
+    Instruction* type;
+    // both typeBufferEXT and UntypedPointer only contains storage class info.
+    spv::Op typeOp = setBufferPointer ? Op::OpTypeBufferEXT : Op::OpTypeUntypedPointerKHR;
+    for (int t = 0; t < (int)groupedTypes[enumCast(typeOp)].size(); ++t) {
+        type = groupedTypes[enumCast(typeOp)][t];
+        if (type->getImmediateOperand(0) == (unsigned)storageClass)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), NoType, typeOp);
+    type->addImmediateOperand(storageClass);
+    groupedTypes[enumCast(typeOp)].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+    return type->getResultId();
+}
+
 Id Builder::makePointerFromForwardPointer(StorageClass storageClass, Id forwardPointerType, Id pointee)
 {
     // try to find it
@@ -1767,6 +1788,7 @@ bool Builder::isConstantOpCode(Op opcode) const
     case Op::OpSpecConstantComposite:
     case Op::OpSpecConstantCompositeReplicateEXT:
     case Op::OpSpecConstantOp:
+    case Op::OpConstantSizeOfEXT:
         return true;
     default:
         return false;
@@ -2429,6 +2451,23 @@ void Builder::addDecorationId(Id id, Decoration decoration, const std::vector<Id
     decorations.insert(std::unique_ptr<Instruction>(dec));
 }
 
+void Builder::addMemberDecorationIdEXT(Id id, unsigned int member, Decoration decoration,
+                                       const std::vector<unsigned>& operands)
+{
+    if (decoration == spv::Decoration::Max)
+        return;
+
+    Instruction* dec = new Instruction(Op::OpMemberDecorateIdEXT);
+    dec->reserveOperands(operands.size() + 3);
+    dec->addIdOperand(id);
+    dec->addImmediateOperand(member);
+    dec->addImmediateOperand(decoration);
+    for (auto operand : operands)
+        dec->addIdOperand(operand);
+
+    decorations.insert(std::unique_ptr<Instruction>(dec));
+}
+
 void Builder::addMemberDecoration(Id id, unsigned int member, Decoration decoration, int num)
 {
     if (decoration == spv::Decoration::Max)
@@ -2844,6 +2883,38 @@ void Builder::createConstVariable(Id type, const char* name, Id constant, bool i
     }
 }
 
+// Comments in header
+Id Builder::createUntypedVariable(Decoration precision, StorageClass storageClass, const char* name, Id dataType,
+                                  Id initializer)
+{
+    Id resultUntypedPointerType = makeUntypedPointer(storageClass);
+    Instruction* inst = new Instruction(getUniqueId(), resultUntypedPointerType, Op::OpUntypedVariableKHR);
+    inst->addImmediateOperand(storageClass);
+    if (dataType != NoResult) {
+        Id dataPointerType = makePointer(storageClass, dataType);
+        inst->addIdOperand(dataPointerType);
+    }
+    if (initializer != NoResult)
+        inst->addIdOperand(initializer);
+
+    switch (storageClass) {
+    case StorageClass::Function:
+        // Validation rules require the declaration in the entry block
+        buildPoint->getParent().addLocalVariable(std::unique_ptr<Instruction>(inst));
+        break;
+    default:
+        constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+        module.mapInstruction(inst);
+        break;
+    }
+
+    if (name)
+        addName(inst->getResultId(), name);
+    setPrecision(inst->getResultId(), precision);
+
+    return inst->getResultId();
+}
+
 // Comments in header
 Id Builder::createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name, Id initializer,
     bool const compilerGenerated)
@@ -2916,9 +2987,14 @@ spv::MemoryAccessMask Builder::sanitizeMemoryAccessForStorageClass(spv::MemoryAc
 void Builder::createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess, spv::Scope scope,
     unsigned int alignment)
 {
-    Instruction* store = new Instruction(Op::OpStore);
-    store->reserveOperands(2);
-    store->addIdOperand(lValue);
+    Instruction* store = nullptr;
+    if (isUntypedPointer(lValue))
+        store = createDescHeapLoadStoreBaseRemap(lValue, Op::OpStore);
+    else {
+        store = new Instruction(Op::OpStore);
+        store->reserveOperands(2);
+        store->addIdOperand(lValue);
+    }
     store->addIdOperand(rValue);
 
     memoryAccess = sanitizeMemoryAccessForStorageClass(memoryAccess, getStorageClass(lValue));
@@ -2940,8 +3016,13 @@ void Builder::createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAcce
 Id Builder::createLoad(Id lValue, spv::Decoration precision, spv::MemoryAccessMask memoryAccess,
     spv::Scope scope, unsigned int alignment)
 {
-    Instruction* load = new Instruction(getUniqueId(), getDerefTypeId(lValue), Op::OpLoad);
-    load->addIdOperand(lValue);
+    Instruction* load = nullptr;
+    if (isUntypedPointer(lValue))
+        load = createDescHeapLoadStoreBaseRemap(lValue, Op::OpLoad);
+    else {
+        load = new Instruction(getUniqueId(), getDerefTypeId(lValue), Op::OpLoad);
+        load->addIdOperand(lValue);
+    }
 
     memoryAccess = sanitizeMemoryAccessForStorageClass(memoryAccess, getStorageClass(lValue));
 
@@ -2961,6 +3042,172 @@ Id Builder::createLoad(Id lValue, spv::Decoration precision, spv::MemoryAccessMa
     return load->getResultId();
 }
 
+Instruction* Builder::createDescHeapLoadStoreBaseRemap(Id baseId, Op op)
+{
+    // could only be untypedAccessChain or BufferPointerEXT op.
+    spv::Op instOp = module.getInstruction(baseId)->getOpCode();
+    spv::Id baseVal = baseId;
+    // base type (from run time array)
+    spv::Id resultTy = getIdOperand(baseId, 0);
+    // Descriptor heap using run time array.
+    if (accessChain.descHeapInfo.descHeapStorageClass != StorageClass::Max)
+        resultTy = getIdOperand(resultTy, 0);
+    if (instOp == Op::OpBufferPointerEXT) {
+        // get base structure type from run time array of buffer structure type.
+        // create an extra untyped access chain for buffer pointer.
+        resultTy = accessChain.descHeapInfo.descHeapBaseTy;
+        Instruction* chain = new Instruction(getUniqueId(), getTypeId(baseId), Op::OpUntypedAccessChainKHR);
+        // base type.
+        chain->addIdOperand(resultTy);
+        // base
+        chain->addIdOperand(baseId);
+        // index
+        for (int i = 0; i < (int)accessChain.indexChain.size(); ++i) {
+            chain->addIdOperand(accessChain.indexChain[i]);
+        }
+        addInstruction(std::unique_ptr<Instruction>(chain));
+        baseVal = chain->getResultId();
+        clearAccessChain();
+    } else if (instOp != Op::OpUntypedAccessChainKHR) {
+        assert("Not a untyped load type");
+    }
+
+    Instruction* inst = nullptr;
+    if (op == Op::OpStore)
+        inst = new Instruction(Op::OpStore);
+    else {
+        inst = new Instruction(getUniqueId(), resultTy, Op::OpLoad);
+        accessChain.descHeapInfo.descHeapInstId.push_back(inst);
+    }
+    inst->addIdOperand(baseVal);
+    return inst;
+}
+
+uint32_t Builder::isStructureHeapMember(Id id, std::vector<Id> indexChain,
+    unsigned int idx, spv::BuiltIn* bt, uint32_t* firstArrIndex)
+{
+    unsigned currentIdx = idx;
+    // Process types, only array types could contain no constant id operands.
+    Id baseId = id;
+    if (baseId == NoType)
+        return 0;
+    if (isPointerType(baseId))
+        baseId = getContainedTypeId(baseId);
+    auto baseInst = module.getInstruction(baseId);
+    if (baseInst->getOpCode() == spv::Op::OpTypeArray ||
+        baseInst->getOpCode() == spv::Op::OpTypeRuntimeArray) {
+        if (firstArrIndex)
+            *firstArrIndex = currentIdx;
+        baseId = getContainedTypeId(baseId);
+        baseInst = module.getInstruction(baseId);
+        currentIdx++;
+    }
+    if (currentIdx >= indexChain.size())
+        return 0;
+    // Process index op.
+    auto indexInst = module.getInstruction(indexChain[currentIdx]);
+    if (indexInst->getOpCode() != spv::Op::OpConstant)
+        return 0;
+    auto index = indexInst->getImmediateOperand(0);
+    for (auto dec = decorations.begin(); dec != decorations.end(); dec++) {
+        if (dec->get()->getOpCode() == spv::Op::OpMemberDecorate && dec->get()->getIdOperand(0) == baseId &&
+            dec->get()->getImmediateOperand(1) == index &&
+            dec->get()->getImmediateOperand(2) == spv::Decoration::BuiltIn &&
+            (dec->get()->getImmediateOperand(3) == (unsigned)spv::BuiltIn::ResourceHeapEXT ||
+             dec->get()->getImmediateOperand(3) == (unsigned)spv::BuiltIn::SamplerHeapEXT)) {
+            if (bt)
+                *bt = (spv::BuiltIn)dec->get()->getImmediateOperand(3);
+            return currentIdx;
+        }
+    }
+    // New base.
+    if (baseInst->getOpCode() == spv::Op::OpTypeStruct) {
+        if (!baseInst->isIdOperand(index) || idx == indexChain.size() - 1)
+            return 0;
+        return isStructureHeapMember(baseInst->getIdOperand(index), indexChain, currentIdx + 1, bt, firstArrIndex);
+    }
+
+    return 0;
+}
+
+// Comments in header
+Id Builder::createDescHeapAccessChain()
+{
+    uint32_t rsrcOffsetIdx = accessChain.descHeapInfo.structRsrcTyOffsetCount;
+    if (rsrcOffsetIdx != 0)
+        accessChain.base = accessChain.descHeapInfo.structRemappedBase;
+    Id base = accessChain.base;
+    Id untypedResultTy = accessChain.descHeapInfo.descHeapBaseTy;
+    uint32_t explicitArrayStride = accessChain.descHeapInfo.descHeapBaseArrayStride;
+    std::vector<Id>& offsets = accessChain.indexChain;
+    uint32_t firstArrIndex = accessChain.descHeapInfo.structRsrcTyFirstArrIndex;
+    // both typeBufferEXT and UntypedPointer only contains storage class info.
+    StorageClass storageClass = (StorageClass)accessChain.descHeapInfo.descHeapStorageClass;
+    Id resultTy = makeUntypedPointer(storageClass == spv::StorageClass::StorageBuffer ? spv::StorageClass::StorageBuffer
+                                                                                      : spv::StorageClass::Uniform);
+
+    // Make the untyped access chain instruction
+    Instruction* chain = new Instruction(getUniqueId(), makeUntypedPointer(getStorageClass(base)), Op::OpUntypedAccessChainKHR);
+
+    if (storageClass == spv::StorageClass::Uniform || storageClass == spv::StorageClass::StorageBuffer) {
+        // For buffer and uniform heap, split first index as heap array index
+        // Insert BufferPointer op and construct another access chain with following indexes.
+        Id bufferTy = makeUntypedPointer(storageClass, true);
+        Id strideId = NoResult;
+        if (explicitArrayStride == 0) {
+            strideId = createConstantSizeOfEXT(bufferTy);
+        } else {
+            strideId = makeUintConstant(explicitArrayStride);
+        }
+        Id runtimeArrTy = makeRuntimeArray(bufferTy);
+        addDecorationId(runtimeArrTy, spv::Decoration::ArrayStrideIdEXT, strideId);
+        chain->addIdOperand(runtimeArrTy);
+        chain->addIdOperand(base);
+        // We would only re-target current member resource directly to resource/sampler heap base.
+        // So the previous access chain index towards final resource type is not needed?
+        // In current draft, only keep the first 'array index' into last access chain index.
+        // As those resource can't be declared as an array, in current first draft, array index will
+        // be the second index. This will be refined later.
+        chain->addIdOperand(offsets[firstArrIndex]);
+        if (rsrcOffsetIdx != 0) {
+            for (uint32_t i = 0; i < rsrcOffsetIdx + 1; i++) {
+                if (rsrcOffsetIdx + i + 1 < offsets.size())
+                    offsets[i] = offsets[i + rsrcOffsetIdx + 1];
+            }
+        } else {
+            for (uint32_t i = 0; i < offsets.size() - 1; i++) {
+                offsets[i] = offsets[i + 1];
+            }
+        }
+        for (uint32_t i = 0; i < rsrcOffsetIdx + 1; i++)
+            offsets.pop_back();
+        addInstruction(std::unique_ptr<Instruction>(chain));
+        // Create OpBufferPointer for loading target buffer descriptor.
+        Instruction* bufferUntypedDataPtr = new Instruction(getUniqueId(), resultTy, Op::OpBufferPointerEXT);
+        bufferUntypedDataPtr->addIdOperand(chain->getResultId());
+        addInstruction(std::unique_ptr<Instruction>(bufferUntypedDataPtr));
+        // Final/Second untyped access chain loading will be created during loading, current results only
+        // refer to the loading 'base'.
+        return bufferUntypedDataPtr->getResultId();
+    } else {
+        // image/sampler heap
+        Id strideId = NoResult;
+        if (explicitArrayStride == 0) {
+            strideId = createConstantSizeOfEXT(untypedResultTy);
+        } else {
+            strideId = makeUintConstant(explicitArrayStride);
+        }
+        Id runtimeArrTy = makeRuntimeArray(untypedResultTy);
+        addDecorationId(runtimeArrTy, spv::Decoration::ArrayStrideIdEXT, strideId);
+        chain->addIdOperand(runtimeArrTy);
+        chain->addIdOperand(base);
+        for (int i = 0; i < (int)offsets.size(); ++i)
+            chain->addIdOperand(offsets[i]);
+        addInstruction(std::unique_ptr<Instruction>(chain));
+        return chain->getResultId();
+    }
+}
+
 // Comments in header
 Id Builder::createAccessChain(StorageClass storageClass, Id base, const std::vector<Id>& offsets)
 {
@@ -3344,12 +3591,21 @@ Id Builder::createLvalueSwizzle(Id typeId, Id target, Id source, const std::vect
 // Comments in header
 void Builder::promoteScalar(Decoration precision, Id& left, Id& right)
 {
-    int direction = getNumComponents(right) - getNumComponents(left);
+    // choose direction of promotion (+1 for left to right, -1 for right to left)
+    int direction = !isScalar(right) - !isScalar(left);
+
+    auto const &makeVec = [&](Id component, Id other) {
+        if (isCooperativeVector(other)) {
+            return makeCooperativeVectorTypeNV(getTypeId(component), getCooperativeVectorNumComponents(getTypeId(other)));
+        } else {
+            return makeVectorType(getTypeId(component), getNumComponents(other));
+        }
+    };
 
     if (direction > 0)
-        left = smearScalar(precision, left, makeVectorType(getTypeId(left), getNumComponents(right)));
+        left = smearScalar(precision, left, makeVec(left, right));
     else if (direction < 0)
-        right = smearScalar(precision, right, makeVectorType(getTypeId(right), getNumComponents(left)));
+        right = smearScalar(precision, right, makeVec(right, left));
 
     return;
 }
@@ -3361,7 +3617,7 @@ Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType)
     assert(getTypeId(scalar) == getScalarTypeId(vectorType));
 
     int numComponents = getNumTypeComponents(vectorType);
-    if (numComponents == 1 && !isCooperativeVectorType(vectorType))
+    if (numComponents == 1 && !isCooperativeVectorType(vectorType) && !isVectorType(vectorType))
         return scalar;
 
     Instruction* smear = nullptr;
@@ -3773,7 +4029,7 @@ Id Builder::createCompositeConstruct(Id typeId, const std::vector<Id>& constitue
 {
     assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 &&
            getNumTypeConstituents(typeId) == constituents.size()) ||
-           (isCooperativeVectorType(typeId) && constituents.size() == 1));
+           ((isCooperativeVectorType(typeId) || isVectorType(typeId)) && constituents.size() == 1));
 
     if (generatingOpCodeForSpecConst) {
         // Sometime, even in spec-constant-op mode, the constant composite to be
@@ -3862,9 +4118,16 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
         return smearScalar(precision, sources[0], resultTypeId);
 
     // Special case: 2 vectors of equal size
-    if (sources.size() == 1 && isVector(sources[0]) && numTargetComponents == getNumComponents(sources[0])) {
-        assert(resultTypeId == getTypeId(sources[0]));
-        return sources[0];
+    if (sources.size() == 1 &&
+        (isVector(sources[0]) || isCooperativeVector(sources[0])) &&
+        numTargetComponents == getNumComponents(sources[0])) {
+        if (isCooperativeVector(sources[0]) != isCooperativeVectorType(resultTypeId)) {
+            assert(isVector(sources[0]) != isVectorType(resultTypeId));
+            return createUnaryOp(spv::Op::OpBitcast, resultTypeId, sources[0]);
+        } else {
+            assert(resultTypeId == getTypeId(sources[0]));
+            return sources[0];
+        }
     }
 
     // accumulate the arguments for OpCompositeConstruct
@@ -3873,7 +4136,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
 
     // lambda to store the result of visiting an argument component
     const auto latchResult = [&](Id comp) {
-        if (numTargetComponents > 1)
+        if (numTargetComponents > 1 || isVectorType(resultTypeId))
             constituents.push_back(comp);
         else
             result = comp;
@@ -4251,6 +4514,13 @@ void Builder::clearAccessChain()
     accessChain.isRValue = false;
     accessChain.coherentFlags.clear();
     accessChain.alignment = 0;
+    accessChain.descHeapInfo.descHeapBaseTy = NoResult;
+    accessChain.descHeapInfo.descHeapStorageClass = StorageClass::Max;
+    accessChain.descHeapInfo.descHeapInstId.clear();
+    accessChain.descHeapInfo.descHeapBaseArrayStride = NoResult;
+    accessChain.descHeapInfo.structRemappedBase = NoResult;
+    accessChain.descHeapInfo.structRsrcTyOffsetCount = 0;
+    accessChain.descHeapInfo.structRsrcTyFirstArrIndex = 0;
 }
 
 // Comments in header
@@ -4372,7 +4642,7 @@ Id Builder::accessChainLoad(Decoration precision, Decoration l_nonUniform,
             if (constant) {
                 id = createCompositeExtract(accessChain.base, swizzleBase, indexes);
                 setPrecision(id, precision);
-            } else if (isCooperativeVector(accessChain.base)) {
+            } else if (isVector(accessChain.base) || isCooperativeVector(accessChain.base)) {
                 assert(accessChain.indexChain.size() == 1);
                 id = createVectorExtractDynamic(accessChain.base, resultType, accessChain.indexChain[0]);
             } else {
@@ -4461,10 +4731,13 @@ Id Builder::accessChainGetLValue()
 Id Builder::accessChainGetInferredType()
 {
     // anything to operate on?
-    if (accessChain.base == NoResult)
+    // for untyped pointer, it may be remapped to a descriptor heap.
+    // for descriptor heap, its base data type will be determined later,
+    // according to load/store results' types.
+    if (accessChain.base == NoResult || isUntypedPointer(accessChain.base) ||
+        isStructureHeapMember(getTypeId(accessChain.base), accessChain.indexChain, 0) != 0)
         return NoType;
     Id type = getTypeId(accessChain.base);
-
     // do initial dereference
     if (! accessChain.isRValue)
         type = getContainedTypeId(type);
@@ -4582,7 +4855,13 @@ Id Builder::collapseAccessChain()
 
     // emit the access chain
     StorageClass storageClass = (StorageClass)module.getStorageClass(getTypeId(accessChain.base));
-    accessChain.instr = createAccessChain(storageClass, accessChain.base, accessChain.indexChain);
+    // when descHeap info is set, use another access chain process.
+    if ((isUntypedPointer(accessChain.base) || accessChain.descHeapInfo.structRsrcTyOffsetCount!= 0) &&
+        accessChain.descHeapInfo.descHeapStorageClass != StorageClass::Max) {
+        accessChain.instr = createDescHeapAccessChain();
+    } else {
+        accessChain.instr = createAccessChain(storageClass, accessChain.base, accessChain.indexChain);
+    }
 
     return accessChain.instr;
 }
@@ -4691,6 +4970,16 @@ void Builder::createBranch(bool implicit, Block* block)
     block->addPredecessor(buildPoint);
 }
 
+// Create OpConstantSizeOfEXT
+Id Builder::createConstantSizeOfEXT(Id typeId)
+{
+    Instruction* inst = new Instruction(getUniqueId(), makeIntType(32), Op::OpConstantSizeOfEXT);
+    inst->addIdOperand(typeId);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+    module.mapInstruction(inst);
+    return inst->getResultId();
+}
+
 void Builder::createSelectionMerge(Block* mergeBlock, SelectionControlMask control)
 {
     Instruction* merge = new Instruction(Op::OpSelectionMerge);
diff --git a/3rdparty/glslang/SPIRV/SpvBuilder.h b/3rdparty/glslang/SPIRV/SpvBuilder.h
index 70c1defb7..abfec52ef 100644
--- a/3rdparty/glslang/SPIRV/SpvBuilder.h
+++ b/3rdparty/glslang/SPIRV/SpvBuilder.h
@@ -230,6 +230,7 @@ public:
     Id makePointer(StorageClass, Id pointee);
     Id makeForwardPointer(StorageClass);
     Id makePointerFromForwardPointer(StorageClass, Id forwardPointerType, Id pointee);
+    Id makeUntypedPointer(StorageClass storageClass, bool setBufferPointer = false);
     Id makeIntegerType(int width, bool hasSign);   // generic
     Id makeIntType(int width) { return makeIntegerType(width, true); }
     Id makeUintType(int width) { return makeIntegerType(width, false); }
@@ -317,6 +318,14 @@ public:
     Id getCooperativeVectorNumComponents(Id typeId) const { return module.getInstruction(typeId)->getIdOperand(1); }
 
     bool isPointer(Id resultId)      const { return isPointerType(getTypeId(resultId)); }
+    bool isUntypedPointer(Id resultId) const
+    {
+        const Id tid = getTypeId(resultId);
+        // Expect that OpString have no type
+        if (tid == 0)
+            return false;
+        return isUntypedPointerType(tid);
+    }
     bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
     bool isVector(Id resultId)       const { return isVectorType(getTypeId(resultId)); }
     bool isMatrix(Id resultId)       const { return isMatrixType(getTypeId(resultId)); }
@@ -334,6 +343,7 @@ public:
         { return getTypeClass(typeId) == Op::OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
     bool isFloatType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeFloat; }
     bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == Op::OpTypePointer; }
+    bool isUntypedPointerType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeUntypedPointerKHR; }
     bool isScalarType(Id typeId)       const
         { return getTypeClass(typeId) == Op::OpTypeFloat || getTypeClass(typeId) == Op::OpTypeInt ||
           getTypeClass(typeId) == Op::OpTypeBool; }
@@ -469,6 +479,7 @@ public:
     void addMemberDecoration(Id, unsigned int member, Decoration, const char*);
     void addMemberDecoration(Id, unsigned int member, Decoration, const std::vector<unsigned>& literals);
     void addMemberDecoration(Id, unsigned int member, Decoration, const std::vector<const char*>& strings);
+    void addMemberDecorationIdEXT(Id, unsigned int member, Decoration, const std::vector<unsigned>& operands);
 
     // At the end of what block do the next create*() instructions go?
     // Also reset current last DebugScope and current source line to unknown
@@ -531,9 +542,16 @@ public:
     Id createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name = nullptr,
         Id initializer = NoResult, bool const compilerGenerated = true);
 
+    // Create an untyped global or function local or IO variable.
+    Id createUntypedVariable(Decoration precision, StorageClass storageClass, const char* name = nullptr,
+                             Id dataType = NoResult, Id initializer = NoResult);
+
     // Create an intermediate with an undefined value.
     Id createUndefined(Id type);
 
+    // Create load/store instruction with a remapped descriptor heap base.
+    Instruction* createDescHeapLoadStoreBaseRemap(Id base, Op op);
+
     // Store into an Id and return the l-value
     void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
         spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
@@ -790,6 +808,18 @@ public:
         unsigned int alignment;        // bitwise OR of alignment values passed in. Accumulates worst alignment.
                                        // Only tracks base and (optional) component selection alignment.
 
+        struct DescHeapInfo {
+            Id descHeapBaseTy;                  // for descriptor heap, record its base data type.
+            StorageClass descHeapStorageClass;  // for descriptor heap, record its basic storage class.
+            uint32_t descHeapBaseArrayStride;   // for descriptor heap, record its explicit array stride.
+            std::vector<Instruction*> descHeapInstId;
+                                                // for descriptor heap, record its data type for loading/store results.
+            uint32_t structRsrcTyOffsetCount;
+            uint32_t structRsrcTyFirstArrIndex;
+            Id structRemappedBase;
+        };
+        DescHeapInfo descHeapInfo;
+
         // Accumulate whether anything in the chain of structures has coherent decorations.
         struct CoherentFlags {
             CoherentFlags() { clear(); }
@@ -856,10 +886,15 @@ public:
     // clear accessChain
     void clearAccessChain();
 
+    Id createDescHeapAccessChain();
+    Id createConstantSizeOfEXT(Id typeId);
+    uint32_t isStructureHeapMember(Id id, std::vector<Id> indexChain, unsigned int idx, spv::BuiltIn* bt = nullptr,
+                                   uint32_t* firstArrIndex = nullptr);
+
     // set new base as an l-value base
     void setAccessChainLValue(Id lValue)
     {
-        assert(isPointer(lValue));
+        assert(isPointer(lValue) || isUntypedPointer(lValue));
         accessChain.base = lValue;
     }
 
@@ -870,6 +905,25 @@ public:
         accessChain.base = rValue;
     }
 
+    // set access chain info for untyped descriptor heap variable
+    void setAccessChainDescHeapInfo(StorageClass storageClass = StorageClass::Max, Id baseTy = NoResult,
+                                    uint32_t explicitArrayStride = NoResult, uint32_t structRsrcTyOffsetCount = 0,
+                                    spv::Id structRemappedBase = NoResult, uint32_t firstArrIndex = NoResult)
+    {
+        if (accessChain.descHeapInfo.descHeapStorageClass == StorageClass::Max)
+            accessChain.descHeapInfo.descHeapStorageClass = storageClass;
+        if (accessChain.descHeapInfo.descHeapBaseTy == NoResult)
+            accessChain.descHeapInfo.descHeapBaseTy = baseTy;
+        if (accessChain.descHeapInfo.descHeapBaseArrayStride == NoResult)
+            accessChain.descHeapInfo.descHeapBaseArrayStride = explicitArrayStride;
+        if (accessChain.descHeapInfo.structRemappedBase == NoResult)
+            accessChain.descHeapInfo.structRemappedBase = structRemappedBase;
+        if (accessChain.descHeapInfo.structRsrcTyOffsetCount == 0)
+            accessChain.descHeapInfo.structRsrcTyOffsetCount = structRsrcTyOffsetCount;
+        if (accessChain.descHeapInfo.structRsrcTyFirstArrIndex == 0)
+            accessChain.descHeapInfo.structRsrcTyFirstArrIndex = firstArrIndex;
+    }
+
     // push offset onto the end of the chain
     void accessChainPush(Id offset, AccessChain::CoherentFlags coherentFlags, unsigned int alignment)
     {
diff --git a/3rdparty/glslang/SPIRV/SpvPostProcess.cpp b/3rdparty/glslang/SPIRV/SpvPostProcess.cpp
index 068e33e82..2d5c32099 100644
--- a/3rdparty/glslang/SPIRV/SpvPostProcess.cpp
+++ b/3rdparty/glslang/SPIRV/SpvPostProcess.cpp
@@ -83,7 +83,10 @@ void Builder::postProcessType(const Instruction& inst, Id typeId)
             if (containsType(typeId, Op::OpTypeFloat, 16))
                 addCapability(Capability::Float16);
         } else {
-            StorageClass storageClass = getStorageClass(inst.getIdOperand(0));
+            StorageClass storageClass = StorageClass::Max;
+            if (module.getInstruction(inst.getIdOperand(0))->getOpCode() != Op::OpUntypedAccessChainKHR) {
+                storageClass = getStorageClass(inst.getIdOperand(0));
+            }
             if (width == 8) {
                 switch (storageClass) {
                 case StorageClass::PhysicalStorageBufferEXT:
diff --git a/3rdparty/glslang/SPIRV/SpvTools.cpp b/3rdparty/glslang/SPIRV/SpvTools.cpp
index d1b411f29..bf8269282 100644
--- a/3rdparty/glslang/SPIRV/SpvTools.cpp
+++ b/3rdparty/glslang/SPIRV/SpvTools.cpp
@@ -166,6 +166,7 @@ void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<
     spvValidatorOptionsSetScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
     spvValidatorOptionsSetWorkgroupScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
     spvValidatorOptionsSetAllowOffsetTextureOperand(options, intermediate.usingTextureOffsetNonConst());
+    spvValidatorOptionsSetAllowVulkan32BitBitwise(options, true);
     spvValidateWithOptions(context, options, &binary, &diagnostic);
 
     // report
diff --git a/3rdparty/glslang/SPIRV/disassemble.cpp b/3rdparty/glslang/SPIRV/disassemble.cpp
index 9b85ff28e..388969513 100644
--- a/3rdparty/glslang/SPIRV/disassemble.cpp
+++ b/3rdparty/glslang/SPIRV/disassemble.cpp
@@ -414,6 +414,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 idDescriptor[resultId] = "struct";
                 break;
             case Op::OpTypePointer:
+            case Op::OpTypeUntypedPointerKHR:
                 idDescriptor[resultId] = "ptr";
                 break;
             case Op::OpTypeVector:
diff --git a/3rdparty/glslang/SPIRV/doc.cpp b/3rdparty/glslang/SPIRV/doc.cpp
index dcc9b4e1a..f81faefab 100644
--- a/3rdparty/glslang/SPIRV/doc.cpp
+++ b/3rdparty/glslang/SPIRV/doc.cpp
@@ -350,6 +350,12 @@ const char* DecorationString(int decoration)
     case (int)Decoration::HitObjectShaderRecordBufferEXT:  return "DecorationHitObjectShaderRecordBufferEXT";
 
     case (int)Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "DecorationSaturatedToLargestFloat8NormalConversionEXT";
+
+    case (int)Decoration::BankNV:                        return "BankNV";
+    case (int)Decoration::MemberOffsetNV:                return "MemberOffsetNV";
+
+    case (int)Decoration::ArrayStrideIdEXT:        return "DecorationArrayStrideIdEXT";
+    case (int)Decoration::OffsetIdEXT:             return "DecorationOffsetIdEXT";
     }
 }
 
@@ -491,6 +497,8 @@ const char* BuiltInString(int builtIn)
     case (int)BuiltIn::CoreMaxIDARM:           return "CoreMaxIDARM";
     case (int)BuiltIn::WarpIDARM:              return "WarpIDARM";
     case (int)BuiltIn::WarpMaxIDARM:           return "BuiltInWarpMaxIDARM";
+    case (int)BuiltIn::SamplerHeapEXT:         return "SamplerHeapEXT";
+    case (int)BuiltIn::ResourceHeapEXT:        return "ResourceHeapEXT";
 
     default: return "Bad";
     }
@@ -1093,6 +1101,8 @@ const char* CapabilityString(int info)
     case (int)Capability::ShaderClockKHR:                          return "ShaderClockKHR";
     case (int)Capability::QuadControlKHR:                          return "QuadControlKHR";
     case (int)Capability::Int64ImageEXT:                           return "Int64ImageEXT";
+    case (int)Capability::DescriptorHeapEXT:                       return "DescriptorHeapEXT";
+    case (int)Capability::UntypedPointersKHR:                      return "UntypedPointersKHR";
 
     case (int)Capability::IntegerFunctions2INTEL:              return "IntegerFunctions2INTEL";
 
@@ -1140,7 +1150,10 @@ const char* CapabilityString(int info)
     case (int)Capability::Float8EXT:                           return "Float8EXT";
     case (int)Capability::Float8CooperativeMatrixEXT:          return "Float8CooperativeMatrixEXT";
 
+    case (int)Capability::PushConstantBanksNV:                 return "PushConstantBanksNV";
+        
     case (int)Capability::Shader64BitIndexingEXT:              return "CapabilityShader64BitIndexingEXT";
+    case (int)Capability::LongVectorEXT:                       return "LongVectorEXT";
 
     default: return "Bad";
     }
@@ -1523,6 +1536,14 @@ const char* OpcodeString(int op)
 
     case (int)Op::OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
     case (int)Op::OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
+    case (int)Op::OpBufferPointerEXT:          return "OpBufferPointerEXT";
+    case (int)Op::OpConstantSizeOfEXT:         return "OpConstantSizeOfEXT";
+    case (int)Op::OpTypeBufferEXT:             return "OpTypeBufferEXT";
+    case (int)Op::OpUntypedAccessChainKHR:     return "OpUntypedAccessChainKHR";
+    case (int)Op::OpUntypedVariableKHR:        return "OpUntypedVariableKHR";
+    case (int)Op::OpTypeUntypedPointerKHR:     return "OpTypeUntypedPointerKHR";
+    case (int)Op::OpMemberDecorateIdEXT:       return "OpMemberDecorateIdEXT";
+    case (int)Op::OpUntypedImageTexelPointerEXT:     return "OpUntypedImageTexelPointerEXT";
 
     case (int)Op::OpAtomicFAddEXT: return "OpAtomicFAddEXT";
     case (int)Op::OpAtomicFMinEXT: return "OpAtomicFMinEXT";
@@ -1819,6 +1840,7 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpTypeStruct)].setResultAndType(true, false);
         InstructionDesc[enumCast(Op::OpTypeOpaque)].setResultAndType(true, false);
         InstructionDesc[enumCast(Op::OpTypePointer)].setResultAndType(true, false);
+        InstructionDesc[enumCast(Op::OpTypeUntypedPointerKHR)].setResultAndType(true, false);
         InstructionDesc[enumCast(Op::OpTypeForwardPointer)].setResultAndType(false, false);
         InstructionDesc[enumCast(Op::OpTypeFunction)].setResultAndType(true, false);
         InstructionDesc[enumCast(Op::OpTypeEvent)].setResultAndType(true, false);
@@ -1889,6 +1911,7 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].setResultAndType(false, false);
         InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].setResultAndType(false, false);
         InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].setResultAndType(false, false);
+        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].setResultAndType(false, false);
 
         InstructionDesc[enumCast(Op::OpTypeTensorARM)].setResultAndType(true, false);
         InstructionDesc[enumCast(Op::OpTensorReadARM)].setResultAndType(true, true);
@@ -2043,6 +2066,7 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpTypeStruct)].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
 
         InstructionDesc[enumCast(Op::OpTypeOpaque)].operands.push(OperandLiteralString, "The name of the opaque type.");
+        InstructionDesc[enumCast(Op::OpTypeUntypedPointerKHR)].operands.push(OperandStorage, "");
 
         InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandStorage, "");
         InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandId, "'Type'");
@@ -2070,6 +2094,9 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandLiteralNumber, "'Opcode'");
         InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandVariableIds, "'Operands'");
 
+        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandStorage, "");
+        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandId, "'Type'", true);
+        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandId, "'Initializer'", true);
         InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandStorage, "");
         InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandId, "'Initializer'", true);
 
@@ -2117,6 +2144,11 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandDecoration, "");
         InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
 
+        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandId, "'Structure Type'");
+        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandLiteralNumber, "'Member'");
+        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandDecoration, "");
+        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
+
         InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandId, "'Structure Type'");
         InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandLiteralNumber, "'Member'");
         InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandDecoration, "");
@@ -2323,6 +2355,9 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandId, "'Base'");
         InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
 
+        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandId, "'Base Type'");
+        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandId, "'Base'");
+        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandVariableIds, "'Indexes'");
         InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandId, "'Base'");
         InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
 
@@ -3160,6 +3195,19 @@ void Parameterize()
         InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Coordinate'");
         InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Fragment Index'");
 
+
+        InstructionDesc[enumCast(Op::OpTypeBufferEXT)].operands.push(OperandStorage, "");
+        InstructionDesc[enumCast(Op::OpTypeBufferEXT)].setResultAndType(true, false);
+
+        InstructionDesc[enumCast(Op::OpConstantSizeOfEXT)].operands.push(OperandId, "'Type'");
+
+        InstructionDesc[enumCast(Op::OpBufferPointerEXT)].operands.push(OperandId, "'Buffer'");
+
+        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'ImageType'");
+        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Image'");
+        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Sample'");
+
         InstructionDesc[enumCast(Op::OpGroupNonUniformPartitionNV)].operands.push(OperandId, "X");
 
         InstructionDesc[enumCast(Op::OpGroupNonUniformQuadAllKHR)].operands.push(OperandId, "'Predicate'");
diff --git a/3rdparty/glslang/SPIRV/spirv.hpp11 b/3rdparty/glslang/SPIRV/spirv.hpp11
index 6f3021e9e..36a82e7a3 100644
--- a/3rdparty/glslang/SPIRV/spirv.hpp11
+++ b/3rdparty/glslang/SPIRV/spirv.hpp11
@@ -206,7 +206,7 @@ enum class ExecutionMode : unsigned {
     SampleInterlockOrderedEXT = 5368,
     SampleInterlockUnorderedEXT = 5369,
     ShadingRateInterlockOrderedEXT = 5370,
-    ShadingRateInterlockUnorderedEXT = 5371,
+    ShadingRateInterlockUnorderedEXT = 5371,
     Shader64BitIndexingEXT = 5427,
     SharedLocalMemorySizeINTEL = 5618,
     RoundingModeRTPINTEL = 5620,
@@ -564,6 +564,8 @@ enum class Decoration : unsigned {
     PayloadNodeSparseArrayAMDX = 5099,
     PayloadNodeArraySizeAMDX = 5100,
     PayloadDispatchIndirectAMDX = 5105,
+    ArrayStrideIdEXT = 5124,
+    OffsetIdEXT = 5125,
     OverrideCoverageNV = 5248,
     PassthroughNV = 5250,
     ViewportRelativeNV = 5252,
@@ -580,8 +582,10 @@ enum class Decoration : unsigned {
     RestrictPointerEXT = 5355,
     AliasedPointer = 5356,
     AliasedPointerEXT = 5356,
+    MemberOffsetNV = 5358,
     HitObjectShaderRecordBufferNV = 5386,
     HitObjectShaderRecordBufferEXT = 5389,
+    BankNV = 5397,
     BindlessSamplerNV = 5398,
     BindlessImageNV = 5399,
     BoundSamplerNV = 5400,
@@ -733,6 +737,8 @@ enum class BuiltIn : unsigned {
     FragStencilRefEXT = 5014,
     RemainingRecursionLevelsAMDX = 5021,
     ShaderIndexAMDX = 5073,
+    SamplerHeapEXT = 5122,
+    ResourceHeapEXT = 5123,
     ViewportMaskNV = 5253,
     SecondaryPositionNV = 5257,
     SecondaryViewportMaskNV = 5258,
@@ -1127,6 +1133,7 @@ enum class Capability : unsigned {
     BFloat16TypeKHR = 5116,
     BFloat16DotProductKHR = 5117,
     BFloat16CooperativeMatrixKHR = 5118,
+    DescriptorHeapEXT = 5128,
     SampleMaskOverrideCoverageNV = 5249,
     GeometryShaderPassthroughNV = 5251,
     ShaderViewportIndexLayerEXT = 5254,
@@ -1199,7 +1206,9 @@ enum class Capability : unsigned {
     RayTracingDisplacementMicromapNV = 5409,
     RawAccessChainsNV = 5414,
     RayTracingSpheresGeometryNV = 5418,
-    RayTracingLinearSweptSpheresGeometryNV = 5419,
+    RayTracingLinearSweptSpheresGeometryNV = 5419,
+    PushConstantBanksNV = 5423,
+    LongVectorEXT = 5425,
     Shader64BitIndexingEXT = 5426,
     CooperativeMatrixReductionsNV = 5430,
     CooperativeMatrixConversionsNV = 5431,
@@ -2031,6 +2040,11 @@ enum class Op : unsigned {
     OpSpecConstantStringAMDX = 5104,
     OpGroupNonUniformQuadAllKHR = 5110,
     OpGroupNonUniformQuadAnyKHR = 5111,
+    OpTypeBufferEXT = 5115,
+    OpBufferPointerEXT = 5119,
+    OpUntypedImageTexelPointerEXT = 5126,
+    OpMemberDecorateIdEXT = 5127,
+    OpConstantSizeOfEXT = 5129,
     OpHitObjectRecordHitMotionNV = 5249,
     OpHitObjectRecordHitWithIndexMotionNV = 5250,
     OpHitObjectRecordMissMotionNV = 5251,
@@ -2066,6 +2080,7 @@ enum class Op : unsigned {
     OpTypeHitObjectNV = 5281,
     OpImageSampleFootprintNV = 5283,
     OpTypeCooperativeVectorNV = 5288,
+    OpTypeVectorIdEXT = 5288,
     OpCooperativeVectorMatrixMulNV = 5289,
     OpCooperativeVectorOuterProductAccumulateNV = 5290,
     OpCooperativeVectorReduceSumAccumulateNV = 5291,
@@ -2816,6 +2831,11 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case Op::OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
     case Op::OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
     case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBufferPointerEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedImageTexelPointerEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMemberDecorateIdEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConstantSizeOfEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeBufferEXT: *hasResult = true; *hasResultType = false; break;
     case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
     case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
     case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
@@ -3426,7 +3446,7 @@ inline const char* ExecutionModeToString(ExecutionMode value) {
     case ExecutionMode::SampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT";
     case ExecutionMode::SampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT";
     case ExecutionMode::ShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT";
-    case ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
+    case ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
     case ExecutionMode::Shader64BitIndexingEXT: return "Shader64BitIndexingEXT";
     case ExecutionMode::SharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL";
     case ExecutionMode::RoundingModeRTPINTEL: return "RoundingModeRTPINTEL";
@@ -3736,7 +3756,9 @@ inline const char* DecorationToString(Decoration value) {
     case Decoration::NonUniform: return "NonUniform";
     case Decoration::RestrictPointer: return "RestrictPointer";
     case Decoration::AliasedPointer: return "AliasedPointer";
+    case Decoration::MemberOffsetNV: return "MemberOffsetNV";
     case Decoration::HitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV";
+    case Decoration::BankNV: return "BankNV";
     case Decoration::HitObjectShaderRecordBufferEXT: return "HitObjectShaderRecordBufferEXT";
     case Decoration::BindlessSamplerNV: return "BindlessSamplerNV";
     case Decoration::BindlessImageNV: return "BindlessImageNV";
@@ -4157,7 +4179,9 @@ inline const char* CapabilityToString(Capability value) {
     case Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
     case Capability::RawAccessChainsNV: return "RawAccessChainsNV";
     case Capability::RayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV";
-    case Capability::RayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case Capability::RayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case Capability::PushConstantBanksNV: return "PushConstantBanksNV";
+    case Capability::LongVectorEXT: return "LongVectorEXT";
     case Capability::Shader64BitIndexingEXT: return "Shader64BitIndexingEXT";
     case Capability::CooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
     case Capability::CooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
@@ -4803,6 +4827,11 @@ inline const char* OpToString(Op value) {
     case Op::OpSubgroupAllKHR: return "OpSubgroupAllKHR";
     case Op::OpSubgroupAnyKHR: return "OpSubgroupAnyKHR";
     case Op::OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR";
+    case Op::OpBufferPointerEXT: return "OpBufferPointerEXT";
+    case Op::OpUntypedImageTexelPointerEXT: return "OpUntypedImageTexelPointerEXT";
+    case Op::OpMemberDecorateIdEXT: return "OpMemberDecorateIdEXT";
+    case Op::OpConstantSizeOfEXT: return "OpConstantSizeOfEXT";
+    case Op::OpTypeBufferEXT: return "OpTypeBufferEXT";
     case Op::OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
     case Op::OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR";
     case Op::OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR";
diff --git a/3rdparty/glslang/SPIRV/spvIR.h b/3rdparty/glslang/SPIRV/spvIR.h
index f1039cfdb..ce7afbcce 100644
--- a/3rdparty/glslang/SPIRV/spvIR.h
+++ b/3rdparty/glslang/SPIRV/spvIR.h
@@ -222,6 +222,7 @@ public:
     }
     Id getResultId() const { return resultId; }
     Id getTypeId() const { return typeId; }
+    void setTypeId(Id tId) { typeId = tId; }
     Id getIdOperand(int op) const {
         assert(idOperand[op]);
         return operands[op];
@@ -574,7 +575,8 @@ public:
     }
     StorageClass getStorageClass(Id typeId) const
     {
-        assert(idToInstruction[typeId]->getOpCode() == spv::Op::OpTypePointer);
+        assert(idToInstruction[typeId]->getOpCode() == spv::Op::OpTypePointer ||
+               idToInstruction[typeId]->getOpCode() == spv::Op::OpTypeUntypedPointerKHR);
         return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0);
     }
 
diff --git a/3rdparty/glslang/StandAlone/StandAlone.cpp b/3rdparty/glslang/StandAlone/StandAlone.cpp
index be7f44212..c98551c4a 100644
--- a/3rdparty/glslang/StandAlone/StandAlone.cpp
+++ b/3rdparty/glslang/StandAlone/StandAlone.cpp
@@ -113,6 +113,7 @@ enum TOptions : uint64_t {
     EOptionDisplayErrorColumn = (1ull << 33),
     EOptionLinkTimeOptimization = (1ull << 34),
     EOptionValidateCrossStageIO = (1ull << 35),
+    EOptionBindingsPerResourceType = (1ull << 36),
 };
 bool targetHlslFunctionality1 = false;
 bool SpvToolsDisassembler = false;
@@ -918,6 +919,8 @@ void ProcessArguments(std::vector<std::unique_ptr<glslang::TWorkItem>>& workItem
                         Options |= EOptionLinkTimeOptimization;
                     } else if (lowerword == "validate-io") {
                         Options |= EOptionValidateCrossStageIO;
+                    } else if (lowerword == "bindings-per-resource-type") {
+                        Options |= EOptionBindingsPerResourceType;
                     } else if (lowerword == "help") {
                         usage();
                         break;
@@ -1465,6 +1468,9 @@ void CompileAndLinkShaderUnits(std::vector<ShaderCompUnit> compUnits)
         if (emitNonSemanticShaderDebugInfo)
             shader->setDebugInfo(true);
 
+        if (Options & EOptionBindingsPerResourceType)
+            shader->setBindingsPerResourceType();
+
         // Set up the environment, some subsettings take precedence over earlier
         // ways of setting things.
         if (Options & EOptionSpv) {
@@ -2194,7 +2200,8 @@ void usage()
            "                                    creates a C header file that contains a\n"
            "                                    uint32_t array named <name> initialized with\n"
            "                                    the shader binary code\n"
-           "  --validate-io                     validate cross stage IO\n");
+           "  --validate-io                     validate cross stage IO\n"
+           "  --bindings-per-resource-type\n");
 
     exit(EFailUsage);
 }
diff --git a/3rdparty/glslang/build_info.h b/3rdparty/glslang/build_info.h
index 7816b66d2..bf1caf7be 100644
--- a/3rdparty/glslang/build_info.h
+++ b/3rdparty/glslang/build_info.h
@@ -35,7 +35,7 @@
 #define GLSLANG_BUILD_INFO
 
 #define GLSLANG_VERSION_MAJOR 16
-#define GLSLANG_VERSION_MINOR 1
+#define GLSLANG_VERSION_MINOR 2
 #define GLSLANG_VERSION_PATCH 0
 #define GLSLANG_VERSION_FLAVOR ""
 
diff --git a/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp b/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp
index 72841c15d..1038eec3f 100644
--- a/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp
+++ b/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp
@@ -384,6 +384,10 @@ GLSLANG_EXPORT void glslang_shader_set_options(glslang_shader_t* shader, int opt
     if (options & GLSLANG_SHADER_VULKAN_RULES_RELAXED) {
         shader->shader->setEnvInputVulkanRulesRelaxed();
     }
+
+    if (options & GLSLANG_SHADER_BINDINGS_PER_RESOURCE_TYPE) {
+        shader->shader->setBindingsPerResourceType();
+    }
 }
 
 GLSLANG_EXPORT void glslang_shader_set_glsl_version(glslang_shader_t* shader, int version)
diff --git a/3rdparty/glslang/glslang/Include/BaseTypes.h b/3rdparty/glslang/glslang/Include/BaseTypes.h
index 3678afe89..e681ca0dc 100644
--- a/3rdparty/glslang/glslang/Include/BaseTypes.h
+++ b/3rdparty/glslang/glslang/Include/BaseTypes.h
@@ -76,6 +76,7 @@ enum TBasicType {
     EbtTensorViewNV,
     EbtCoopvecNV,
     EbtTensorARM,
+    EbtLongVector,
     // SPIR-V type defined by spirv_type
     EbtSpirvType,
 
@@ -143,6 +144,10 @@ enum TStorageQualifier {
 
     EvqTileImageEXT,
 
+    // EXT_structured_descriptor_heap
+    EvqSamplerHeap,
+    EvqResourceHeap,
+
     // end of list
     EvqLast
 };
@@ -353,6 +358,9 @@ enum TBuiltInVariable {
     EbvTileOffsetQCOM,
     EbvTileDimensionQCOM,
     EbvTileApronSizeQCOM,
+    // GL_EXT_descriptor_heap
+    EbvSamplerHeapEXT,
+    EbvResourceHeapEXT,
 
     EbvLast
 };
@@ -603,6 +611,22 @@ __inline bool isTypeUnsignedInt(TBasicType type)
     }
 }
 
+__inline TBasicType unsignedTypeToSigned(TBasicType type)
+{
+    switch (type) {
+    case EbtUint8:
+        return EbtInt8;
+    case EbtUint16:
+        return EbtInt16;
+    case EbtUint:
+        return EbtInt;
+    case EbtUint64:
+        return EbtInt64;
+    default:
+        return type;
+    }
+}
+
 __inline bool isTypeInt(TBasicType type)
 {
     return isTypeSignedInt(type) || isTypeUnsignedInt(type);
diff --git a/3rdparty/glslang/glslang/Include/Types.h b/3rdparty/glslang/glslang/Include/Types.h
index d3124ac8f..3fb0c55b5 100644
--- a/3rdparty/glslang/glslang/Include/Types.h
+++ b/3rdparty/glslang/glslang/Include/Types.h
@@ -517,6 +517,7 @@ public:
         spirvByReference = false;
         spirvLiteral = false;
         defaultBlock = false;
+        usedByAtomic = false;
     }
 
     // drop qualifiers that don't belong in a temporary variable
@@ -536,6 +537,7 @@ public:
         spirvDecorate = nullptr;
         spirvByReference = false;
         spirvLiteral = false;
+        usedByAtomic = false;
     }
 
     void clearInterstage()
@@ -617,6 +619,7 @@ public:
     bool nullInit : 1;
     bool spirvByReference : 1;
     bool spirvLiteral : 1;
+    bool usedByAtomic : 1; // EXT_descriptor_heap
     bool isWriteOnly() const { return writeonly; }
     bool isReadOnly() const { return readonly; }
     bool isRestrict() const { return restrict; }
@@ -660,6 +663,8 @@ public:
     bool isSpirvByReference() const { return spirvByReference; }
     void setSpirvLiteral() { spirvLiteral = true; }
     bool isSpirvLiteral() const { return spirvLiteral; }
+    void setUsedByAtomic() { usedByAtomic = true; }
+    bool isUsedByAtomic() const { return usedByAtomic; }
 
     bool isPipeInput() const
     {
@@ -875,6 +880,11 @@ public:
         clearInterstageLayout();
 
         layoutSpecConstantId = layoutSpecConstantIdEnd;
+        layoutBank = layoutBankEnd;
+        layoutDescriptorHeap = false;
+        layoutDescriptorStride = layoutDescriptorStrideEnd;
+        layoutHeapOffset = 0;
+        layoutDescriptorInnerBlock = false;
     }
     void clearInterstageLayout()
     {
@@ -916,6 +926,7 @@ public:
     TLayoutPacking layoutPacking : 4;
     int layoutOffset;
     int layoutAlign;
+    int layoutMemberOffset;
 
                  unsigned int layoutLocation             : 12;
     static const unsigned int layoutLocationEnd      =  0xFFF;
@@ -950,6 +961,12 @@ public:
                  unsigned int layoutSpecConstantId       : 11;
     static const unsigned int layoutSpecConstantIdEnd = 0x7FF;
 
+                 unsigned int layoutBank                 : 4;
+    static const unsigned int layoutBankEnd            = 0xF;
+
+                 unsigned int layoutDescriptorStride     : 4;
+    static const unsigned int layoutDescriptorStrideEnd = 0x0;
+
     // stored as log2 of the actual alignment value
                  unsigned int layoutBufferReferenceAlign :  6;
     static const unsigned int layoutBufferReferenceAlignEnd = 0x3F;
@@ -966,6 +983,9 @@ public:
     bool layoutQuadDeriv;
     bool layoutHitObjectShaderRecordNV;
     bool layoutHitObjectShaderRecordEXT;
+    bool layoutDescriptorHeap;
+    bool layoutDescriptorInnerBlock;
+    int layoutHeapOffset;
 
     // GL_EXT_spirv_intrinsics
     int spirvStorageClass;
@@ -991,6 +1011,7 @@ public:
         layoutPacking = ElpNone;
         layoutOffset = layoutNotSet;
         layoutAlign = layoutNotSet;
+        layoutMemberOffset = layoutNotSet;
 
         layoutSet = layoutSetEnd;
         layoutBinding = layoutBindingEnd;
@@ -1115,6 +1136,14 @@ public:
         // is just whether or not it was declared with an ID.
         return layoutSpecConstantId != layoutSpecConstantIdEnd;
     }
+    bool hasBank() const
+    {
+        return layoutBank != layoutBankEnd;
+    }
+    bool hasMemberOffset() const
+    {
+        return layoutMemberOffset != layoutNotSet;
+    }
     bool isSpecConstant() const
     {
         // True if type is a specialization constant, whether or not it
@@ -1514,6 +1543,7 @@ public:
     bool coopmatNV  : 1;
     bool coopmatKHR : 1;
     bool coopvecNV  : 1;
+    bool longVector : 1;
     bool tileAttachmentQCOM: 1;
     uint32_t tensorRankARM : 4;
     TArraySizes* arraySizes;
@@ -1527,8 +1557,11 @@ public:
     bool isCoopmatNV() const { return coopmatNV; }
     bool isCoopmatKHR() const { return coopmatKHR; }
     bool isCoopvecNV() const { return coopvecNV; }
+    bool isCoopmatOrvec() const { return isCoopmat() || isCoopvecNV() || isLongVector(); }
+    bool isLongVector() const { return longVector; }
+    bool isCoopvecOrLongVector() const { return isCoopvecNV() || isLongVector(); }
     bool isTensorARM() const { return tensorRankARM; }
-    bool hasTypeParameter() const { return isCoopmat() || isCoopvecNV() || isTensorARM(); }
+    bool hasTypeParameter() const { return isCoopmat() || isCoopvecNV() || isLongVector() || isTensorARM(); }
 
     bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; }
     bool isTensorViewNV() const { return basicType == EbtTensorViewNV; }
@@ -1546,6 +1579,7 @@ public:
         coopmatNV = false;
         coopmatKHR = false;
         coopvecNV = false;
+        longVector = false;
         tileAttachmentQCOM = false;
         tensorRankARM = 0;
         spirvType = nullptr;
@@ -1607,7 +1641,7 @@ public:
     // for "empty" type (no args) or simple scalar/vector/matrix
     explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0,
                    bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), longVector(false),
                             tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1623,7 +1657,7 @@ public:
     // for explicit precision qualifier
     TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0,
           bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), longVector(false),
                             tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1641,7 +1675,7 @@ public:
     // for turning a TPublicType into a TType, using a shallow copy
     explicit TType(const TPublicType& p) :
                             basicType(p.basicType),
-                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV),
+                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV), longVector(p.longVector),
                             tileAttachmentQCOM(p.tileAttachmentQCOM), tensorRankARM(p.tensorRankARM), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters),
                             spirvType(p.spirvType)
                             {
@@ -1692,7 +1726,7 @@ public:
                                         coopmatKHRUseValid = true;
                                     }
                                 }
-                                if (p.isCoopvecNV() && p.typeParameters) {
+                                if ((p.isCoopvecNV() || p.isLongVector()) && p.typeParameters) {
                                     basicType = p.typeParameters->basicType;
                                 }
                                 if (p.isTensorARM() && p.typeParameters) {
@@ -1704,7 +1738,7 @@ public:
                             }
     // for construction of sampler types
     TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) :
-        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), longVector(false),
         tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
         sampler(sampler), typeParameters(nullptr), spirvType(nullptr)
     {
@@ -1747,12 +1781,13 @@ public:
                                         // dereference from vector to scalar
                                         vectorSize = 1;
                                         vector1 = false;
-                                    } else if (isCoopMat() || isCoopVecNV()) {
+                                    } else if (isCoopMat() || isCoopVecNV() || isLongVector()) {
                                         coopmatNV = false;
                                         coopmatKHR = false;
                                         coopmatKHRuse = 0;
                                         coopmatKHRUseValid = false;
                                         coopvecNV = false;
+                                        longVector = false;
                                         typeParameters = nullptr;
                                     } else if (isTileAttachmentQCOM()) {
                                         tileAttachmentQCOM = false;
@@ -1762,7 +1797,7 @@ public:
                             }
     // for making structures, ...
     TType(TTypeList* userDef, const TString& n) :
-                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), longVector(false),
                             tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1772,7 +1807,7 @@ public:
                             }
     // For interface blocks
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) :
-                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), longVector(false),
                             tileAttachmentQCOM(false), tensorRankARM(0), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1821,6 +1856,7 @@ public:
         coopmatKHRuse = copyOf.coopmatKHRuse;
         coopmatKHRUseValid = copyOf.coopmatKHRUseValid;
         coopvecNV = copyOf.isCoopVecNV();
+        longVector = copyOf.isLongVector();
         tileAttachmentQCOM = copyOf.tileAttachmentQCOM;
         tensorRankARM = copyOf.tensorRankARM;
     }
@@ -1907,7 +1943,7 @@ public:
     virtual const TTypeParameters* getTypeParameters() const { return typeParameters; }
     virtual       TTypeParameters* getTypeParameters()       { return typeParameters; }
 
-    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray() && ! isCoopVecNV(); }
+    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray() && ! isCoopVecNV() && ! isLongVector(); }
     virtual bool isScalarOrVec1() const { return isScalar() || vector1; }
     virtual bool isScalarOrVector() const { return !isMatrix() && !isStruct() && !isArray(); }
     virtual bool isVector() const { return vectorSize > 1u || vector1; }
@@ -1962,9 +1998,12 @@ public:
     bool isCoopMatNV() const { return coopmatNV; }
     bool isCoopMatKHR() const { return coopmatKHR; }
     bool isCoopVecNV() const { return coopvecNV; }
+    bool isCoopMatOrVec() const { return isCoopMat() || isCoopVecNV() || isLongVector(); }
+    bool isLongVector() const { return longVector; }
+    bool isCoopVecOrLongVector() const { return isCoopVecNV() || isLongVector(); }
     bool isTileAttachmentQCOM() const { return tileAttachmentQCOM; }
     bool isTensorARM() const { return tensorRankARM; }
-    bool hasTypeParameter() const { return isCoopMat() || isCoopVecNV() || isTensorARM(); }
+    bool hasTypeParameter() const { return isCoopMat() || isCoopVecNV() || isLongVector() || isTensorARM(); }
     int getTensorRankARM() const { return static_cast<int>(tensorRankARM); }
     bool isReference() const { return getBasicType() == EbtReference; }
     bool isSpirvType() const { return getBasicType() == EbtSpirvType; }
@@ -1997,6 +2036,22 @@ public:
         return contains([](const TType* t) { return t->isArray(); } );
     }
 
+    // Recursively check the structure for any arrays, needed for some error checks
+    virtual bool containsHeapArray() const
+    {
+        const auto containsResourceArray = [](const TType* t) {
+            return (t->isArray() &&
+                    (t->isImage() || t->isTexture() || t->getBasicType() == EbtSampler ||
+                     t->getBasicType() == EbtAccStruct ||
+                     t->getQualifier().storage == EvqUniform ||
+                     t->getQualifier().storage == EvqResourceHeap ||
+                     t->getQualifier().storage == EvqSamplerHeap ||
+                     t->getQualifier().storage == EvqBuffer));
+        };
+
+        return contains(containsResourceArray);
+    }
+
     // Check the structure for any structures, needed for some error checks
     virtual bool containsStructure() const
     {
@@ -2101,6 +2156,10 @@ public:
     {
         return contains([](const TType* t) { return t->coopvecNV; } );
     }
+    bool containsLongVector() const
+    {
+        return contains([](const TType* t) { return t->longVector; } );
+    }
     bool containsReference() const
     {
         return containsBasicType(EbtReference);
@@ -2225,6 +2284,7 @@ public:
         case EbtTensorViewNV:      return "tensorViewNV";
         case EbtCoopvecNV:         return "coopvecNV";
         case EbtTensorARM:         return "tensorARM";
+        case EbtLongVector:        return "vector";
         default:                   return "unknown type";
         }
     }
@@ -2342,11 +2402,29 @@ public:
               if (qualifier.layoutHitObjectShaderRecordEXT)
                 appendStr(" hitobjectshaderrecordext");
 
+              if (qualifier.hasBank()) {
+                appendStr(" bank=");
+                appendUint(qualifier.layoutBank);
+              }
+              if (qualifier.hasMemberOffset()) {
+                appendStr(" member_offset=");
+                appendInt(qualifier.layoutMemberOffset);
+              }
+
               if (qualifier.layoutBindlessSampler)
                   appendStr(" layoutBindlessSampler");
               if (qualifier.layoutBindlessImage)
                   appendStr(" layoutBindlessImage");
 
+              if (qualifier.layoutDescriptorHeap)
+                  appendStr(" descriptor_heap");
+              if (qualifier.layoutDescriptorStride != TQualifier::layoutDescriptorStrideEnd) {
+                  appendStr(" descriptor_stride=");
+                  appendInt(qualifier.layoutDescriptorStride);
+              }
+              if (qualifier.layoutHeapOffset)
+                  appendStr(" heap_offset=");
+
               appendStr(")");
             }
           }
@@ -2551,6 +2629,10 @@ public:
                 appendStr(" ");
                 appendStr("coopvecNV");
               }
+              if (isLongVector()) {
+                appendStr(" ");
+                appendStr("vector");
+              }
 
               appendStr("<");
               for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) {
@@ -2632,7 +2714,7 @@ public:
     {
         uint32_t components = 0;
 
-        if (isCoopVecNV()) {
+        if (isCoopVecOrLongVector()) {
             components = typeParameters->arraySizes->getDimSize(0);
         } else if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) {
             for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++)
@@ -2649,6 +2731,10 @@ public:
         return static_cast<int>(components);
     }
 
+    bool hasSpecConstantVectorComponents() const {
+        return getTypeParameters() && getTypeParameters()->arraySizes->getDimNode(0) != nullptr;
+    }
+
     // append this type's mangled name to the passed in 'name'
     void appendMangledName(TString& name) const
     {
@@ -2839,6 +2925,7 @@ public:
               isCoopMatNV() == right.isCoopMatNV() &&
               isCoopMatKHR() == right.isCoopMatKHR() &&
               isCoopVecNV() == right.isCoopVecNV() &&
+              isLongVector() == right.isLongVector() &&
                isTensorARM() == right.isTensorARM() &&
                sameStructType(right, lpidx, rpidx) &&
                sameReferenceType(right);
@@ -2935,6 +3022,26 @@ public:
         return rv;
     }
 
+    bool sameLongVectorBaseType(const TType &right) const {
+        bool rv = false;
+
+        if (isLongVector() && right.isLongVector()) {
+            if (isFloatingDomain())
+                rv = right.isFloatingDomain() || right.getBasicType() == EbtLongVector;
+            else if (isTypeUnsignedInt(getBasicType()))
+                rv = isTypeUnsignedInt(right.getBasicType()) || right.getBasicType() == EbtLongVector;
+            else if (isTypeSignedInt(getBasicType()))
+                rv = isTypeSignedInt(right.getBasicType()) || right.getBasicType() == EbtLongVector;
+            else if (getBasicType() == EbtBool)
+                rv = right.getBasicType() == EbtBool || right.getBasicType() == EbtLongVector;
+            else if (getBasicType() == EbtLongVector)
+                rv = right.isLongVector();
+            else
+                rv = false;
+        }
+        return rv;
+    }
+
     bool sameCoopMatUse(const TType &right) const {
         return coopmatKHRuse == right.coopmatKHRuse;
     }
@@ -2965,6 +3072,31 @@ public:
         return true;
     }
 
+    bool sameLongVectorShape(const TType &right) const
+    {
+        if (!isLongVector() || !right.isLongVector() || !typeParameters || !right.typeParameters)
+            return false;
+
+        return typeParameters->arraySizes->getDimSize(0) == right.typeParameters->arraySizes->getDimSize(0);
+    }
+
+    static bool vectorAndLongVectorMatch(const TType &left, const TType &right)
+    {
+        if (left.isVector() && right.isLongVector() &&
+            right.getTypeParameters() &&
+            !right.hasSpecConstantVectorComponents() &&
+            left.getVectorSize() == right.getTypeParameters()->arraySizes->getDimSize(0)) {
+            return true;
+        }
+        if (right.isVector() && left.isLongVector() &&
+            left.getTypeParameters() &&
+            !left.hasSpecConstantVectorComponents() &&
+            right.getVectorSize() == left.getTypeParameters()->arraySizes->getDimSize(0)) {
+            return true;
+        }
+        return false;
+    }
+
     // See if two types match in all ways (just the actual type, not qualification)
     bool operator==(const TType& right) const
     {
@@ -3065,6 +3197,7 @@ protected:
     uint32_t coopmatKHRuse    : 3;  // Accepts one of three values: 0, 1, 2 (gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator)
     bool coopmatKHRUseValid   : 1;  // True if coopmatKHRuse has been set
     bool coopvecNV       : 1;
+    bool longVector      : 1;
     bool tileAttachmentQCOM : 1;
     uint32_t tensorRankARM       : 4;  // 0 means not a tensor; non-zero indicates the tensor rank.
     TQualifier qualifier;
diff --git a/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h b/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h
index ccba2fde6..1b70645fe 100644
--- a/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h
+++ b/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h
@@ -213,6 +213,7 @@ typedef enum {
     GLSLANG_SHADER_AUTO_MAP_BINDINGS = (1 << 0),
     GLSLANG_SHADER_AUTO_MAP_LOCATIONS = (1 << 1),
     GLSLANG_SHADER_VULKAN_RULES_RELAXED = (1 << 2),
+    GLSLANG_SHADER_BINDINGS_PER_RESOURCE_TYPE = (1 << 3),
     LAST_ELEMENT_MARKER(GLSLANG_SHADER_COUNT),
 } glslang_shader_options_t;
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp b/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp
index 34bc52999..546d8af85 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp
@@ -394,6 +394,83 @@ void AddTabledBuiltin(TString& decls, const BuiltInFunction& function)
     }
 }
 
+// Add long vector prototype for the builtin function. This is similar to
+// AddTabledBuiltin, but only generates builtins where one type is an
+// arbitrary vector. See comments on "enum ArgClass" for more details.
+void AddLongVectorBuiltin(TString& decls, const BuiltInFunction& function)
+{
+    const auto isScalarType = [](int type) { return (type & TypeStringColumnMask) == 0; };
+
+    // loop across these two:
+    //  0: the varying arg set, and
+    //  1: the fixed scalar args
+    const ArgClass ClassFixed = (ArgClass)(ClassLS | ClassXLS | ClassLS2 | ClassFS | ClassFS2);
+    for (int fixed = 0; fixed < ((function.classes & ClassFixed) > 0 ? 2 : 1); ++fixed) {
+
+        if (fixed == 0 && (function.classes & ClassXLS))
+            continue;
+
+        // Iterate over the different scalar types (needed for ClassRS)
+        for (int type = 0; type < TypeStringCount; ++type) {
+            if (!isScalarType(type))
+                continue;
+
+            // skip types not selected: go from type to row number to type bit
+            if ((function.types & (1 << (type >> TypeStringRowShift))) == 0)
+                continue;
+
+            // skip scalar-only
+            if (function.classes & ClassV1)
+                continue;
+
+            // skip 3-vector
+            if (function.classes & ClassV3)
+                continue;
+
+            TString decl;
+            // return type
+            if (function.classes & ClassB)
+                decl.append("vector");
+            else if (function.classes & ClassRS)
+                decl.append(TypeString[type & TypeStringScalarMask]);
+            else
+                decl.append("vector");
+            decl.append(" ");
+            decl.append(function.name);
+            decl.append("(");
+
+            // arguments
+            for (int arg = 0; arg < function.numArguments; ++arg) {
+                if (arg == function.numArguments - 1 && (function.classes & ClassLO))
+                    decl.append("out ");
+                if (arg == 0) {
+                    if (function.classes & ClassCVN)
+                        decl.append("coherent volatile nontemporal ");
+                    if (function.classes & ClassFIO)
+                        decl.append("inout ");
+                    if (function.classes & ClassFO)
+                        decl.append("out ");
+                }
+                if ((function.classes & ClassLB) && arg == function.numArguments - 1)
+                    decl.append("vector");
+                else if (fixed && ((arg == function.numArguments - 1 && (function.classes & (ClassLS | ClassXLS |
+                                                                                                       ClassLS2))) ||
+                                   (arg == function.numArguments - 2 && (function.classes & ClassLS2))             ||
+                                   (arg == 0                         && (function.classes & (ClassFS | ClassFS2))) ||
+                                   (arg == 1                         && (function.classes & ClassFS2))))
+                    decl.append(TypeString[type & TypeStringScalarMask]);
+                else
+                    decl.append("vector");
+                if (arg < function.numArguments - 1)
+                    decl.append(",");
+            }
+            decl.append(");\n");
+
+            decls.append(decl);
+        }
+    }
+}
+
 // See if the tabled versioning information allows the current version.
 bool ValidVersion(const BuiltInFunction& function, int version, EProfile profile, const SpvVersion& /* spVersion */)
 {
@@ -432,8 +509,12 @@ void TBuiltIns::addTabledBuiltins(int version, EProfile profile, const SpvVersio
 {
     const auto forEachFunction = [&](TString& decls, const span<const BuiltInFunction>& functions) {
         for (const auto& fn : functions) {
-            if (ValidVersion(fn, version, profile, spvVersion))
+            if (ValidVersion(fn, version, profile, spvVersion)) {
                 AddTabledBuiltin(decls, fn);
+                if (profile != EEsProfile) {
+                    AddLongVectorBuiltin(decls, fn);
+                }
+            }
         }
     };
 
@@ -2498,6 +2579,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
                 snprintf(buf, bufSize, op, intTypes[j], intTypes[j]);
                 commonBuiltins.append(buf);
             }
+            snprintf(buf, bufSize, op, "vector", "vector");
+            commonBuiltins.append(buf);
         }
 
         stageBuiltins[EShLangCompute].append(
@@ -5060,12 +5143,124 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
             "coopvecNV log(coopvecNV);\n"            
             "coopvecNV tanh(coopvecNV);\n"            
             "coopvecNV atan(coopvecNV);\n"            
-            "coopvecNV clamp(coopvecNV, coopvecNV, coopvecNV);\n"
-            "\n"
-            ;
+            "coopvecNV clamp(coopvecNV, coopvecNV, coopvecNV);\n";
 
         commonBuiltins.append(cooperativeVectorFuncs.c_str());
 
+        if (profile != EEsProfile) {
+            std::string longVectorFuncs =
+
+                // manually add long vector prototypes for functions not in BaseFunctions/etc
+                "vector frexp(vector, vector);\n"
+                "vector ldexp(vector, vector);\n"
+                "vector fma(vector, vector, vector);\n"
+
+                "vector floatBitsToInt(vector);\n"
+                "vector floatBitsToUint(vector);\n"
+                "vector intBitsToFloat(vector);\n"
+                "vector uintBitsToFloat(vector);\n"
+                "vector doubleBitsToInt64(vector);"
+                "vector doubleBitsToUint64(vector);"
+                "vector int64BitsToDouble(vector);"
+                "vector uint64BitsToDouble(vector);"
+                "vector bfloat16BitsToIntEXT(vector);"
+                "vector bfloat16BitsToUintEXT(vector);"
+                "vector intBitsToBFloat16EXT(vector);"
+                "vector uintBitsToBFloat16EXT(vector);"
+                "vector halfBitsToInt16(vector);"
+                "vector halfBitsToUint16(vector);"
+                "vector float16BitsToInt16(vector);"
+                "vector float16BitsToUint16(vector);"
+                "vector int16BitsToFloat16(vector);"
+                "vector uint16BitsToFloat16(vector);"
+                "vector int16BitsToHalf(vector);"
+                "vector uint16BitsToHalf(vector);"
+                "vector floate5m2BitsToIntEXT(vector);"
+                "vector floate5m2BitsToUintEXT(vector);"
+                "vector intBitsToFloate5m2EXT(vector);"
+                "vector uintBitsToFloate5m2EXT(vector);"
+                "vector floate4m3BitsToIntEXT(vector);"
+                "vector floate4m3BitsToUintEXT(vector);"
+                "vector intBitsToFloate4m3EXT(vector);"
+                "vector uintBitsToFloate4m3EXT(vector);"
+
+                "vector uaddCarry(highp vector, highp vector, out lowp vector carry);"
+                "vector usubBorrow(highp vector, highp vector, out lowp vector borrow);"
+                "void umulExtended(highp vector, highp vector, out highp vector, out highp vector);"
+                "void imulExtended(highp vector, highp vector, out highp vector, out highp vector);"
+                "vector bitfieldExtract(vector, int, int);"
+                "vector bitfieldInsert(vector, vector, int, int);"
+                "vector bitfieldReverse(highp vector);"
+                "vector bitCount(vector);"
+                "vector findLSB(vector);"
+                "vector findMSB(vector);"
+
+                // BaseFunctions overloads with a scalar parameter don't get generated in AddLongVectorBuiltin
+                "vector mod(vector, double);\n"
+                "vector min(vector, double);\n"
+                "vector max(vector, double);\n"
+                "vector clamp(vector, double, double);"
+                "vector mix(vector, vector,  double);"
+                "vector step(double, vector);"
+                "vector smoothstep(double, double, vector);"
+                "vector refract(vector, vector, double);"
+
+                "vector mod(vector, float16_t);\n"
+                "vector min(vector, float16_t);\n"
+                "vector max(vector, float16_t);\n"
+                "vector clamp(vector, float16_t, float16_t);"
+                "vector mix(vector, vector,  float16_t);"
+                "vector step(float16_t, vector);"
+                "vector smoothstep(float16_t, float16_t, vector);"
+                "vector refract(vector, vector, float16_t);"
+
+                "vector min(vector, uint64_t);\n"
+                "vector max(vector, uint64_t);\n"
+                "vector clamp(vector, uint64_t, uint64_t);"
+                "vector mix(vector, vector,  uint64_t);"
+
+                "vector min(vector, int64_t);\n"
+                "vector max(vector, int64_t);\n"
+                "vector clamp(vector, int64_t, int64_t);"
+                "vector mix(vector, vector,  int64_t);"
+
+                "vector min(vector, uint16_t);\n"
+                "vector max(vector, uint16_t);\n"
+                "vector clamp(vector, uint16_t, uint16_t);"
+                "vector mix(vector, vector,  uint16_t);"
+
+                "vector min(vector, int16_t);\n"
+                "vector max(vector, int16_t);\n"
+                "vector clamp(vector, int16_t, int16_t);"
+                "vector mix(vector, vector,  int16_t);"
+
+                "vector min(vector, uint8_t);\n"
+                "vector max(vector, uint8_t);\n"
+                "vector clamp(vector, uint8_t, uint8_t);"
+                "vector mix(vector, vector,  uint8_t);"
+
+                "vector min(vector, int8_t);\n"
+                "vector max(vector, int8_t);\n"
+                "vector clamp(vector, int8_t, int8_t);"
+                "vector mix(vector, vector,  int8_t);"
+
+                "vector expectEXT(vector, vector);"
+                ;
+
+            std::string longVectorDerivativeFuncs =
+                "vector dFdxFine(vector);"
+                "vector dFdyFine(vector);"
+                "vector fwidthFine(vector);"
+                "vector dFdxCoarse(vector);"
+                "vector dFdyCoarse(vector);"
+                "vector fwidthCoarse(vector);"
+
+                ;
+            commonBuiltins.append(longVectorFuncs.c_str());
+            stageBuiltins[EShLangFragment].append(longVectorDerivativeFuncs.c_str());
+            stageBuiltins[EShLangCompute].append(longVectorDerivativeFuncs.c_str());
+        }
+
         const char *scalarAndVectorTypes[] = {
             "int8_t",
             "int16_t",
@@ -11548,4 +11743,407 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
     }
 }
 
+// Determine whether this fnCandidate overload is supported for these arguments.
+// Some of this is based on the BaseFunctions table, but for functions not in that
+// table there's some handcoded logic.
+// If the overload is supported, then this sets the specific parameter/result
+// types and returns true.
+bool IsSupportedLongVectorBuiltin(const TFunction* fnCandidate, TType* resultType, TIntermNode* arguments)
+{
+    TOperator op = fnCandidate->getBuiltInOp();
+
+    const auto &getArg = [&](uint32_t i) {
+        TIntermAggregate* aggregate = arguments->getAsAggregate();
+        return fnCandidate->getParamCount() == 1 ? arguments->getAsTyped() : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped());
+    };
+
+    bool valid = true;
+
+    const auto &checkFnTypes = [&](TIntermTyped *t, uint32_t types) {
+        if (t->getType().isFloatingDomain() && !(types & TypeF)) {
+            valid = false;
+        }
+        if (isTypeSignedInt(t->getType().getBasicType()) && !(types & TypeI)) {
+            valid = false;
+        }
+        if (isTypeUnsignedInt(t->getType().getBasicType()) && !(types & TypeU)) {
+            valid = false;
+        }
+        if (t->getType().getBasicType() == EbtBool && !(types & TypeB)) {
+            valid = false;
+        }
+    };
+
+    const auto &checkShape = [&](TIntermTyped *t0, TIntermTyped *t1) {
+        if (!t0->getType().sameLongVectorShape(t1->getType())) {
+            valid = false;
+        }
+    };
+
+    const auto &checkSameType = [&](TIntermTyped *t0, TIntermTyped *t1) {
+        if (t0->getType() != t1->getType()) {
+            valid = false;
+        }
+    };
+
+    const auto &checkArgsMatch = [&](uint32_t argStart, uint32_t argEnd, uint32_t types) {
+        for (uint32_t i = argStart; i < argEnd; ++i) {
+            checkFnTypes(getArg(i), types);
+            if (i != argStart) {
+                checkSameType(getArg(argStart), getArg(i));
+            }
+        }
+    };
+
+    uint32_t paramCount = fnCandidate->getParamCount();
+
+    bool foundInBase = false;
+    for (const auto &fn : BaseFunctions) {
+        if (fn.op != op) {
+            continue;
+        }
+        valid = true;
+        foundInBase = true;
+
+        TIntermTyped *firstLongVector = nullptr;
+        for (uint32_t i = 0; i < paramCount; ++i) {
+            TIntermTyped* arg = getArg(i);
+
+            ArgType argType = fn.types;
+            if (i == paramCount - 1 && (fn.classes & ClassLB)) {
+                argType = TypeB;
+            }
+
+            checkFnTypes(arg, argType);
+
+            if ((fn.classes & ClassLS) && getArg(paramCount-1)->getType().isScalar()) {
+                if (getArg(paramCount-1)->getType().getBasicType() != arg->getBasicType()) {
+                    valid = false;
+                }
+            }
+
+            if (arg->getType().isLongVector()) {
+                if (firstLongVector != nullptr) {
+                    checkShape(firstLongVector, arg);
+                }
+                if (firstLongVector == nullptr) {
+                    firstLongVector = arg;
+                }
+            }
+        }
+
+        uint32_t argsToMatchStart = 0;
+        uint32_t argsToMatchEnd = paramCount;
+        if (fn.classes & ClassFS)
+            argsToMatchStart++;
+        if (fn.classes & ClassFS2)
+            argsToMatchStart += 2;
+        if ((fn.classes & ClassLS) && getArg(paramCount-1)->getType().isScalar())
+            argsToMatchEnd--;
+        if (fn.classes & ClassXLS)
+            argsToMatchEnd--;
+        if (fn.classes & ClassLS2)
+            argsToMatchEnd -= 2;
+        if (fn.classes & ClassLB)
+            argsToMatchEnd--;
+            
+        checkArgsMatch(argsToMatchStart, argsToMatchEnd, fn.types);
+
+        // These ops (arbitrarily) don't support double precision
+        switch (op) {
+        case EOpRadians:
+        case EOpDegrees:
+        case EOpSin:
+        case EOpCos:
+        case EOpTan:
+        case EOpAcos:
+        case EOpAsin:
+        case EOpAtan:
+        case EOpAcosh:
+        case EOpAsinh:
+        case EOpAtanh:
+        case EOpTanh:
+        case EOpCosh:
+        case EOpSinh:
+        case EOpPow:
+        case EOpExp:
+        case EOpLog:
+        case EOpExp2:
+        case EOpLog2:
+            if (getArg(0)->getType().getBasicType() == EbtDouble) {
+                return false;
+            }
+            break;
+        default:
+            break;
+        }
+
+        if (valid) {
+            // It's valid, so override the types and return true
+            assert(firstLongVector);
+            resultType->deepCopy(firstLongVector->getType());
+            if (fn.classes & ClassB) {
+                resultType->setBasicType(EbtBool);
+            }
+            if (fn.classes & ClassRS) {
+                resultType->deepCopy(TType(firstLongVector->getType().getBasicType()));
+            }
+            if (fn.classes & ClassLO) {
+                getArg(fnCandidate->getParamCount() - 1)->setType(getArg(0)->getType());
+            }
+            return true;
+        }
+    }
+    // If it was in the base table but not supported, fail. The rest of the logic
+    // is for ops not in the base table.
+    if (foundInBase) {
+        return false;
+    }
+
+    // Check the arg0 type and if this and other checks have passed, then set
+    // the result type to the bitcasted result
+    const auto &checkBitCast = [&](TBasicType fromBasicType, TBasicType newBasicType) {
+        if (getArg(0)->getType().getBasicType() != fromBasicType) {
+            valid = false;
+        }
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+            resultType->setBasicType(newBasicType);
+        }
+    };
+
+    valid = true;
+    switch (op) {
+    case EOpFrexp:
+    case EOpLdexp:
+        checkFnTypes(getArg(0), TypeF);
+        checkFnTypes(getArg(1), TypeI);
+        checkShape(getArg(0), getArg(1));
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpFloatBitsToInt:
+        if (fnCandidate->getName() == "bfloat16BitsToIntEXT") {
+            checkBitCast(EbtBFloat16, EbtInt16);
+        } else if (fnCandidate->getName() == "floate5m2BitsToIntEXT") {
+            checkBitCast(EbtFloatE5M2, EbtInt8);
+        } else if (fnCandidate->getName() == "floate4m3BitsToIntEXT") {
+            checkBitCast(EbtFloatE4M3, EbtInt8);
+        } else {
+            checkBitCast(EbtFloat, EbtInt);
+        }
+        return valid;
+    case EOpFloatBitsToUint:
+        if (fnCandidate->getName() == "bfloat16BitsToUintEXT") {
+            checkBitCast(EbtBFloat16, EbtUint16);
+        } else if (fnCandidate->getName() == "floate5m2BitsToUintEXT") {
+            checkBitCast(EbtFloatE5M2, EbtUint8);
+        } else if (fnCandidate->getName() == "floate4m3BitsToUintEXT") {
+            checkBitCast(EbtFloatE4M3, EbtUint8);
+        } else {
+            checkBitCast(EbtFloat, EbtUint);
+        }
+        return valid;
+    case EOpIntBitsToFloat:
+        if (fnCandidate->getName() == "intBitsToBFloat16EXT") {
+            checkBitCast(EbtInt16, EbtBFloat16);
+        } else if (fnCandidate->getName() == "intBitsToFloate5m2EXT") {
+            checkBitCast(EbtInt8, EbtFloatE5M2);
+        } else if (fnCandidate->getName() == "intBitsToFloate4m3EXT") {
+            checkBitCast(EbtInt8, EbtFloatE4M3);
+        } else {
+            checkBitCast(EbtInt, EbtFloat);
+        }
+        return valid;
+    case EOpUintBitsToFloat:
+        if (fnCandidate->getName() == "uintBitsToBFloat16EXT") {
+            checkBitCast(EbtUint16, EbtBFloat16);
+        } else if (fnCandidate->getName() == "uintBitsToFloate5m2EXT") {
+            checkBitCast(EbtUint8, EbtFloatE5M2);
+        } else if (fnCandidate->getName() == "uintBitsToFloate4m3EXT") {
+            checkBitCast(EbtUint8, EbtFloatE4M3);
+        } else {
+            checkBitCast(EbtUint, EbtFloat);
+        }
+        return valid;
+    case EOpDoubleBitsToInt64:
+        checkBitCast(EbtDouble, EbtInt64);
+        return valid;
+    case EOpDoubleBitsToUint64:
+        checkBitCast(EbtDouble, EbtUint64);
+        return valid;
+    case EOpInt64BitsToDouble:
+        checkBitCast(EbtInt64, EbtDouble);
+        return valid;
+    case EOpUint64BitsToDouble:
+        checkBitCast(EbtUint64, EbtDouble);
+        return valid;
+    case EOpFloat16BitsToInt16:
+        checkBitCast(EbtFloat16, EbtInt16);
+        return valid;
+    case EOpFloat16BitsToUint16:
+        checkBitCast(EbtFloat16, EbtUint16);
+        return valid;
+    case EOpInt16BitsToFloat16:
+        checkBitCast(EbtInt16, EbtFloat16);
+        return valid;
+    case EOpUint16BitsToFloat16:
+        checkBitCast(EbtUint16, EbtFloat16);
+        return valid;
+
+    case EOpFma:
+        checkArgsMatch(0, paramCount, TypeF);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpAddCarry:
+    case EOpSubBorrow:
+        checkArgsMatch(0, paramCount, TypeU);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpUMulExtended:
+        checkArgsMatch(0, paramCount, TypeU);
+        return valid;
+    case EOpIMulExtended:
+        checkArgsMatch(0, paramCount, TypeI);
+        return valid;
+    case EOpBitfieldExtract:
+    case EOpBitFieldReverse:
+        checkFnTypes(getArg(0), TypeIU);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpBitfieldInsert:
+        checkArgsMatch(0, 2, TypeIU);
+        checkSameType(getArg(0), getArg(1));
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpFindLSB:
+    case EOpFindMSB:
+    case EOpBitCount:
+        checkFnTypes(getArg(0), TypeIU);
+        if (valid) {
+            TType newType;
+            newType.deepCopy(getArg(0)->getType());
+            newType.setBasicType(unsignedTypeToSigned(newType.getBasicType()));
+            resultType->deepCopy(newType);
+        }
+        return valid;
+    case EOpDPdx:
+    case EOpDPdxFine:
+    case EOpDPdxCoarse:
+    case EOpDPdy:
+    case EOpDPdyFine:
+    case EOpDPdyCoarse:
+    case EOpFwidth:
+    case EOpFwidthFine:
+    case EOpFwidthCoarse:
+        checkFnTypes(getArg(0), TypeF);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpExpectEXT:
+        checkArgsMatch(0, paramCount, TypeIU | TypeB);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+
+    case EOpSubgroupPartition:
+        resultType->deepCopy(TType(EbtUint, EvqTemporary, 4));
+        return valid;
+    case EOpSubgroupAllEqual:
+        resultType->deepCopy(TType(EbtBool));
+        return valid;
+
+    case EOpSubgroupAnd:
+    case EOpSubgroupOr:
+    case EOpSubgroupXor:
+    case EOpSubgroupInclusiveAnd:
+    case EOpSubgroupInclusiveOr:
+    case EOpSubgroupInclusiveXor:
+    case EOpSubgroupExclusiveAnd:
+    case EOpSubgroupExclusiveOr:
+    case EOpSubgroupExclusiveXor:
+    case EOpSubgroupClusteredAnd:
+    case EOpSubgroupClusteredOr:
+    case EOpSubgroupClusteredXor:
+    case EOpSubgroupPartitionedAnd:
+    case EOpSubgroupPartitionedOr:
+    case EOpSubgroupPartitionedXor:
+    case EOpSubgroupPartitionedInclusiveAnd:
+    case EOpSubgroupPartitionedInclusiveOr:
+    case EOpSubgroupPartitionedInclusiveXor:
+    case EOpSubgroupPartitionedExclusiveAnd:
+    case EOpSubgroupPartitionedExclusiveOr:
+    case EOpSubgroupPartitionedExclusiveXor:
+        checkFnTypes(getArg(0), TypeIU | TypeB);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpSubgroupBroadcast:
+    case EOpSubgroupBroadcastFirst:
+    case EOpSubgroupShuffle:
+    case EOpSubgroupShuffleXor:
+    case EOpSubgroupShuffleUp:
+    case EOpSubgroupShuffleDown:
+    case EOpSubgroupRotate:
+    case EOpSubgroupClusteredRotate:
+    case EOpSubgroupQuadBroadcast:
+    case EOpSubgroupQuadSwapHorizontal:
+    case EOpSubgroupQuadSwapVertical:
+    case EOpSubgroupQuadSwapDiagonal:
+        checkFnTypes(getArg(0), TypeIU | TypeB | TypeF);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    case EOpSubgroupAdd:
+    case EOpSubgroupMul:
+    case EOpSubgroupMin:
+    case EOpSubgroupMax:
+    case EOpSubgroupInclusiveAdd:
+    case EOpSubgroupInclusiveMul:
+    case EOpSubgroupInclusiveMin:
+    case EOpSubgroupInclusiveMax:
+    case EOpSubgroupExclusiveAdd:
+    case EOpSubgroupExclusiveMul:
+    case EOpSubgroupExclusiveMin:
+    case EOpSubgroupExclusiveMax:
+    case EOpSubgroupClusteredAdd:
+    case EOpSubgroupClusteredMul:
+    case EOpSubgroupClusteredMin:
+    case EOpSubgroupClusteredMax:
+    case EOpSubgroupPartitionedAdd:
+    case EOpSubgroupPartitionedMul:
+    case EOpSubgroupPartitionedMin:
+    case EOpSubgroupPartitionedMax:
+    case EOpSubgroupPartitionedInclusiveAdd:
+    case EOpSubgroupPartitionedInclusiveMul:
+    case EOpSubgroupPartitionedInclusiveMin:
+    case EOpSubgroupPartitionedInclusiveMax:
+    case EOpSubgroupPartitionedExclusiveAdd:
+    case EOpSubgroupPartitionedExclusiveMul:
+    case EOpSubgroupPartitionedExclusiveMin:
+    case EOpSubgroupPartitionedExclusiveMax:
+        checkFnTypes(getArg(0), TypeIU | TypeF);
+        if (valid) {
+            resultType->deepCopy(getArg(0)->getType());
+        }
+        return valid;
+    default:
+        break;
+    }
+    return false;
+}
+
 } // end namespace glslang
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Initialize.h b/3rdparty/glslang/glslang/MachineIndependent/Initialize.h
index 42c32ddbb..849399af3 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Initialize.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/Initialize.h
@@ -110,6 +110,9 @@ protected:
 // change this back to false if depending on textual spellings of texturing calls when consuming the AST
 // Using PureOperatorBuiltins=false is deprecated.
 constexpr bool PureOperatorBuiltins = true;
+
+bool IsSupportedLongVectorBuiltin(const TFunction* fnCandidate, TType* resultType, TIntermNode* arguments);
+
 } // end namespace glslang
 
 #endif // _INITIALIZE_INCLUDED_
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp b/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp
index 90410f0c1..68e57e387 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp
@@ -407,11 +407,15 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child,
     }
 
     if (newType != EbtVoid) {
-        child = addConversion(op, TType(newType, EvqTemporary, child->getVectorSize(),
-                                                               child->getMatrixCols(),
-                                                               child->getMatrixRows(),
-                                                               child->isVector()),
-                              child);
+        TType newTType(newType, EvqTemporary, child->getVectorSize(), child->getMatrixCols(), child->getMatrixRows(), child->isVector());
+        if (child->getType().isLongVector()) {
+            newTType.shallowCopy(child->getType());
+            newTType.setBasicType(newType);
+            newTType.makeTemporary();
+            newTType.getQualifier().clear();
+        }
+
+        child = addConversion(op, newTType, child);
         if (child == nullptr)
             return nullptr;
     }
@@ -647,6 +651,12 @@ TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped
     }
 
     TType newType(convertTo, EvqTemporary, node->getVectorSize(), node->getMatrixCols(), node->getMatrixRows());
+    if (node->getType().isLongVector()) {
+        newType.shallowCopy(node->getType());
+        newType.setBasicType(convertTo);
+        newType.makeTemporary();
+        newType.getQualifier().clear();
+    }
     newNode = addUnaryNode(newOp, node, node->getLoc(), newType);
 
     if (node->getAsConstantUnion()) {
@@ -1859,7 +1869,7 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
     if (type.isCoopMatKHR())
         return EOpConstructCooperativeMatrixKHR;
 
-    if (type.isCoopVecNV())
+    if (type.isCoopVecOrLongVector())
         return EOpConstructCooperativeVectorNV;
 
     switch (type.getBasicType()) {
@@ -3456,6 +3466,8 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
         return false;
     }
 
+    bool vectorAndLongVectorMatch = TType::vectorAndLongVectorMatch(left->getType(), right->getType());
+
     // Finish handling the case, for all ops, where both operands are scalars.
     if (left->isScalar() && right->isScalar())
         return true;
@@ -3464,6 +3476,10 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
     if (left->isVector() && right->isVector() && left->getVectorSize() != right->getVectorSize() && right->getVectorSize() > 1)
         return false;
 
+    // Finish handling the case, for all ops, where there are two vectors of different sizes
+    if (left->getType().isLongVector() && right->getType().isLongVector() && !left->getType().sameLongVectorShape(right->getType()))
+        return false;
+
     //
     // We now have a mix of scalars, vectors, or matrices, for non-relational operations.
     //
@@ -3549,7 +3565,8 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
         break;
 
     case EOpAssign:
-        if (left->getVectorSize() != right->getVectorSize() || left->getMatrixCols() != right->getMatrixCols() || left->getMatrixRows() != right->getMatrixRows())
+        if ((left->getVectorSize() != right->getVectorSize() || left->getMatrixCols() != right->getMatrixCols() || left->getMatrixRows() != right->getMatrixRows()) &&
+            !vectorAndLongVectorMatch)
             return false;
         [[fallthrough]];
 
@@ -3576,7 +3593,7 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
             return false;
         if (left->isVector() && right->isVector() && left->getVectorSize() != right->getVectorSize())
             return false;
-        if (right->isVector() || right->isMatrix()) {
+        if ((right->isVector() || right->isMatrix()) && !vectorAndLongVectorMatch) {
             node.getWritableType().shallowCopy(right->getType());
             node.getWritableType().getQualifier().makeTemporary();
         }
diff --git a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp
index 38ce7bd69..658ca42d4 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp
@@ -565,7 +565,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn
     variableCheck(base);
 
     if (! base->isArray() && ! base->isMatrix() && ! base->isVector() && ! base->getType().isCoopMat() &&
-        ! base->isReference() && ! base->getType().isCoopVecNV()) {
+        ! base->isReference() && ! base->getType().isCoopVecOrLongVector()) {
         if (base->getAsSymbolNode())
             error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), "");
         else
@@ -996,7 +996,7 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm
             const char* feature = ".length() on vectors and matrices";
             requireProfile(loc, ~EEsProfile, feature);
             profileRequires(loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, feature);
-        } else if (!base->getType().isCoopMat() && !base->getType().isCoopVecNV()) {
+        } else if (!base->getType().isCoopMat() && !base->getType().isCoopVecOrLongVector()) {
             bool enhanced = intermediate.getEnhancedMsgs();
             error(loc, "does not operate on this type:", field.c_str(), base->getType().getCompleteString(enhanced).c_str());
             return base;
@@ -1421,6 +1421,7 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                 if ((*fnCandidate)[0].type->getSampler().isMultiSample() && version <= 140)
                     requireExtensions(loc, 1, &E_GL_ARB_texture_multisample, fnCandidate->getName().c_str());
             }
+            bool hasLongVectorArg = false;
             if (arguments != nullptr) {
                 // Make sure qualifications work for these arguments.
                 TIntermAggregate* aggregate = arguments->getAsAggregate();
@@ -1516,6 +1517,10 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                         }
                     }
 
+                    if (argType.isLongVector()) {
+                        hasLongVectorArg = true;
+                    }
+
                     // TODO 4.5 functionality:  A shader will fail to compile
                     // if the value passed to the memargument of an atomic memory function does not correspond to a buffer or
                     // shared variable. It is acceptable to pass an element of an array or a single component of a vector to the
@@ -1558,6 +1563,12 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                     userFunctionCallCheck(loc, *call);
             }
 
+            if (hasLongVectorArg && fnCandidate->getBuiltInOp() != EOpNull) {
+                TType longVectorResultType(EbtVoid);
+                handleLongVectorBuiltin(loc, fnCandidate, &longVectorResultType, arguments);
+                result->setType(longVectorResultType);
+            }
+
             // Convert 'out' arguments.  If it was a constant folded built-in, it won't be an aggregate anymore.
             // Built-ins with a single argument aren't called with an aggregate, but they also don't have an output.
             // Also, build the qualifier list for user function calls, which are always called with an aggregate.
@@ -1574,7 +1585,7 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
 
             handleVector2CoopMatConversionCall(loc, fnCandidate, result, arguments);
 
-            if (result->getAsTyped()->getType().isCoopVecNV() &&
+            if (result->getAsTyped()->getType().isCoopVecOrLongVector() &&
                !result->getAsTyped()->getType().isParameterized()) {
                 if (auto unaryNode = result->getAsUnaryNode())
                     result->setType(unaryNode->getOperand()->getAsTyped()->getType());
@@ -2179,6 +2190,12 @@ void TParseContext::handleVector2CoopMatConversionCall(const TSourceLoc& loc, co
   }
 }
 
+void TParseContext::handleLongVectorBuiltin(const TSourceLoc& loc, const TFunction* fnCandidate, TType* resultType, TIntermNode* arguments)
+{
+    if (!IsSupportedLongVectorBuiltin(fnCandidate, resultType, arguments)) {
+        error(loc, "can't resolve types (ambiguous long vector overload)", fnCandidate->getName().c_str(), "");
+    }
+}
 
 TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNode* arguments,
                                                        const TFunction& function)
@@ -2187,6 +2204,26 @@ TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNo
     TIntermTyped *result = intermediate.addBuiltInFunctionCall(loc, function.getBuiltInOp(),
                                                                function.getParamCount() == 1,
                                                                arguments, function.getType());
+
+    // EXT_descriptor_heap
+    // All the image atomic ops' first param is image variable.
+    if (extensionTurnedOn(E_GL_EXT_descriptor_heap) && function.getBuiltInOp() <= EOpImageAtomicStore &&
+        function.getBuiltInOp() >= EOpImageAtomicAdd) {
+        TIntermNode* imageNode = nullptr;
+        if (arguments->getAsAggregate() && arguments->getAsAggregate()->getSequence().size() > 0)
+            imageNode = arguments->getAsAggregate()->getSequence()[0];
+        else if (arguments->getAsUnaryNode())
+            imageNode = arguments->getAsUnaryNode();
+
+        if (imageNode && imageNode->getAsBinaryNode()) {
+            auto imageSymbol = imageNode->getAsBinaryNode()->getLeft();
+            if (imageSymbol && imageSymbol->getType().isImage()) {
+                imageSymbol->getQualifier().setUsedByAtomic();
+                result->getQualifier().setUsedByAtomic();
+            }
+        }
+    }
+
     if (result != nullptr && obeyPrecisionQualifiers())
         computeBuiltinPrecisions(*result, function);
 
@@ -2475,7 +2512,7 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction
             length = type.getMatrixCols();
         else if (type.isVector())
             length = type.getVectorSize();
-        else if (type.isCoopMat() || type.isCoopVecNV())
+        else if (type.isCoopMat() || type.isCoopVecOrLongVector())
             return intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, intermNode, TType(EbtInt));
         else {
             // we should not get here, because earlier semantic checking should have prevented this path
@@ -3600,10 +3637,10 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
             error(loc, "second parameter must not have floate5m2 or floate4m3 basic type", "", "");
         }
 
-        if (!(op0Type.isScalar() || op0Type.isVector() || op0Type.isCoopMatKHR())) {
+        if (!(op0Type.isScalar() || op0Type.isVector() || op0Type.isLongVector() || op0Type.isCoopMatKHR())) {
             error(loc, "first parameter must be scalar, vector, or cooperative matrix", "", "");
         }
-        if (!(op1Type.isScalar() || op1Type.isVector() || op1Type.isCoopMatKHR())) {
+        if (!(op1Type.isScalar() || op1Type.isVector() || op1Type.isLongVector() || op1Type.isCoopMatKHR())) {
             error(loc, "second parameter must be scalar, vector, or cooperative matrix", "", "");
         }
         if (!(op0Type.sameElementShape(op1Type) || op0Type.sameCoopMatShape(op1Type))) {
@@ -6289,9 +6326,11 @@ void TParseContext::paramCheckFix(const TSourceLoc& loc, const TQualifier& quali
     paramCheckFixStorage(loc, qualifier.storage, type);
 }
 
-void TParseContext::nestedBlockCheck(const TSourceLoc& loc)
+void TParseContext::nestedBlockCheck(const TSourceLoc& loc, const bool allowedInnerStruct)
 {
-    if (structNestingLevel > 0 || blockNestingLevel > 0)
+    if ((!allowedInnerStruct && structNestingLevel > 0) ||
+        (allowedInnerStruct && structNestingLevel <= 0) ||
+        blockNestingLevel > 0)
         error(loc, "cannot nest a block definition inside a structure or block", "", "");
     ++blockNestingLevel;
 }
@@ -6373,7 +6412,8 @@ void TParseContext::structTypeCheck(const TSourceLoc& /*loc*/, TPublicType& publ
         const TSourceLoc& memberLoc = typeList[member].loc;
         if (memberQualifier.isAuxiliary() ||
             memberQualifier.isInterpolation() ||
-            (memberQualifier.storage != EvqTemporary && memberQualifier.storage != EvqGlobal))
+            (memberQualifier.storage != EvqTemporary && memberQualifier.storage != EvqGlobal &&
+             !memberQualifier.layoutDescriptorHeap && !memberQualifier.layoutDescriptorInnerBlock))
             error(memberLoc, "cannot use storage or interpolation qualifiers on structure members", typeList[member].type->getFieldName().c_str(), "");
         if (memberQualifier.isMemory())
             error(memberLoc, "cannot use memory qualifiers on structure members", typeList[member].type->getFieldName().c_str(), "");
@@ -6667,6 +6707,12 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
             return;
         }
     }
+    if (id == "descriptor_heap") {
+        requireExtensions(loc, 1, &E_GL_EXT_descriptor_heap, "descriptor_stride");
+        requireVulkan(loc, "descriptor_heap");
+        publicType.qualifier.layoutDescriptorHeap = true;
+        return;
+    }
     if (id == "push_constant") {
         requireVulkan(loc, "push_constant");
         publicType.qualifier.layoutPushConstant = true;
@@ -7187,6 +7233,45 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
         return;
     }
 
+    if (id == "bank") {
+        requireExtensions(loc, 1, &E_GL_NV_push_constant_bank, "bank");
+        if (nonLiteral)
+            error(loc, "needs a literal integer", id.c_str(), "");
+        else if (value < 0 || (unsigned int)value >= TQualifier::layoutBankEnd)
+            error(loc, "bank out of range", id.c_str(), "");
+        else
+            publicType.qualifier.layoutBank = value;
+        return;
+    }
+    if (id == "member_offset") {
+        requireExtensions(loc, 1, &E_GL_NV_push_constant_bank, "member_offset");
+        if (nonLiteral)
+            error(loc, "needs a literal integer", id.c_str(), "");
+        else if (value < 0)
+            error(loc, "must be equal or greater than 0", id.c_str(), "");
+        else
+            publicType.qualifier.layoutMemberOffset = value;
+        return;
+    }
+
+    if (id == "descriptor_stride") {
+        requireExtensions(loc, 1, &E_GL_EXT_descriptor_heap, "descriptor_stride");
+        requireVulkan(loc, "descriptor_stride");
+        if (!IsPow2(value))
+            error(loc, "must be a power of 2", "descriptor_stride", "");
+        else
+            publicType.qualifier.layoutDescriptorStride = uint32_t(value);
+        return;
+    }
+
+    if (id == "heap_offset") {
+        requireExtensions(loc, 1, &E_GL_EXT_descriptor_heap, "heap_offset");
+        requireExtensions(loc, 1, &E_GL_EXT_structured_descriptor_heap, "heap_offset");
+        requireVulkan(loc, "heap_offset");
+        publicType.qualifier.layoutHeapOffset = uint32_t(value);
+        return;
+    }
+
     switch (language) {
     case EShLangTessControl:
         if (id == "vertices") {
@@ -7427,6 +7512,14 @@ void TParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifie
             dst.layoutXfbOffset = src.layoutXfbOffset;
         if (src.hasAttachment())
             dst.layoutAttachment = src.layoutAttachment;
+        if (src.layoutDescriptorHeap)
+            dst.layoutDescriptorHeap = true;
+        if (src.layoutDescriptorInnerBlock)
+            dst.layoutDescriptorInnerBlock = true;
+        if (src.layoutDescriptorStride != TQualifier::layoutDescriptorStrideEnd)
+            dst.layoutDescriptorStride = src.layoutDescriptorStride;
+        if (src.layoutHeapOffset != 0)
+            dst.layoutHeapOffset = src.layoutHeapOffset;
         if (src.layoutPushConstant)
             dst.layoutPushConstant = true;
 
@@ -7458,6 +7551,10 @@ void TParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifie
         dst.layoutTileAttachmentQCOM |= src.layoutTileAttachmentQCOM;
         if (src.layoutHitObjectShaderRecordEXT)
             dst.layoutHitObjectShaderRecordEXT = true;
+        if (src.hasBank())
+            dst.layoutBank = src.layoutBank;
+        if (src.hasMemberOffset())
+            dst.layoutMemberOffset = src.layoutMemberOffset;
     }
 }
 
@@ -7713,7 +7810,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
 
         // SPIR-V
         if (spvVersion.spv > 0) {
-            if (qualifier.isUniformOrBuffer()) {
+            if (qualifier.isUniformOrBuffer() && !intermediate.IsRequestedExtension(E_GL_EXT_descriptor_heap)) {
                 if (type.getBasicType() == EbtBlock && !qualifier.isPushConstant() &&
                        !qualifier.isShaderRecord() &&
                        !qualifier.hasAttachment() &&
@@ -7837,6 +7934,8 @@ static bool storageCanHaveLayoutInBlock(const enum TStorageQualifier storage)
     case EvqUniform:
     case EvqBuffer:
     case EvqShared:
+    case EvqSamplerHeap:
+    case EvqResourceHeap:
         return true;
     default:
         return false;
@@ -7972,6 +8071,21 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier
     if (qualifier.storage == EvqHitAttr && qualifier.hasLayout()) {
         error(loc, "cannot apply layout qualifiers to hitAttributeNV variable", "hitAttributeNV", "");
     }
+    if (qualifier.hasBank()) {
+        if (!qualifier.isPushConstant())
+            error(loc, "can only be used with push_constant", "bank", "");
+    }
+    if (qualifier.hasMemberOffset()) {
+        if (!qualifier.isPushConstant())
+            error(loc, "can only be used with push_constant", "member_offset", "");
+    }
+
+    if (qualifier.layoutDescriptorStride != TQualifier::layoutDescriptorStrideEnd &&
+        !qualifier.layoutDescriptorHeap)
+        error(loc, "must specify 'descriptor_heap' to use 'descriptor_stride'", "descriptor_stride", "");
+    if (qualifier.layoutHeapOffset != 0 && !qualifier.layoutDescriptorHeap &&
+        qualifier.storage != EvqSamplerHeap && qualifier.storage != EvqResourceHeap)
+        error(loc, "must specify 'descriptor_heap' to use 'heap_offset'", "heap_offset", "");
 }
 
 // For places that can't have shader-level layout qualifiers
@@ -8303,12 +8417,16 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu
             if (fromElementType == toElementType)
                 return true;
         }
+        if (TType::vectorAndLongVectorMatch(from, to))
+            return true;
         if (from.isArray() || to.isArray() || ! from.sameElementShape(to))
             return false;
         if (from.isCoopMat() && to.isCoopMat())
             return from.sameCoopMatBaseType(to);
         if (from.isCoopVecNV() && to.isCoopVecNV())
             return from.sameCoopVecBaseType(to);
+        if (from.isLongVector() && to.isLongVector())
+            return from.sameLongVectorBaseType(to);
         if (from.isTensorARM() && to.isTensorARM())
             return from.sameTensorBaseTypeARM(to);
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
@@ -8319,10 +8437,13 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu
     // Assumes 'convertible' already said true.
     const auto better = [&](const TType& from, const TType& to1, const TType& to2) -> bool {
         // 1. exact match
-        if (from == to2)
-            return from != to1;
-        if (from == to1)
+        bool to2Matches = from == to2 || (from.isLongVector() && to2.getBasicType() == EbtLongVector);
+        bool to1Matches = from == to1 || (from.isLongVector() && to1.getBasicType() == EbtLongVector);
+        if (to2Matches)
+            return !to1Matches;
+        if (to1Matches)
             return false;
+
         if (extensionTurnedOn(E_GL_NV_gpu_shader5)) {
             // This map refers to the conversion table mentioned under the 
             // section "Modify Section 6.1, Function Definitions, p. 63" in NV_gpu_shader5 spec
@@ -8416,12 +8537,16 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc,
             if (fromElementType == toElementType)
                 return true;
         }
+        if (TType::vectorAndLongVectorMatch(from, to))
+            return true;
         if (from.isArray() || to.isArray() || ! from.sameElementShape(to))
             return false;
         if (from.isCoopMat() && to.isCoopMat())
             return from.sameCoopMatBaseType(to);
         if (from.isCoopVecNV() && to.isCoopVecNV())
             return from.sameCoopVecBaseType(to);
+        if (from.isLongVector() && to.isLongVector())
+            return from.sameLongVectorBaseType(to);
         if (from.isTensorARM() && to.isTensorARM())
             return from.sameTensorBaseTypeARM(to);
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
@@ -8432,9 +8557,11 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc,
     // Assumes 'convertible' already said true.
     const auto better = [this](const TType& from, const TType& to1, const TType& to2) -> bool {
         // 1. exact match
-        if (from == to2)
-            return from != to1;
-        if (from == to1)
+        bool to2Matches = from == to2 || (from.isLongVector() && to2.getBasicType() == EbtLongVector);
+        bool to1Matches = from == to1 || (from.isLongVector() && to1.getBasicType() == EbtLongVector);
+        if (to2Matches)
+            return !to1Matches;
+        if (to1Matches)
             return false;
 
         // 2. Promotion (integral, floating-point) is better
@@ -8728,6 +8855,11 @@ bool TParseContext::vkRelaxedRemapUniformVariable(const TSourceLoc& loc, TString
     // merge qualifiers
     mergeObjectLayoutQualifiers(updatedBlock->getWritableType().getQualifier(), type.getQualifier(), true);
 
+    // set default value for bank when no decoration is present. 
+    if (updatedBlock->getWritableType().getQualifier().isPushConstant() && !updatedBlock->getWritableType().getQualifier().hasBank()) {
+        updatedBlock->getWritableType().getQualifier().layoutBank = 0;
+    }
+
     return true;
 }
 
@@ -9077,7 +9209,15 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
 
         if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 1) {
             error(loc, "expected two type parameters", identifier.c_str(), "");
-        } else if (publicType.typeParameters->arraySizes->getDimSize(0) <= 0) {
+        } else if (publicType.typeParameters->arraySizes->getDimNode(0) == nullptr && publicType.typeParameters->arraySizes->getDimSize(0) <= 0) {
+            error(loc, "expected positive number of components", identifier.c_str(), "");
+        }
+    } else if (type.isLongVector()) {
+        intermediate.setUseStorageBuffer();
+
+        if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 1) {
+            error(loc, "expected two type parameters", identifier.c_str(), "");
+        } else if (publicType.typeParameters->arraySizes->getDimNode(0) == nullptr && publicType.typeParameters->arraySizes->getDimSize(0) <= 0) {
             error(loc, "expected positive number of components", identifier.c_str(), "");
         }
     } else if (type.isTensorARM()) {
@@ -9221,6 +9361,11 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
         initNode = executeInitializer(loc, initializer, variable);
     }
 
+    // EXT_descriptor_heap
+    if (!untypedHeapCheck(symbol, type, loc, identifier.c_str())) {
+        return nullptr;
+    }
+
     // look for errors in layout qualifier use
     layoutObjectCheck(loc, *symbol);
 
@@ -10162,6 +10307,60 @@ void TParseContext::updateBindlessQualifier(TType& memberType)
     }
 }
 
+void TParseContext::descHeapBuiltinRemap(TType* type, bool isInnerBlock)
+{
+    if (type->isStruct()) {
+        TTypeList* types = type->getWritableStruct();
+        for (auto typeLoc : *types) {
+            descHeapBuiltinRemap(typeLoc.type, isInnerBlock);
+        }
+    }
+
+    auto* qualifier = &type->getQualifier();
+    if (type->getBasicType() == EbtSampler) {
+        if (type->isImage() || type->isTexture())
+            qualifier->builtIn = EbvResourceHeapEXT;
+        else
+            qualifier->builtIn = EbvSamplerHeapEXT;
+        qualifier->layoutDescriptorHeap = true;
+    } else if (qualifier->isUniformOrBuffer() || type->getBasicType() == EbtAccStruct) {
+        qualifier->builtIn = EbvResourceHeapEXT;
+        qualifier->layoutDescriptorHeap = true;
+        qualifier->layoutDescriptorInnerBlock = isInnerBlock;
+    }
+ }
+
+bool TParseContext::untypedHeapCheck(TSymbol* symbol, const TType& type, const TSourceLoc& loc, const char* name)
+{
+    // EXT_descriptor_heap
+    bool isHeapStruct =
+        (type.getQualifier().storage == EvqSamplerHeap || type.getQualifier().storage == EvqResourceHeap);
+
+    if (intermediate.IsRequestedExtension(E_GL_EXT_descriptor_heap) && spvVersion.vulkan > 0 &&
+        !type.getQualifier().hasSet() && !type.getQualifier().hasBinding()) {
+        if (type.getQualifier().layoutDescriptorHeap || isHeapStruct) {
+            if ((intermediate.isEsProfile() && intermediate.getVersion() < 310) ||
+                (!intermediate.isEsProfile() && intermediate.getVersion() < 420)) {
+                TString warnMsg = "layout(descriptor_heap) is turned on beyond version/profile limits.";
+                infoSink.info.message(EPrefixWarning, warnMsg.c_str());
+            }
+            if (IsAnonymous(symbol->getName()) &&
+                (type.getQualifier().isUniformOrBuffer() || type.getBasicType() == EbtBlock)) {
+                error(loc, "layout(descriptor_heap) decorated block should be explicitly "
+                    "declared with a run-time sized array type.", name, "");
+                return false;
+            }
+            if (!type.containsHeapArray()) {
+                error(loc, "layout(descriptor_heap) decorated variable could only be declared as an array.",
+                      name, "");
+                return false;
+            }
+            descHeapBuiltinRemap(&symbol->getWritableType(), isHeapStruct);
+        }
+    }
+    return true;
+}
+
 //
 // Do everything needed to add an interface block. Returns the declarator node if there's an instance declaration.
 //
@@ -10213,12 +10412,12 @@ TIntermNode* TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeL
         }
 
         // For bindless texture, sampler can be declared as uniform/storage block member,
-        if (memberType.containsOpaque()) {
+        if (memberType.containsOpaque() && !extensionTurnedOn(E_GL_EXT_structured_descriptor_heap)) {
             if (memberType.containsSampler() && extensionTurnedOn(E_GL_ARB_bindless_texture))
                 updateBindlessQualifier(memberType);
             else
                 error(memberLoc, "member of block cannot be or contain a sampler, image, or atomic_uint type", typeList[member].type->getFieldName().c_str(), "");
-            }
+        }
 
         if (memberType.containsCoopMat())
             error(memberLoc, "member of block cannot be or contain a cooperative matrix type", typeList[member].type->getFieldName().c_str(), "");
@@ -10444,6 +10643,11 @@ TIntermNode* TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeL
         return nullptr;
     }
 
+    // EXT_descriptor_heap
+    if (!untypedHeapCheck(&variable, blockType, loc, blockName->c_str())) {
+        return nullptr;
+    }
+
     // Check for general layout qualifier errors
     layoutObjectCheck(loc, variable);
 
@@ -10559,6 +10763,14 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
         profileRequires(loc, ~EEsProfile, 460, E_GL_EXT_shader_invocation_reorder, "hitObjectAttributeEXT block");
         requireStage(loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | EShLangMissMask), "hitObjectAttributeEXT block");
         break;
+    case EvqResourceHeap:
+        profileRequires(loc, ~EEsProfile, 460, E_GL_EXT_structured_descriptor_heap, "resourceheap block");
+        profileRequires(loc, ~EEsProfile, 460, E_GL_EXT_descriptor_heap, "resourceheap block");
+        break;
+    case EvqSamplerHeap:
+        profileRequires(loc, ~EEsProfile, 460, E_GL_EXT_structured_descriptor_heap, "samplerheap block");
+        profileRequires(loc, ~EEsProfile, 460, E_GL_EXT_descriptor_heap, "samplerheap block");
+        break;
     default:
         error(loc, "only uniform, buffer, in, or out blocks are supported", blockName->c_str(), "");
         break;
diff --git a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h
index bf5cab2aa..785c9c68b 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h
@@ -416,7 +416,7 @@ public:
     void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes);
     void paramCheckFixStorage(const TSourceLoc&, const TStorageQualifier&, TType& type);
     void paramCheckFix(const TSourceLoc&, const TQualifier&, TType& type);
-    void nestedBlockCheck(const TSourceLoc&);
+    void nestedBlockCheck(const TSourceLoc&, const bool allowedInnerStruct = false);
     void nestedStructCheck(const TSourceLoc&);
     void arrayObjectCheck(const TSourceLoc&, const TType&, const char* op);
     void opaqueCheck(const TSourceLoc&, const TType&, const char* op);
@@ -456,6 +456,8 @@ public:
     TParameter getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer,
                                    const TSourceLoc& loc);
     void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to);
+    void descHeapBuiltinRemap(TType* type, bool isInnerBlock);
+    bool untypedHeapCheck(TSymbol* symbol, const TType& type, const TSourceLoc& loc, const char* name);
     TIntermNode* declareBlock(const TSourceLoc&, TTypeList& typeList, const TString* instanceName = nullptr, TArraySizes* arraySizes = nullptr);
     void blockStorageRemap(const TSourceLoc&, const TString*, TQualifier&);
     void blockStageIoCheck(const TSourceLoc&, const TQualifier&);
@@ -516,6 +518,7 @@ protected:
     void finish() override;
     void handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* result, TIntermNode* arguments);
     void handleVector2CoopMatConversionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* &result, TIntermNode* arguments);
+    void handleLongVectorBuiltin(const TSourceLoc& loc, const TFunction* fnCandidate, TType* resultType, TIntermNode* arguments);
 
     virtual const char* getGlobalUniformBlockName() const override;
     virtual void finalizeGlobalUniformBlockLayout(TVariable&) override;
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp b/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp
index 8a08a3c87..665a92e66 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp
@@ -779,6 +779,9 @@ const std::unordered_map<const char*, int, str_hash, str_eq> KeywordMap {
     {"tensorViewNV",TENSORVIEWNV},
 
     {"coopvecNV",COOPVECNV},
+    {"vector",VECTOR},
+    {"resourceheap",RESOURCEHEAP},
+    {"samplerheap",SAMPLERHEAP},
 };
 const std::unordered_set<const char*, str_hash, str_eq> ReservedSet {
     "common",
@@ -1353,13 +1356,14 @@ int TScanContext::tokenizeIdentifier()
     case U64VEC2:
     case U64VEC3:
     case U64VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int64))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int64)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case INT8_T:
@@ -1370,13 +1374,14 @@ int TScanContext::tokenizeIdentifier()
     case U8VEC2:
     case U8VEC3:
     case U8VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_8bit_storage) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case INT16_T:
@@ -1387,14 +1392,15 @@ int TScanContext::tokenizeIdentifier()
     case U16VEC2:
     case U16VEC3:
     case U16VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
     case INT32_T:
     case UINT32_T:
@@ -1404,23 +1410,25 @@ int TScanContext::tokenizeIdentifier()
     case U32VEC2:
     case U32VEC3:
     case U32VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int32))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int32)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
     case FLOAT32_T:
     case F32VEC2:
     case F32VEC3:
     case F32VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float32))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float32)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
     case F32MAT2:
     case F32MAT3:
@@ -1434,25 +1442,27 @@ int TScanContext::tokenizeIdentifier()
     case F32MAT4X2:
     case F32MAT4X3:
     case F32MAT4X4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float32))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float32)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case FLOAT64_T:
     case F64VEC2:
     case F64VEC3:
     case F64VEC4:
-    afterType = true;
-    if (parseContext.symbolTable.atBuiltInLevel() ||
-        parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
-        (parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) && 
-         parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_fp64)) ||
-        parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float64))
-        return keyword;
-    return identifierOrType();
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
+            (parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) && 
+             parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_fp64)) ||
+             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float64)) {
+            afterType = true;
+            return keyword;
+        }
+        return identifierOrType();
     case F64MAT2:
     case F64MAT3:
     case F64MAT4:
@@ -1465,26 +1475,27 @@ int TScanContext::tokenizeIdentifier()
     case F64MAT4X2:
     case F64MAT4X3:
     case F64MAT4X4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float64))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float64)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case FLOAT16_T:
     case F16VEC2:
     case F16VEC3:
     case F16VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
             parseContext.extensionTurnedOn(E_GL_NV_gpu_shader5) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16)) {
+            afterType = true;
             return keyword;
-
+        }
         return identifierOrType();
 
     case F16MAT2:
@@ -1499,12 +1510,13 @@ int TScanContext::tokenizeIdentifier()
     case F16MAT4X2:
     case F16MAT4X3:
     case F16MAT4X4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
             parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) ||
             parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
-            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16))
+            parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16)) {
+            afterType = true;
             return keyword;
+        }
 
         return identifierOrType();
 
@@ -1512,10 +1524,11 @@ int TScanContext::tokenizeIdentifier()
     case BF16VEC2:
     case BF16VEC3:
     case BF16VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_EXT_bfloat16))
+            parseContext.extensionTurnedOn(E_GL_EXT_bfloat16)) {
+            afterType = true;
             return keyword;
+        }
 
         return identifierOrType();
 
@@ -1523,10 +1536,11 @@ int TScanContext::tokenizeIdentifier()
     case FE5M2VEC2:
     case FE5M2VEC3:
     case FE5M2VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_EXT_float_e5m2))
+            parseContext.extensionTurnedOn(E_GL_EXT_float_e5m2)) {
+            afterType = true;
             return keyword;
+        }
 
         return identifierOrType();
 
@@ -1534,10 +1548,11 @@ int TScanContext::tokenizeIdentifier()
     case FE4M3VEC2:
     case FE4M3VEC3:
     case FE4M3VEC4:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_EXT_float_e4m3))
+            parseContext.extensionTurnedOn(E_GL_EXT_float_e4m3)) {
+            afterType = true;
             return keyword;
+        }
 
         return identifierOrType();
 
@@ -1806,10 +1821,11 @@ int TScanContext::tokenizeIdentifier()
 
     case F16SUBPASSINPUT:
     case F16SUBPASSINPUTMS:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch))
+            parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case EXPLICITINTERPAMD:
@@ -1858,38 +1874,51 @@ int TScanContext::tokenizeIdentifier()
         return identifierOrType();
 
     case FCOOPMATNV:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix))
+            parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case UCOOPMATNV:
     case ICOOPMATNV:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_NV_integer_cooperative_matrix))
+            parseContext.extensionTurnedOn(E_GL_NV_integer_cooperative_matrix)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
     case TENSORARM:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_ARM_tensors))
+            parseContext.extensionTurnedOn(E_GL_ARM_tensors)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case COOPMAT:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_KHR_cooperative_matrix))
+            parseContext.extensionTurnedOn(E_GL_KHR_cooperative_matrix)) {
+            afterType = true;
             return keyword;
+        }
         return identifierOrType();
 
     case COOPVECNV:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_NV_cooperative_vector))
+            parseContext.extensionTurnedOn(E_GL_NV_cooperative_vector)) {
+            afterType = true;
             return keyword;
+        }
+        return identifierOrType();
+
+    case VECTOR:
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            parseContext.extensionTurnedOn(E_GL_EXT_long_vector)) {
+            afterType = true;
+            return keyword;
+        }
         return identifierOrType();
 
     case DEMOTE:
@@ -1944,9 +1973,17 @@ int TScanContext::tokenizeIdentifier()
     case FUNCTION:
     case TENSORLAYOUTNV:
     case TENSORVIEWNV:
-        afterType = true;
         if (parseContext.symbolTable.atBuiltInLevel() ||
-            parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix2))
+            parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix2)) {
+            afterType = true;
+            return keyword;
+        }
+        return identifierOrType();
+
+    case RESOURCEHEAP:
+    case SAMPLERHEAP:
+        if (parseContext.extensionTurnedOn(E_GL_EXT_structured_descriptor_heap) &&
+            parseContext.extensionTurnedOn(E_GL_EXT_descriptor_heap))
             return keyword;
         return identifierOrType();
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/ShaderLang.cpp b/3rdparty/glslang/glslang/MachineIndependent/ShaderLang.cpp
index 62d72535b..7a0433c11 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/ShaderLang.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/ShaderLang.cpp
@@ -1855,6 +1855,7 @@ void TShader::setUniformLocationBase(int base)
 {
     intermediate->setUniformLocationBase(base);
 }
+void TShader::setBindingsPerResourceType() { intermediate->setBindingsPerResourceType(); }
 void TShader::setNoStorageFormat(bool useUnknownFormat) { intermediate->setNoStorageFormat(useUnknownFormat); }
 void TShader::setResourceSetBinding(const std::vector<std::string>& base)   { intermediate->setResourceSetBinding(base); }
 void TShader::setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode) { intermediate->setTextureSamplerTransformMode(mode); }
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp b/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp
index e01f96be4..4238d4f6c 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp
@@ -317,6 +317,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_NV_cooperative_matrix2]                   = EBhDisable;
     extensionBehavior[E_GL_NV_cluster_acceleration_structure]        = EBhDisable;
     extensionBehavior[E_GL_NV_linear_swept_spheres]                  = EBhDisable;
+    extensionBehavior[E_GL_NV_push_constant_bank]                    = EBhDisable;
 
     // ARM
     extensionBehavior[E_GL_ARM_shader_core_builtins]                 = EBhDisable;
@@ -345,6 +346,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_texture_buffer]                       = EBhDisable;
     extensionBehavior[E_GL_EXT_texture_cube_map_array]               = EBhDisable;
     extensionBehavior[E_GL_EXT_null_initializer]                     = EBhDisable;
+    extensionBehavior[E_GL_EXT_descriptor_heap]                      = EBhDisable;
 
     // OES matching AEP
     extensionBehavior[E_GL_OES_geometry_shader]          = EBhDisable;
@@ -389,6 +391,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_uniform_buffer_unsized_array] = EBhDisable;
     extensionBehavior[E_GL_EXT_shader_64bit_indexing]       = EBhDisable;
     extensionBehavior[E_GL_EXT_conservative_depth]          = EBhDisable;
+    extensionBehavior[E_GL_EXT_long_vector]                 = EBhDisable;
 
     // OVR extensions
     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -457,6 +460,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_shader_implicit_conversions 1\n"
             "#define GL_EXT_shader_integer_mix 1\n"
             "#define GL_EXT_blend_func_extended 1\n"
+            "#define GL_EXT_descriptor_heap 1\n"
 
             // OES matching AEP
             "#define GL_OES_geometry_shader 1\n"
@@ -639,6 +643,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_shader_64bit_indexing 1\n"
 
             "#define GL_EXT_shader_invocation_reorder 1\n"
+            "#define GL_EXT_descriptor_heap 1\n"
             ;
 
         if (spvVersion.spv == 0) {
@@ -662,6 +667,11 @@ void TParseVersions::getPreamble(std::string& preamble)
         }
     }
 
+    if ((!isEsProfile() && version >= 460) ||
+        (isEsProfile() && version >= 320)) {
+        preamble += "#define GL_EXT_nontemporal_keyword 1\n";
+    }
+
     if ((!isEsProfile() && version >= 140) ||
         (isEsProfile() && version >= 310)) {
         preamble +=
@@ -1519,6 +1529,14 @@ void TParseVersions::tensorCheckARM(const TSourceLoc& loc, const char* op, bool
     }
 }
 
+void TParseVersions::longVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_EXT_long_vector};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
 // Call for any operation removed because SPIR-V is in use.
 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
 {
diff --git a/3rdparty/glslang/glslang/MachineIndependent/Versions.h b/3rdparty/glslang/glslang/MachineIndependent/Versions.h
index 48a7c5b6b..cfc6ea3fb 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/Versions.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/Versions.h
@@ -229,6 +229,8 @@ const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_of
 const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
 const char* const E_GL_EXT_uniform_buffer_unsized_array     = "GL_EXT_uniform_buffer_unsized_array";
 const char* const E_GL_EXT_conservative_depth               = "GL_EXT_conservative_depth";
+const char* const E_GL_EXT_descriptor_heap                  = "GL_EXT_descriptor_heap";
+const char* const E_GL_EXT_structured_descriptor_heap       = "GL_EXT_structured_descriptor_heap";
 
 // Arrays of extensions for the above viewportEXTs duplications
 
@@ -293,6 +295,7 @@ const char* const E_GL_NV_cooperative_vector                    = "GL_NV_coopera
 const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
 const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
 const char* const E_GL_NV_gpu_shader5                           = "GL_NV_gpu_shader5";
+const char* const E_GL_NV_push_constant_bank                    = "GL_NV_push_constant_bank";
 
 // ARM
 const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
@@ -366,6 +369,7 @@ const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_inte
 const char* const E_GL_EXT_bfloat16 = "GL_EXT_bfloat16";
 const char* const E_GL_EXT_float_e5m2 = "GL_EXT_float_e5m2";
 const char* const E_GL_EXT_float_e4m3 = "GL_EXT_float_e4m3";
+const char* const E_GL_EXT_long_vector = "GL_EXT_long_vector";
 
 const char* const E_GL_EXT_shader_64bit_indexing = "GL_EXT_shader_64bit_indexing";
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang.y b/3rdparty/glslang/glslang/MachineIndependent/glslang.y
index 9758048df..ac39aff0b 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/glslang.y
+++ b/3rdparty/glslang/glslang/MachineIndependent/glslang.y
@@ -182,6 +182,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
 %token <lex> COOPMAT
 %token <lex> COOPVECNV
+%token <lex> VECTOR
 %token <lex> HITOBJECTNV HITOBJECTATTRNV HITOBJECTEXT HITOBJECTATTREXT
 %token <lex> TENSORLAYOUTNV TENSORVIEWNV
 %token <lex> TENSORARM
@@ -284,7 +285,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> SUBROUTINE DEMOTE FUNCTION
 %token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV 
 %token <lex> PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT
-%token <lex> PATCH SAMPLE NONUNIFORM
+%token <lex> PATCH SAMPLE NONUNIFORM RESOURCEHEAP SAMPLERHEAP
 %token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY NONTEMPORAL DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
 %token <lex> SUBGROUPCOHERENT NONPRIVATE SHADERCALLCOHERENT
 %token <lex> NOPERSPECTIVE EXPLICITINTERPAMD PERVERTEXEXT PERVERTEXNV PERPRIMITIVENV PERVIEWNV PERTASKNV PERPRIMITIVEEXT TASKPAYLOADWORKGROUPEXT
@@ -326,8 +327,10 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %type <interm.type> single_type_qualifier
 %type <interm.type> type_specifier_nonarray
 %type <interm.type> struct_specifier
+%type <interm.type> block_heap_inner_structure
 %type <interm.typeLine> struct_declarator
 %type <interm.typeList> struct_declarator_list struct_declaration struct_declaration_list
+%type <interm.typeList> struct_declaration_with_heap struct_declaration_without_heap
 %type <interm> block_structure
 %type <interm.function> function_header function_declarator
 %type <interm.function> function_header_with_parameters
@@ -934,7 +937,7 @@ declaration
     ;
 
 block_structure
-    : type_qualifier IDENTIFIER LEFT_BRACE { parseContext.nestedBlockCheck($1.loc); } struct_declaration_list RIGHT_BRACE {
+    : type_qualifier IDENTIFIER LEFT_BRACE { parseContext.nestedBlockCheck($1.loc); } struct_declaration_without_heap RIGHT_BRACE {
         --parseContext.blockNestingLevel;
         parseContext.blockName = $2.string;
         parseContext.globalQualifierFixCheck($1.loc, $1.qualifier);
@@ -943,6 +946,7 @@ block_structure
         $$.loc = $1.loc;
         $$.typeList = $5;
     }
+    ;
 
 identifier_list
     : IDENTIFIER {
@@ -1530,6 +1534,16 @@ storage_qualifier
         $$.init($1.loc);
         $$.qualifier.sample = true;
     }
+    | RESOURCEHEAP {
+        parseContext.globalCheck($1.loc, "resourceHeap");
+        $$.init($1.loc);
+        $$.qualifier.storage = EvqResourceHeap;
+    }
+    | SAMPLERHEAP {
+        parseContext.globalCheck($1.loc, "samplerHeap");
+        $$.init($1.loc);
+        $$.qualifier.storage = EvqSamplerHeap;
+    }
     | HITATTRNV {
         parseContext.globalCheck($1.loc, "hitAttributeNV");
         parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -3652,6 +3666,12 @@ type_specifier_nonarray
         $$.tensorRankARM = 1; // placeholder value
         $$.basicType = EbtTensorARM;
     }
+    | VECTOR {
+        parseContext.longVectorCheck($1.loc, "vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtLongVector;
+        $$.longVector = true;
+    }
     | spirv_type_specifier {
         parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
         $$ = $1;
@@ -3704,7 +3724,6 @@ precision_qualifier
 
 struct_specifier
     : STRUCT IDENTIFIER LEFT_BRACE { parseContext.nestedStructCheck($1.loc); } struct_declaration_list RIGHT_BRACE {
-
         TType* structure = new TType($5, *$2.string);
         parseContext.structArrayCheck($2.loc, *structure);
 
@@ -3730,10 +3749,71 @@ struct_specifier
     ;
 
 struct_declaration_list
+    : struct_declaration_without_heap {
+        $$ = $1;
+    }
+    | struct_declaration_with_heap {
+        $$ = $1;
+    }
+    | struct_declaration_with_heap struct_declaration_without_heap {
+        $$ = $1;
+        for (unsigned int i = 0; i < $2->size(); ++i) {
+            for (unsigned int j = 0; j < $$->size(); ++j) {
+                if ((*$$)[j].type->getFieldName() == (*$2)[i].type->getFieldName())
+                    parseContext.error((*$2)[i].loc, "duplicate member name:", "", (*$2)[i].type->getFieldName().c_str());
+            }
+            $$->push_back((*$2)[i]);
+        }
+    }
+    | struct_declaration_without_heap struct_declaration_with_heap {
+        $$ = $1;
+        for (unsigned int i = 0; i < $2->size(); ++i) {
+            for (unsigned int j = 0; j < $$->size(); ++j) {
+                if ((*$$)[j].type->getFieldName() == (*$2)[i].type->getFieldName())
+                    parseContext.error((*$2)[i].loc, "duplicate member name:", "", (*$2)[i].type->getFieldName().c_str());
+            }
+            $$->push_back((*$2)[i]);
+        }
+    }
+    ;
+
+struct_declaration_with_heap
+    : block_heap_inner_structure struct_declarator_list SEMICOLON {
+        $$ = $2;
+        parseContext.voidErrorCheck($1.loc, (*$2)[0].type->getFieldName(), $1.basicType);
+        parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.hasTypeParameter());
+
+        for (unsigned int i = 0; i < $$->size(); ++i) {
+            TType type($1);
+            type.setFieldName((*$$)[i].type->getFieldName());
+            type.transferArraySizes((*$$)[i].type->getArraySizes());
+            type.copyArrayInnerSizes($1.arraySizes);
+            parseContext.arrayOfArrayVersionCheck((*$$)[i].loc, type.getArraySizes());
+            (*$$)[i].type->shallowCopy(type);
+        }
+    }
+    ;
+
+block_heap_inner_structure
+    : type_qualifier LEFT_BRACE { parseContext.nestedBlockCheck($1.loc, true); } struct_declaration_without_heap RIGHT_BRACE {
+        --parseContext.blockNestingLevel;
+        parseContext.globalQualifierFixCheck($1.loc, $1.qualifier);
+        parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers);
+        $$.init($1.loc);
+        TType* innerStructure = new TType($4, TString(""));
+        $$.basicType = EbtBlock;
+        $$.userDef = innerStructure;
+        $$.qualifier = $1.qualifier;
+        $$.qualifier.layoutDescriptorHeap = true;
+        $$.qualifier.layoutDescriptorInnerBlock = true;
+    }
+    ;
+
+struct_declaration_without_heap
     : struct_declaration {
         $$ = $1;
     }
-    | struct_declaration_list struct_declaration {
+    | struct_declaration_without_heap struct_declaration {
         $$ = $1;
         for (unsigned int i = 0; i < $2->size(); ++i) {
             for (unsigned int j = 0; j < $$->size(); ++j) {
diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp
index f0ec8c6a0..50db001d4 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp
@@ -301,443 +301,450 @@ enum yysymbol_kind_t
   YYSYMBOL_UCOOPMATNV = 177,               /* UCOOPMATNV  */
   YYSYMBOL_COOPMAT = 178,                  /* COOPMAT  */
   YYSYMBOL_COOPVECNV = 179,                /* COOPVECNV  */
-  YYSYMBOL_HITOBJECTNV = 180,              /* HITOBJECTNV  */
-  YYSYMBOL_HITOBJECTATTRNV = 181,          /* HITOBJECTATTRNV  */
-  YYSYMBOL_HITOBJECTEXT = 182,             /* HITOBJECTEXT  */
-  YYSYMBOL_HITOBJECTATTREXT = 183,         /* HITOBJECTATTREXT  */
-  YYSYMBOL_TENSORLAYOUTNV = 184,           /* TENSORLAYOUTNV  */
-  YYSYMBOL_TENSORVIEWNV = 185,             /* TENSORVIEWNV  */
-  YYSYMBOL_TENSORARM = 186,                /* TENSORARM  */
-  YYSYMBOL_SAMPLERCUBEARRAY = 187,         /* SAMPLERCUBEARRAY  */
-  YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 188,   /* SAMPLERCUBEARRAYSHADOW  */
-  YYSYMBOL_ISAMPLERCUBEARRAY = 189,        /* ISAMPLERCUBEARRAY  */
-  YYSYMBOL_USAMPLERCUBEARRAY = 190,        /* USAMPLERCUBEARRAY  */
-  YYSYMBOL_SAMPLER1D = 191,                /* SAMPLER1D  */
-  YYSYMBOL_SAMPLER1DARRAY = 192,           /* SAMPLER1DARRAY  */
-  YYSYMBOL_SAMPLER1DARRAYSHADOW = 193,     /* SAMPLER1DARRAYSHADOW  */
-  YYSYMBOL_ISAMPLER1D = 194,               /* ISAMPLER1D  */
-  YYSYMBOL_SAMPLER1DSHADOW = 195,          /* SAMPLER1DSHADOW  */
-  YYSYMBOL_SAMPLER2DRECT = 196,            /* SAMPLER2DRECT  */
-  YYSYMBOL_SAMPLER2DRECTSHADOW = 197,      /* SAMPLER2DRECTSHADOW  */
-  YYSYMBOL_ISAMPLER2DRECT = 198,           /* ISAMPLER2DRECT  */
-  YYSYMBOL_USAMPLER2DRECT = 199,           /* USAMPLER2DRECT  */
-  YYSYMBOL_SAMPLERBUFFER = 200,            /* SAMPLERBUFFER  */
-  YYSYMBOL_ISAMPLERBUFFER = 201,           /* ISAMPLERBUFFER  */
-  YYSYMBOL_USAMPLERBUFFER = 202,           /* USAMPLERBUFFER  */
-  YYSYMBOL_SAMPLER2DMS = 203,              /* SAMPLER2DMS  */
-  YYSYMBOL_ISAMPLER2DMS = 204,             /* ISAMPLER2DMS  */
-  YYSYMBOL_USAMPLER2DMS = 205,             /* USAMPLER2DMS  */
-  YYSYMBOL_SAMPLER2DMSARRAY = 206,         /* SAMPLER2DMSARRAY  */
-  YYSYMBOL_ISAMPLER2DMSARRAY = 207,        /* ISAMPLER2DMSARRAY  */
-  YYSYMBOL_USAMPLER2DMSARRAY = 208,        /* USAMPLER2DMSARRAY  */
-  YYSYMBOL_SAMPLEREXTERNALOES = 209,       /* SAMPLEREXTERNALOES  */
-  YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 210,  /* SAMPLEREXTERNAL2DY2YEXT  */
-  YYSYMBOL_ISAMPLER1DARRAY = 211,          /* ISAMPLER1DARRAY  */
-  YYSYMBOL_USAMPLER1D = 212,               /* USAMPLER1D  */
-  YYSYMBOL_USAMPLER1DARRAY = 213,          /* USAMPLER1DARRAY  */
-  YYSYMBOL_F16SAMPLER1D = 214,             /* F16SAMPLER1D  */
-  YYSYMBOL_F16SAMPLER2D = 215,             /* F16SAMPLER2D  */
-  YYSYMBOL_F16SAMPLER3D = 216,             /* F16SAMPLER3D  */
-  YYSYMBOL_F16SAMPLER2DRECT = 217,         /* F16SAMPLER2DRECT  */
-  YYSYMBOL_F16SAMPLERCUBE = 218,           /* F16SAMPLERCUBE  */
-  YYSYMBOL_F16SAMPLER1DARRAY = 219,        /* F16SAMPLER1DARRAY  */
-  YYSYMBOL_F16SAMPLER2DARRAY = 220,        /* F16SAMPLER2DARRAY  */
-  YYSYMBOL_F16SAMPLERCUBEARRAY = 221,      /* F16SAMPLERCUBEARRAY  */
-  YYSYMBOL_F16SAMPLERBUFFER = 222,         /* F16SAMPLERBUFFER  */
-  YYSYMBOL_F16SAMPLER2DMS = 223,           /* F16SAMPLER2DMS  */
-  YYSYMBOL_F16SAMPLER2DMSARRAY = 224,      /* F16SAMPLER2DMSARRAY  */
-  YYSYMBOL_F16SAMPLER1DSHADOW = 225,       /* F16SAMPLER1DSHADOW  */
-  YYSYMBOL_F16SAMPLER2DSHADOW = 226,       /* F16SAMPLER2DSHADOW  */
-  YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 227,  /* F16SAMPLER1DARRAYSHADOW  */
-  YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 228,  /* F16SAMPLER2DARRAYSHADOW  */
-  YYSYMBOL_F16SAMPLER2DRECTSHADOW = 229,   /* F16SAMPLER2DRECTSHADOW  */
-  YYSYMBOL_F16SAMPLERCUBESHADOW = 230,     /* F16SAMPLERCUBESHADOW  */
-  YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 231, /* F16SAMPLERCUBEARRAYSHADOW  */
-  YYSYMBOL_IMAGE1D = 232,                  /* IMAGE1D  */
-  YYSYMBOL_IIMAGE1D = 233,                 /* IIMAGE1D  */
-  YYSYMBOL_UIMAGE1D = 234,                 /* UIMAGE1D  */
-  YYSYMBOL_IMAGE2D = 235,                  /* IMAGE2D  */
-  YYSYMBOL_IIMAGE2D = 236,                 /* IIMAGE2D  */
-  YYSYMBOL_UIMAGE2D = 237,                 /* UIMAGE2D  */
-  YYSYMBOL_IMAGE3D = 238,                  /* IMAGE3D  */
-  YYSYMBOL_IIMAGE3D = 239,                 /* IIMAGE3D  */
-  YYSYMBOL_UIMAGE3D = 240,                 /* UIMAGE3D  */
-  YYSYMBOL_IMAGE2DRECT = 241,              /* IMAGE2DRECT  */
-  YYSYMBOL_IIMAGE2DRECT = 242,             /* IIMAGE2DRECT  */
-  YYSYMBOL_UIMAGE2DRECT = 243,             /* UIMAGE2DRECT  */
-  YYSYMBOL_IMAGECUBE = 244,                /* IMAGECUBE  */
-  YYSYMBOL_IIMAGECUBE = 245,               /* IIMAGECUBE  */
-  YYSYMBOL_UIMAGECUBE = 246,               /* UIMAGECUBE  */
-  YYSYMBOL_IMAGEBUFFER = 247,              /* IMAGEBUFFER  */
-  YYSYMBOL_IIMAGEBUFFER = 248,             /* IIMAGEBUFFER  */
-  YYSYMBOL_UIMAGEBUFFER = 249,             /* UIMAGEBUFFER  */
-  YYSYMBOL_IMAGE1DARRAY = 250,             /* IMAGE1DARRAY  */
-  YYSYMBOL_IIMAGE1DARRAY = 251,            /* IIMAGE1DARRAY  */
-  YYSYMBOL_UIMAGE1DARRAY = 252,            /* UIMAGE1DARRAY  */
-  YYSYMBOL_IMAGE2DARRAY = 253,             /* IMAGE2DARRAY  */
-  YYSYMBOL_IIMAGE2DARRAY = 254,            /* IIMAGE2DARRAY  */
-  YYSYMBOL_UIMAGE2DARRAY = 255,            /* UIMAGE2DARRAY  */
-  YYSYMBOL_IMAGECUBEARRAY = 256,           /* IMAGECUBEARRAY  */
-  YYSYMBOL_IIMAGECUBEARRAY = 257,          /* IIMAGECUBEARRAY  */
-  YYSYMBOL_UIMAGECUBEARRAY = 258,          /* UIMAGECUBEARRAY  */
-  YYSYMBOL_IMAGE2DMS = 259,                /* IMAGE2DMS  */
-  YYSYMBOL_IIMAGE2DMS = 260,               /* IIMAGE2DMS  */
-  YYSYMBOL_UIMAGE2DMS = 261,               /* UIMAGE2DMS  */
-  YYSYMBOL_IMAGE2DMSARRAY = 262,           /* IMAGE2DMSARRAY  */
-  YYSYMBOL_IIMAGE2DMSARRAY = 263,          /* IIMAGE2DMSARRAY  */
-  YYSYMBOL_UIMAGE2DMSARRAY = 264,          /* UIMAGE2DMSARRAY  */
-  YYSYMBOL_F16IMAGE1D = 265,               /* F16IMAGE1D  */
-  YYSYMBOL_F16IMAGE2D = 266,               /* F16IMAGE2D  */
-  YYSYMBOL_F16IMAGE3D = 267,               /* F16IMAGE3D  */
-  YYSYMBOL_F16IMAGE2DRECT = 268,           /* F16IMAGE2DRECT  */
-  YYSYMBOL_F16IMAGECUBE = 269,             /* F16IMAGECUBE  */
-  YYSYMBOL_F16IMAGE1DARRAY = 270,          /* F16IMAGE1DARRAY  */
-  YYSYMBOL_F16IMAGE2DARRAY = 271,          /* F16IMAGE2DARRAY  */
-  YYSYMBOL_F16IMAGECUBEARRAY = 272,        /* F16IMAGECUBEARRAY  */
-  YYSYMBOL_F16IMAGEBUFFER = 273,           /* F16IMAGEBUFFER  */
-  YYSYMBOL_F16IMAGE2DMS = 274,             /* F16IMAGE2DMS  */
-  YYSYMBOL_F16IMAGE2DMSARRAY = 275,        /* F16IMAGE2DMSARRAY  */
-  YYSYMBOL_I64IMAGE1D = 276,               /* I64IMAGE1D  */
-  YYSYMBOL_U64IMAGE1D = 277,               /* U64IMAGE1D  */
-  YYSYMBOL_I64IMAGE2D = 278,               /* I64IMAGE2D  */
-  YYSYMBOL_U64IMAGE2D = 279,               /* U64IMAGE2D  */
-  YYSYMBOL_I64IMAGE3D = 280,               /* I64IMAGE3D  */
-  YYSYMBOL_U64IMAGE3D = 281,               /* U64IMAGE3D  */
-  YYSYMBOL_I64IMAGE2DRECT = 282,           /* I64IMAGE2DRECT  */
-  YYSYMBOL_U64IMAGE2DRECT = 283,           /* U64IMAGE2DRECT  */
-  YYSYMBOL_I64IMAGECUBE = 284,             /* I64IMAGECUBE  */
-  YYSYMBOL_U64IMAGECUBE = 285,             /* U64IMAGECUBE  */
-  YYSYMBOL_I64IMAGEBUFFER = 286,           /* I64IMAGEBUFFER  */
-  YYSYMBOL_U64IMAGEBUFFER = 287,           /* U64IMAGEBUFFER  */
-  YYSYMBOL_I64IMAGE1DARRAY = 288,          /* I64IMAGE1DARRAY  */
-  YYSYMBOL_U64IMAGE1DARRAY = 289,          /* U64IMAGE1DARRAY  */
-  YYSYMBOL_I64IMAGE2DARRAY = 290,          /* I64IMAGE2DARRAY  */
-  YYSYMBOL_U64IMAGE2DARRAY = 291,          /* U64IMAGE2DARRAY  */
-  YYSYMBOL_I64IMAGECUBEARRAY = 292,        /* I64IMAGECUBEARRAY  */
-  YYSYMBOL_U64IMAGECUBEARRAY = 293,        /* U64IMAGECUBEARRAY  */
-  YYSYMBOL_I64IMAGE2DMS = 294,             /* I64IMAGE2DMS  */
-  YYSYMBOL_U64IMAGE2DMS = 295,             /* U64IMAGE2DMS  */
-  YYSYMBOL_I64IMAGE2DMSARRAY = 296,        /* I64IMAGE2DMSARRAY  */
-  YYSYMBOL_U64IMAGE2DMSARRAY = 297,        /* U64IMAGE2DMSARRAY  */
-  YYSYMBOL_TEXTURECUBEARRAY = 298,         /* TEXTURECUBEARRAY  */
-  YYSYMBOL_ITEXTURECUBEARRAY = 299,        /* ITEXTURECUBEARRAY  */
-  YYSYMBOL_UTEXTURECUBEARRAY = 300,        /* UTEXTURECUBEARRAY  */
-  YYSYMBOL_TEXTURE1D = 301,                /* TEXTURE1D  */
-  YYSYMBOL_ITEXTURE1D = 302,               /* ITEXTURE1D  */
-  YYSYMBOL_UTEXTURE1D = 303,               /* UTEXTURE1D  */
-  YYSYMBOL_TEXTURE1DARRAY = 304,           /* TEXTURE1DARRAY  */
-  YYSYMBOL_ITEXTURE1DARRAY = 305,          /* ITEXTURE1DARRAY  */
-  YYSYMBOL_UTEXTURE1DARRAY = 306,          /* UTEXTURE1DARRAY  */
-  YYSYMBOL_TEXTURE2DRECT = 307,            /* TEXTURE2DRECT  */
-  YYSYMBOL_ITEXTURE2DRECT = 308,           /* ITEXTURE2DRECT  */
-  YYSYMBOL_UTEXTURE2DRECT = 309,           /* UTEXTURE2DRECT  */
-  YYSYMBOL_TEXTUREBUFFER = 310,            /* TEXTUREBUFFER  */
-  YYSYMBOL_ITEXTUREBUFFER = 311,           /* ITEXTUREBUFFER  */
-  YYSYMBOL_UTEXTUREBUFFER = 312,           /* UTEXTUREBUFFER  */
-  YYSYMBOL_TEXTURE2DMS = 313,              /* TEXTURE2DMS  */
-  YYSYMBOL_ITEXTURE2DMS = 314,             /* ITEXTURE2DMS  */
-  YYSYMBOL_UTEXTURE2DMS = 315,             /* UTEXTURE2DMS  */
-  YYSYMBOL_TEXTURE2DMSARRAY = 316,         /* TEXTURE2DMSARRAY  */
-  YYSYMBOL_ITEXTURE2DMSARRAY = 317,        /* ITEXTURE2DMSARRAY  */
-  YYSYMBOL_UTEXTURE2DMSARRAY = 318,        /* UTEXTURE2DMSARRAY  */
-  YYSYMBOL_F16TEXTURE1D = 319,             /* F16TEXTURE1D  */
-  YYSYMBOL_F16TEXTURE2D = 320,             /* F16TEXTURE2D  */
-  YYSYMBOL_F16TEXTURE3D = 321,             /* F16TEXTURE3D  */
-  YYSYMBOL_F16TEXTURE2DRECT = 322,         /* F16TEXTURE2DRECT  */
-  YYSYMBOL_F16TEXTURECUBE = 323,           /* F16TEXTURECUBE  */
-  YYSYMBOL_F16TEXTURE1DARRAY = 324,        /* F16TEXTURE1DARRAY  */
-  YYSYMBOL_F16TEXTURE2DARRAY = 325,        /* F16TEXTURE2DARRAY  */
-  YYSYMBOL_F16TEXTURECUBEARRAY = 326,      /* F16TEXTURECUBEARRAY  */
-  YYSYMBOL_F16TEXTUREBUFFER = 327,         /* F16TEXTUREBUFFER  */
-  YYSYMBOL_F16TEXTURE2DMS = 328,           /* F16TEXTURE2DMS  */
-  YYSYMBOL_F16TEXTURE2DMSARRAY = 329,      /* F16TEXTURE2DMSARRAY  */
-  YYSYMBOL_SUBPASSINPUT = 330,             /* SUBPASSINPUT  */
-  YYSYMBOL_SUBPASSINPUTMS = 331,           /* SUBPASSINPUTMS  */
-  YYSYMBOL_ISUBPASSINPUT = 332,            /* ISUBPASSINPUT  */
-  YYSYMBOL_ISUBPASSINPUTMS = 333,          /* ISUBPASSINPUTMS  */
-  YYSYMBOL_USUBPASSINPUT = 334,            /* USUBPASSINPUT  */
-  YYSYMBOL_USUBPASSINPUTMS = 335,          /* USUBPASSINPUTMS  */
-  YYSYMBOL_F16SUBPASSINPUT = 336,          /* F16SUBPASSINPUT  */
-  YYSYMBOL_F16SUBPASSINPUTMS = 337,        /* F16SUBPASSINPUTMS  */
-  YYSYMBOL_SPIRV_INSTRUCTION = 338,        /* SPIRV_INSTRUCTION  */
-  YYSYMBOL_SPIRV_EXECUTION_MODE = 339,     /* SPIRV_EXECUTION_MODE  */
-  YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 340,  /* SPIRV_EXECUTION_MODE_ID  */
-  YYSYMBOL_SPIRV_DECORATE = 341,           /* SPIRV_DECORATE  */
-  YYSYMBOL_SPIRV_DECORATE_ID = 342,        /* SPIRV_DECORATE_ID  */
-  YYSYMBOL_SPIRV_DECORATE_STRING = 343,    /* SPIRV_DECORATE_STRING  */
-  YYSYMBOL_SPIRV_TYPE = 344,               /* SPIRV_TYPE  */
-  YYSYMBOL_SPIRV_STORAGE_CLASS = 345,      /* SPIRV_STORAGE_CLASS  */
-  YYSYMBOL_SPIRV_BY_REFERENCE = 346,       /* SPIRV_BY_REFERENCE  */
-  YYSYMBOL_SPIRV_LITERAL = 347,            /* SPIRV_LITERAL  */
-  YYSYMBOL_ATTACHMENTEXT = 348,            /* ATTACHMENTEXT  */
-  YYSYMBOL_IATTACHMENTEXT = 349,           /* IATTACHMENTEXT  */
-  YYSYMBOL_UATTACHMENTEXT = 350,           /* UATTACHMENTEXT  */
-  YYSYMBOL_LEFT_OP = 351,                  /* LEFT_OP  */
-  YYSYMBOL_RIGHT_OP = 352,                 /* RIGHT_OP  */
-  YYSYMBOL_INC_OP = 353,                   /* INC_OP  */
-  YYSYMBOL_DEC_OP = 354,                   /* DEC_OP  */
-  YYSYMBOL_LE_OP = 355,                    /* LE_OP  */
-  YYSYMBOL_GE_OP = 356,                    /* GE_OP  */
-  YYSYMBOL_EQ_OP = 357,                    /* EQ_OP  */
-  YYSYMBOL_NE_OP = 358,                    /* NE_OP  */
-  YYSYMBOL_AND_OP = 359,                   /* AND_OP  */
-  YYSYMBOL_OR_OP = 360,                    /* OR_OP  */
-  YYSYMBOL_XOR_OP = 361,                   /* XOR_OP  */
-  YYSYMBOL_MUL_ASSIGN = 362,               /* MUL_ASSIGN  */
-  YYSYMBOL_DIV_ASSIGN = 363,               /* DIV_ASSIGN  */
-  YYSYMBOL_ADD_ASSIGN = 364,               /* ADD_ASSIGN  */
-  YYSYMBOL_MOD_ASSIGN = 365,               /* MOD_ASSIGN  */
-  YYSYMBOL_LEFT_ASSIGN = 366,              /* LEFT_ASSIGN  */
-  YYSYMBOL_RIGHT_ASSIGN = 367,             /* RIGHT_ASSIGN  */
-  YYSYMBOL_AND_ASSIGN = 368,               /* AND_ASSIGN  */
-  YYSYMBOL_XOR_ASSIGN = 369,               /* XOR_ASSIGN  */
-  YYSYMBOL_OR_ASSIGN = 370,                /* OR_ASSIGN  */
-  YYSYMBOL_SUB_ASSIGN = 371,               /* SUB_ASSIGN  */
-  YYSYMBOL_STRING_LITERAL = 372,           /* STRING_LITERAL  */
-  YYSYMBOL_LEFT_PAREN = 373,               /* LEFT_PAREN  */
-  YYSYMBOL_RIGHT_PAREN = 374,              /* RIGHT_PAREN  */
-  YYSYMBOL_LEFT_BRACKET = 375,             /* LEFT_BRACKET  */
-  YYSYMBOL_RIGHT_BRACKET = 376,            /* RIGHT_BRACKET  */
-  YYSYMBOL_LEFT_BRACE = 377,               /* LEFT_BRACE  */
-  YYSYMBOL_RIGHT_BRACE = 378,              /* RIGHT_BRACE  */
-  YYSYMBOL_DOT = 379,                      /* DOT  */
-  YYSYMBOL_COMMA = 380,                    /* COMMA  */
-  YYSYMBOL_COLON = 381,                    /* COLON  */
-  YYSYMBOL_EQUAL = 382,                    /* EQUAL  */
-  YYSYMBOL_SEMICOLON = 383,                /* SEMICOLON  */
-  YYSYMBOL_BANG = 384,                     /* BANG  */
-  YYSYMBOL_DASH = 385,                     /* DASH  */
-  YYSYMBOL_TILDE = 386,                    /* TILDE  */
-  YYSYMBOL_PLUS = 387,                     /* PLUS  */
-  YYSYMBOL_STAR = 388,                     /* STAR  */
-  YYSYMBOL_SLASH = 389,                    /* SLASH  */
-  YYSYMBOL_PERCENT = 390,                  /* PERCENT  */
-  YYSYMBOL_LEFT_ANGLE = 391,               /* LEFT_ANGLE  */
-  YYSYMBOL_RIGHT_ANGLE = 392,              /* RIGHT_ANGLE  */
-  YYSYMBOL_VERTICAL_BAR = 393,             /* VERTICAL_BAR  */
-  YYSYMBOL_CARET = 394,                    /* CARET  */
-  YYSYMBOL_AMPERSAND = 395,                /* AMPERSAND  */
-  YYSYMBOL_QUESTION = 396,                 /* QUESTION  */
-  YYSYMBOL_INVARIANT = 397,                /* INVARIANT  */
-  YYSYMBOL_HIGH_PRECISION = 398,           /* HIGH_PRECISION  */
-  YYSYMBOL_MEDIUM_PRECISION = 399,         /* MEDIUM_PRECISION  */
-  YYSYMBOL_LOW_PRECISION = 400,            /* LOW_PRECISION  */
-  YYSYMBOL_PRECISION = 401,                /* PRECISION  */
-  YYSYMBOL_PACKED = 402,                   /* PACKED  */
-  YYSYMBOL_RESOURCE = 403,                 /* RESOURCE  */
-  YYSYMBOL_SUPERP = 404,                   /* SUPERP  */
-  YYSYMBOL_FLOATCONSTANT = 405,            /* FLOATCONSTANT  */
-  YYSYMBOL_INTCONSTANT = 406,              /* INTCONSTANT  */
-  YYSYMBOL_UINTCONSTANT = 407,             /* UINTCONSTANT  */
-  YYSYMBOL_BOOLCONSTANT = 408,             /* BOOLCONSTANT  */
-  YYSYMBOL_IDENTIFIER = 409,               /* IDENTIFIER  */
-  YYSYMBOL_TYPE_NAME = 410,                /* TYPE_NAME  */
-  YYSYMBOL_CENTROID = 411,                 /* CENTROID  */
-  YYSYMBOL_IN = 412,                       /* IN  */
-  YYSYMBOL_OUT = 413,                      /* OUT  */
-  YYSYMBOL_INOUT = 414,                    /* INOUT  */
-  YYSYMBOL_STRUCT = 415,                   /* STRUCT  */
-  YYSYMBOL_VOID = 416,                     /* VOID  */
-  YYSYMBOL_WHILE = 417,                    /* WHILE  */
-  YYSYMBOL_BREAK = 418,                    /* BREAK  */
-  YYSYMBOL_CONTINUE = 419,                 /* CONTINUE  */
-  YYSYMBOL_DO = 420,                       /* DO  */
-  YYSYMBOL_ELSE = 421,                     /* ELSE  */
-  YYSYMBOL_FOR = 422,                      /* FOR  */
-  YYSYMBOL_IF = 423,                       /* IF  */
-  YYSYMBOL_DISCARD = 424,                  /* DISCARD  */
-  YYSYMBOL_RETURN = 425,                   /* RETURN  */
-  YYSYMBOL_SWITCH = 426,                   /* SWITCH  */
-  YYSYMBOL_CASE = 427,                     /* CASE  */
-  YYSYMBOL_DEFAULT = 428,                  /* DEFAULT  */
-  YYSYMBOL_TERMINATE_INVOCATION = 429,     /* TERMINATE_INVOCATION  */
-  YYSYMBOL_TERMINATE_RAY = 430,            /* TERMINATE_RAY  */
-  YYSYMBOL_IGNORE_INTERSECTION = 431,      /* IGNORE_INTERSECTION  */
-  YYSYMBOL_UNIFORM = 432,                  /* UNIFORM  */
-  YYSYMBOL_SHARED = 433,                   /* SHARED  */
-  YYSYMBOL_BUFFER = 434,                   /* BUFFER  */
-  YYSYMBOL_TILEIMAGEEXT = 435,             /* TILEIMAGEEXT  */
-  YYSYMBOL_FLAT = 436,                     /* FLAT  */
-  YYSYMBOL_SMOOTH = 437,                   /* SMOOTH  */
-  YYSYMBOL_LAYOUT = 438,                   /* LAYOUT  */
-  YYSYMBOL_DOUBLECONSTANT = 439,           /* DOUBLECONSTANT  */
-  YYSYMBOL_INT16CONSTANT = 440,            /* INT16CONSTANT  */
-  YYSYMBOL_UINT16CONSTANT = 441,           /* UINT16CONSTANT  */
-  YYSYMBOL_FLOAT16CONSTANT = 442,          /* FLOAT16CONSTANT  */
-  YYSYMBOL_INT32CONSTANT = 443,            /* INT32CONSTANT  */
-  YYSYMBOL_UINT32CONSTANT = 444,           /* UINT32CONSTANT  */
-  YYSYMBOL_INT64CONSTANT = 445,            /* INT64CONSTANT  */
-  YYSYMBOL_UINT64CONSTANT = 446,           /* UINT64CONSTANT  */
-  YYSYMBOL_SUBROUTINE = 447,               /* SUBROUTINE  */
-  YYSYMBOL_DEMOTE = 448,                   /* DEMOTE  */
-  YYSYMBOL_FUNCTION = 449,                 /* FUNCTION  */
-  YYSYMBOL_PAYLOADNV = 450,                /* PAYLOADNV  */
-  YYSYMBOL_PAYLOADINNV = 451,              /* PAYLOADINNV  */
-  YYSYMBOL_HITATTRNV = 452,                /* HITATTRNV  */
-  YYSYMBOL_CALLDATANV = 453,               /* CALLDATANV  */
-  YYSYMBOL_CALLDATAINNV = 454,             /* CALLDATAINNV  */
-  YYSYMBOL_PAYLOADEXT = 455,               /* PAYLOADEXT  */
-  YYSYMBOL_PAYLOADINEXT = 456,             /* PAYLOADINEXT  */
-  YYSYMBOL_HITATTREXT = 457,               /* HITATTREXT  */
-  YYSYMBOL_CALLDATAEXT = 458,              /* CALLDATAEXT  */
-  YYSYMBOL_CALLDATAINEXT = 459,            /* CALLDATAINEXT  */
-  YYSYMBOL_PATCH = 460,                    /* PATCH  */
-  YYSYMBOL_SAMPLE = 461,                   /* SAMPLE  */
-  YYSYMBOL_NONUNIFORM = 462,               /* NONUNIFORM  */
-  YYSYMBOL_COHERENT = 463,                 /* COHERENT  */
-  YYSYMBOL_VOLATILE = 464,                 /* VOLATILE  */
-  YYSYMBOL_RESTRICT = 465,                 /* RESTRICT  */
-  YYSYMBOL_READONLY = 466,                 /* READONLY  */
-  YYSYMBOL_WRITEONLY = 467,                /* WRITEONLY  */
-  YYSYMBOL_NONTEMPORAL = 468,              /* NONTEMPORAL  */
-  YYSYMBOL_DEVICECOHERENT = 469,           /* DEVICECOHERENT  */
-  YYSYMBOL_QUEUEFAMILYCOHERENT = 470,      /* QUEUEFAMILYCOHERENT  */
-  YYSYMBOL_WORKGROUPCOHERENT = 471,        /* WORKGROUPCOHERENT  */
-  YYSYMBOL_SUBGROUPCOHERENT = 472,         /* SUBGROUPCOHERENT  */
-  YYSYMBOL_NONPRIVATE = 473,               /* NONPRIVATE  */
-  YYSYMBOL_SHADERCALLCOHERENT = 474,       /* SHADERCALLCOHERENT  */
-  YYSYMBOL_NOPERSPECTIVE = 475,            /* NOPERSPECTIVE  */
-  YYSYMBOL_EXPLICITINTERPAMD = 476,        /* EXPLICITINTERPAMD  */
-  YYSYMBOL_PERVERTEXEXT = 477,             /* PERVERTEXEXT  */
-  YYSYMBOL_PERVERTEXNV = 478,              /* PERVERTEXNV  */
-  YYSYMBOL_PERPRIMITIVENV = 479,           /* PERPRIMITIVENV  */
-  YYSYMBOL_PERVIEWNV = 480,                /* PERVIEWNV  */
-  YYSYMBOL_PERTASKNV = 481,                /* PERTASKNV  */
-  YYSYMBOL_PERPRIMITIVEEXT = 482,          /* PERPRIMITIVEEXT  */
-  YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 483,  /* TASKPAYLOADWORKGROUPEXT  */
-  YYSYMBOL_PRECISE = 484,                  /* PRECISE  */
-  YYSYMBOL_YYACCEPT = 485,                 /* $accept  */
-  YYSYMBOL_variable_identifier = 486,      /* variable_identifier  */
-  YYSYMBOL_primary_expression = 487,       /* primary_expression  */
-  YYSYMBOL_postfix_expression = 488,       /* postfix_expression  */
-  YYSYMBOL_integer_expression = 489,       /* integer_expression  */
-  YYSYMBOL_function_call = 490,            /* function_call  */
-  YYSYMBOL_function_call_or_method = 491,  /* function_call_or_method  */
-  YYSYMBOL_function_call_generic = 492,    /* function_call_generic  */
-  YYSYMBOL_function_call_header_no_parameters = 493, /* function_call_header_no_parameters  */
-  YYSYMBOL_function_call_header_with_parameters = 494, /* function_call_header_with_parameters  */
-  YYSYMBOL_function_call_header = 495,     /* function_call_header  */
-  YYSYMBOL_function_identifier = 496,      /* function_identifier  */
-  YYSYMBOL_unary_expression = 497,         /* unary_expression  */
-  YYSYMBOL_unary_operator = 498,           /* unary_operator  */
-  YYSYMBOL_multiplicative_expression = 499, /* multiplicative_expression  */
-  YYSYMBOL_additive_expression = 500,      /* additive_expression  */
-  YYSYMBOL_shift_expression = 501,         /* shift_expression  */
-  YYSYMBOL_relational_expression = 502,    /* relational_expression  */
-  YYSYMBOL_equality_expression = 503,      /* equality_expression  */
-  YYSYMBOL_and_expression = 504,           /* and_expression  */
-  YYSYMBOL_exclusive_or_expression = 505,  /* exclusive_or_expression  */
-  YYSYMBOL_inclusive_or_expression = 506,  /* inclusive_or_expression  */
-  YYSYMBOL_logical_and_expression = 507,   /* logical_and_expression  */
-  YYSYMBOL_logical_xor_expression = 508,   /* logical_xor_expression  */
-  YYSYMBOL_logical_or_expression = 509,    /* logical_or_expression  */
-  YYSYMBOL_conditional_expression = 510,   /* conditional_expression  */
-  YYSYMBOL_511_1 = 511,                    /* $@1  */
-  YYSYMBOL_assignment_expression = 512,    /* assignment_expression  */
-  YYSYMBOL_assignment_operator = 513,      /* assignment_operator  */
-  YYSYMBOL_expression = 514,               /* expression  */
-  YYSYMBOL_constant_expression = 515,      /* constant_expression  */
-  YYSYMBOL_declaration = 516,              /* declaration  */
-  YYSYMBOL_block_structure = 517,          /* block_structure  */
-  YYSYMBOL_518_2 = 518,                    /* $@2  */
-  YYSYMBOL_identifier_list = 519,          /* identifier_list  */
-  YYSYMBOL_function_prototype = 520,       /* function_prototype  */
-  YYSYMBOL_function_declarator = 521,      /* function_declarator  */
-  YYSYMBOL_function_header_with_parameters = 522, /* function_header_with_parameters  */
-  YYSYMBOL_function_header = 523,          /* function_header  */
-  YYSYMBOL_parameter_declarator = 524,     /* parameter_declarator  */
-  YYSYMBOL_parameter_declaration = 525,    /* parameter_declaration  */
-  YYSYMBOL_parameter_type_specifier = 526, /* parameter_type_specifier  */
-  YYSYMBOL_init_declarator_list = 527,     /* init_declarator_list  */
-  YYSYMBOL_single_declaration = 528,       /* single_declaration  */
-  YYSYMBOL_fully_specified_type = 529,     /* fully_specified_type  */
-  YYSYMBOL_invariant_qualifier = 530,      /* invariant_qualifier  */
-  YYSYMBOL_interpolation_qualifier = 531,  /* interpolation_qualifier  */
-  YYSYMBOL_layout_qualifier = 532,         /* layout_qualifier  */
-  YYSYMBOL_layout_qualifier_id_list = 533, /* layout_qualifier_id_list  */
-  YYSYMBOL_layout_qualifier_id = 534,      /* layout_qualifier_id  */
-  YYSYMBOL_precise_qualifier = 535,        /* precise_qualifier  */
-  YYSYMBOL_type_qualifier = 536,           /* type_qualifier  */
-  YYSYMBOL_single_type_qualifier = 537,    /* single_type_qualifier  */
-  YYSYMBOL_storage_qualifier = 538,        /* storage_qualifier  */
-  YYSYMBOL_non_uniform_qualifier = 539,    /* non_uniform_qualifier  */
-  YYSYMBOL_type_name_list = 540,           /* type_name_list  */
-  YYSYMBOL_type_specifier = 541,           /* type_specifier  */
-  YYSYMBOL_array_specifier = 542,          /* array_specifier  */
-  YYSYMBOL_type_parameter_specifier_opt = 543, /* type_parameter_specifier_opt  */
-  YYSYMBOL_type_parameter_specifier = 544, /* type_parameter_specifier  */
-  YYSYMBOL_type_parameter_specifier_list = 545, /* type_parameter_specifier_list  */
-  YYSYMBOL_type_specifier_nonarray = 546,  /* type_specifier_nonarray  */
-  YYSYMBOL_precision_qualifier = 547,      /* precision_qualifier  */
-  YYSYMBOL_struct_specifier = 548,         /* struct_specifier  */
-  YYSYMBOL_549_3 = 549,                    /* $@3  */
-  YYSYMBOL_550_4 = 550,                    /* $@4  */
-  YYSYMBOL_struct_declaration_list = 551,  /* struct_declaration_list  */
-  YYSYMBOL_struct_declaration = 552,       /* struct_declaration  */
-  YYSYMBOL_struct_declarator_list = 553,   /* struct_declarator_list  */
-  YYSYMBOL_struct_declarator = 554,        /* struct_declarator  */
-  YYSYMBOL_initializer = 555,              /* initializer  */
-  YYSYMBOL_initializer_list = 556,         /* initializer_list  */
-  YYSYMBOL_declaration_statement = 557,    /* declaration_statement  */
-  YYSYMBOL_statement = 558,                /* statement  */
-  YYSYMBOL_simple_statement = 559,         /* simple_statement  */
-  YYSYMBOL_demote_statement = 560,         /* demote_statement  */
-  YYSYMBOL_compound_statement = 561,       /* compound_statement  */
-  YYSYMBOL_562_5 = 562,                    /* $@5  */
-  YYSYMBOL_563_6 = 563,                    /* $@6  */
-  YYSYMBOL_statement_no_new_scope = 564,   /* statement_no_new_scope  */
-  YYSYMBOL_statement_scoped = 565,         /* statement_scoped  */
-  YYSYMBOL_566_7 = 566,                    /* $@7  */
-  YYSYMBOL_567_8 = 567,                    /* $@8  */
-  YYSYMBOL_compound_statement_no_new_scope = 568, /* compound_statement_no_new_scope  */
-  YYSYMBOL_statement_list = 569,           /* statement_list  */
-  YYSYMBOL_expression_statement = 570,     /* expression_statement  */
-  YYSYMBOL_selection_statement = 571,      /* selection_statement  */
-  YYSYMBOL_selection_statement_nonattributed = 572, /* selection_statement_nonattributed  */
-  YYSYMBOL_selection_rest_statement = 573, /* selection_rest_statement  */
-  YYSYMBOL_condition = 574,                /* condition  */
-  YYSYMBOL_switch_statement = 575,         /* switch_statement  */
-  YYSYMBOL_switch_statement_nonattributed = 576, /* switch_statement_nonattributed  */
-  YYSYMBOL_577_9 = 577,                    /* $@9  */
-  YYSYMBOL_switch_statement_list = 578,    /* switch_statement_list  */
-  YYSYMBOL_case_label = 579,               /* case_label  */
-  YYSYMBOL_iteration_statement = 580,      /* iteration_statement  */
-  YYSYMBOL_iteration_statement_nonattributed = 581, /* iteration_statement_nonattributed  */
-  YYSYMBOL_582_10 = 582,                   /* $@10  */
-  YYSYMBOL_583_11 = 583,                   /* $@11  */
-  YYSYMBOL_584_12 = 584,                   /* $@12  */
-  YYSYMBOL_for_init_statement = 585,       /* for_init_statement  */
-  YYSYMBOL_conditionopt = 586,             /* conditionopt  */
-  YYSYMBOL_for_rest_statement = 587,       /* for_rest_statement  */
-  YYSYMBOL_jump_statement = 588,           /* jump_statement  */
-  YYSYMBOL_translation_unit = 589,         /* translation_unit  */
-  YYSYMBOL_external_declaration = 590,     /* external_declaration  */
-  YYSYMBOL_function_definition = 591,      /* function_definition  */
-  YYSYMBOL_592_13 = 592,                   /* $@13  */
-  YYSYMBOL_attribute = 593,                /* attribute  */
-  YYSYMBOL_attribute_list = 594,           /* attribute_list  */
-  YYSYMBOL_single_attribute = 595,         /* single_attribute  */
-  YYSYMBOL_spirv_requirements_list = 596,  /* spirv_requirements_list  */
-  YYSYMBOL_spirv_requirements_parameter = 597, /* spirv_requirements_parameter  */
-  YYSYMBOL_spirv_extension_list = 598,     /* spirv_extension_list  */
-  YYSYMBOL_spirv_capability_list = 599,    /* spirv_capability_list  */
-  YYSYMBOL_spirv_execution_mode_qualifier = 600, /* spirv_execution_mode_qualifier  */
-  YYSYMBOL_spirv_execution_mode_parameter_list = 601, /* spirv_execution_mode_parameter_list  */
-  YYSYMBOL_spirv_execution_mode_parameter = 602, /* spirv_execution_mode_parameter  */
-  YYSYMBOL_spirv_execution_mode_id_parameter_list = 603, /* spirv_execution_mode_id_parameter_list  */
-  YYSYMBOL_spirv_storage_class_qualifier = 604, /* spirv_storage_class_qualifier  */
-  YYSYMBOL_spirv_decorate_qualifier = 605, /* spirv_decorate_qualifier  */
-  YYSYMBOL_spirv_decorate_parameter_list = 606, /* spirv_decorate_parameter_list  */
-  YYSYMBOL_spirv_decorate_parameter = 607, /* spirv_decorate_parameter  */
-  YYSYMBOL_spirv_decorate_id_parameter_list = 608, /* spirv_decorate_id_parameter_list  */
-  YYSYMBOL_spirv_decorate_id_parameter = 609, /* spirv_decorate_id_parameter  */
-  YYSYMBOL_spirv_decorate_string_parameter_list = 610, /* spirv_decorate_string_parameter_list  */
-  YYSYMBOL_spirv_type_specifier = 611,     /* spirv_type_specifier  */
-  YYSYMBOL_spirv_type_parameter_list = 612, /* spirv_type_parameter_list  */
-  YYSYMBOL_spirv_type_parameter = 613,     /* spirv_type_parameter  */
-  YYSYMBOL_spirv_instruction_qualifier = 614, /* spirv_instruction_qualifier  */
-  YYSYMBOL_spirv_instruction_qualifier_list = 615, /* spirv_instruction_qualifier_list  */
-  YYSYMBOL_spirv_instruction_qualifier_id = 616 /* spirv_instruction_qualifier_id  */
+  YYSYMBOL_VECTOR = 180,                   /* VECTOR  */
+  YYSYMBOL_HITOBJECTNV = 181,              /* HITOBJECTNV  */
+  YYSYMBOL_HITOBJECTATTRNV = 182,          /* HITOBJECTATTRNV  */
+  YYSYMBOL_HITOBJECTEXT = 183,             /* HITOBJECTEXT  */
+  YYSYMBOL_HITOBJECTATTREXT = 184,         /* HITOBJECTATTREXT  */
+  YYSYMBOL_TENSORLAYOUTNV = 185,           /* TENSORLAYOUTNV  */
+  YYSYMBOL_TENSORVIEWNV = 186,             /* TENSORVIEWNV  */
+  YYSYMBOL_TENSORARM = 187,                /* TENSORARM  */
+  YYSYMBOL_SAMPLERCUBEARRAY = 188,         /* SAMPLERCUBEARRAY  */
+  YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 189,   /* SAMPLERCUBEARRAYSHADOW  */
+  YYSYMBOL_ISAMPLERCUBEARRAY = 190,        /* ISAMPLERCUBEARRAY  */
+  YYSYMBOL_USAMPLERCUBEARRAY = 191,        /* USAMPLERCUBEARRAY  */
+  YYSYMBOL_SAMPLER1D = 192,                /* SAMPLER1D  */
+  YYSYMBOL_SAMPLER1DARRAY = 193,           /* SAMPLER1DARRAY  */
+  YYSYMBOL_SAMPLER1DARRAYSHADOW = 194,     /* SAMPLER1DARRAYSHADOW  */
+  YYSYMBOL_ISAMPLER1D = 195,               /* ISAMPLER1D  */
+  YYSYMBOL_SAMPLER1DSHADOW = 196,          /* SAMPLER1DSHADOW  */
+  YYSYMBOL_SAMPLER2DRECT = 197,            /* SAMPLER2DRECT  */
+  YYSYMBOL_SAMPLER2DRECTSHADOW = 198,      /* SAMPLER2DRECTSHADOW  */
+  YYSYMBOL_ISAMPLER2DRECT = 199,           /* ISAMPLER2DRECT  */
+  YYSYMBOL_USAMPLER2DRECT = 200,           /* USAMPLER2DRECT  */
+  YYSYMBOL_SAMPLERBUFFER = 201,            /* SAMPLERBUFFER  */
+  YYSYMBOL_ISAMPLERBUFFER = 202,           /* ISAMPLERBUFFER  */
+  YYSYMBOL_USAMPLERBUFFER = 203,           /* USAMPLERBUFFER  */
+  YYSYMBOL_SAMPLER2DMS = 204,              /* SAMPLER2DMS  */
+  YYSYMBOL_ISAMPLER2DMS = 205,             /* ISAMPLER2DMS  */
+  YYSYMBOL_USAMPLER2DMS = 206,             /* USAMPLER2DMS  */
+  YYSYMBOL_SAMPLER2DMSARRAY = 207,         /* SAMPLER2DMSARRAY  */
+  YYSYMBOL_ISAMPLER2DMSARRAY = 208,        /* ISAMPLER2DMSARRAY  */
+  YYSYMBOL_USAMPLER2DMSARRAY = 209,        /* USAMPLER2DMSARRAY  */
+  YYSYMBOL_SAMPLEREXTERNALOES = 210,       /* SAMPLEREXTERNALOES  */
+  YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 211,  /* SAMPLEREXTERNAL2DY2YEXT  */
+  YYSYMBOL_ISAMPLER1DARRAY = 212,          /* ISAMPLER1DARRAY  */
+  YYSYMBOL_USAMPLER1D = 213,               /* USAMPLER1D  */
+  YYSYMBOL_USAMPLER1DARRAY = 214,          /* USAMPLER1DARRAY  */
+  YYSYMBOL_F16SAMPLER1D = 215,             /* F16SAMPLER1D  */
+  YYSYMBOL_F16SAMPLER2D = 216,             /* F16SAMPLER2D  */
+  YYSYMBOL_F16SAMPLER3D = 217,             /* F16SAMPLER3D  */
+  YYSYMBOL_F16SAMPLER2DRECT = 218,         /* F16SAMPLER2DRECT  */
+  YYSYMBOL_F16SAMPLERCUBE = 219,           /* F16SAMPLERCUBE  */
+  YYSYMBOL_F16SAMPLER1DARRAY = 220,        /* F16SAMPLER1DARRAY  */
+  YYSYMBOL_F16SAMPLER2DARRAY = 221,        /* F16SAMPLER2DARRAY  */
+  YYSYMBOL_F16SAMPLERCUBEARRAY = 222,      /* F16SAMPLERCUBEARRAY  */
+  YYSYMBOL_F16SAMPLERBUFFER = 223,         /* F16SAMPLERBUFFER  */
+  YYSYMBOL_F16SAMPLER2DMS = 224,           /* F16SAMPLER2DMS  */
+  YYSYMBOL_F16SAMPLER2DMSARRAY = 225,      /* F16SAMPLER2DMSARRAY  */
+  YYSYMBOL_F16SAMPLER1DSHADOW = 226,       /* F16SAMPLER1DSHADOW  */
+  YYSYMBOL_F16SAMPLER2DSHADOW = 227,       /* F16SAMPLER2DSHADOW  */
+  YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 228,  /* F16SAMPLER1DARRAYSHADOW  */
+  YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 229,  /* F16SAMPLER2DARRAYSHADOW  */
+  YYSYMBOL_F16SAMPLER2DRECTSHADOW = 230,   /* F16SAMPLER2DRECTSHADOW  */
+  YYSYMBOL_F16SAMPLERCUBESHADOW = 231,     /* F16SAMPLERCUBESHADOW  */
+  YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 232, /* F16SAMPLERCUBEARRAYSHADOW  */
+  YYSYMBOL_IMAGE1D = 233,                  /* IMAGE1D  */
+  YYSYMBOL_IIMAGE1D = 234,                 /* IIMAGE1D  */
+  YYSYMBOL_UIMAGE1D = 235,                 /* UIMAGE1D  */
+  YYSYMBOL_IMAGE2D = 236,                  /* IMAGE2D  */
+  YYSYMBOL_IIMAGE2D = 237,                 /* IIMAGE2D  */
+  YYSYMBOL_UIMAGE2D = 238,                 /* UIMAGE2D  */
+  YYSYMBOL_IMAGE3D = 239,                  /* IMAGE3D  */
+  YYSYMBOL_IIMAGE3D = 240,                 /* IIMAGE3D  */
+  YYSYMBOL_UIMAGE3D = 241,                 /* UIMAGE3D  */
+  YYSYMBOL_IMAGE2DRECT = 242,              /* IMAGE2DRECT  */
+  YYSYMBOL_IIMAGE2DRECT = 243,             /* IIMAGE2DRECT  */
+  YYSYMBOL_UIMAGE2DRECT = 244,             /* UIMAGE2DRECT  */
+  YYSYMBOL_IMAGECUBE = 245,                /* IMAGECUBE  */
+  YYSYMBOL_IIMAGECUBE = 246,               /* IIMAGECUBE  */
+  YYSYMBOL_UIMAGECUBE = 247,               /* UIMAGECUBE  */
+  YYSYMBOL_IMAGEBUFFER = 248,              /* IMAGEBUFFER  */
+  YYSYMBOL_IIMAGEBUFFER = 249,             /* IIMAGEBUFFER  */
+  YYSYMBOL_UIMAGEBUFFER = 250,             /* UIMAGEBUFFER  */
+  YYSYMBOL_IMAGE1DARRAY = 251,             /* IMAGE1DARRAY  */
+  YYSYMBOL_IIMAGE1DARRAY = 252,            /* IIMAGE1DARRAY  */
+  YYSYMBOL_UIMAGE1DARRAY = 253,            /* UIMAGE1DARRAY  */
+  YYSYMBOL_IMAGE2DARRAY = 254,             /* IMAGE2DARRAY  */
+  YYSYMBOL_IIMAGE2DARRAY = 255,            /* IIMAGE2DARRAY  */
+  YYSYMBOL_UIMAGE2DARRAY = 256,            /* UIMAGE2DARRAY  */
+  YYSYMBOL_IMAGECUBEARRAY = 257,           /* IMAGECUBEARRAY  */
+  YYSYMBOL_IIMAGECUBEARRAY = 258,          /* IIMAGECUBEARRAY  */
+  YYSYMBOL_UIMAGECUBEARRAY = 259,          /* UIMAGECUBEARRAY  */
+  YYSYMBOL_IMAGE2DMS = 260,                /* IMAGE2DMS  */
+  YYSYMBOL_IIMAGE2DMS = 261,               /* IIMAGE2DMS  */
+  YYSYMBOL_UIMAGE2DMS = 262,               /* UIMAGE2DMS  */
+  YYSYMBOL_IMAGE2DMSARRAY = 263,           /* IMAGE2DMSARRAY  */
+  YYSYMBOL_IIMAGE2DMSARRAY = 264,          /* IIMAGE2DMSARRAY  */
+  YYSYMBOL_UIMAGE2DMSARRAY = 265,          /* UIMAGE2DMSARRAY  */
+  YYSYMBOL_F16IMAGE1D = 266,               /* F16IMAGE1D  */
+  YYSYMBOL_F16IMAGE2D = 267,               /* F16IMAGE2D  */
+  YYSYMBOL_F16IMAGE3D = 268,               /* F16IMAGE3D  */
+  YYSYMBOL_F16IMAGE2DRECT = 269,           /* F16IMAGE2DRECT  */
+  YYSYMBOL_F16IMAGECUBE = 270,             /* F16IMAGECUBE  */
+  YYSYMBOL_F16IMAGE1DARRAY = 271,          /* F16IMAGE1DARRAY  */
+  YYSYMBOL_F16IMAGE2DARRAY = 272,          /* F16IMAGE2DARRAY  */
+  YYSYMBOL_F16IMAGECUBEARRAY = 273,        /* F16IMAGECUBEARRAY  */
+  YYSYMBOL_F16IMAGEBUFFER = 274,           /* F16IMAGEBUFFER  */
+  YYSYMBOL_F16IMAGE2DMS = 275,             /* F16IMAGE2DMS  */
+  YYSYMBOL_F16IMAGE2DMSARRAY = 276,        /* F16IMAGE2DMSARRAY  */
+  YYSYMBOL_I64IMAGE1D = 277,               /* I64IMAGE1D  */
+  YYSYMBOL_U64IMAGE1D = 278,               /* U64IMAGE1D  */
+  YYSYMBOL_I64IMAGE2D = 279,               /* I64IMAGE2D  */
+  YYSYMBOL_U64IMAGE2D = 280,               /* U64IMAGE2D  */
+  YYSYMBOL_I64IMAGE3D = 281,               /* I64IMAGE3D  */
+  YYSYMBOL_U64IMAGE3D = 282,               /* U64IMAGE3D  */
+  YYSYMBOL_I64IMAGE2DRECT = 283,           /* I64IMAGE2DRECT  */
+  YYSYMBOL_U64IMAGE2DRECT = 284,           /* U64IMAGE2DRECT  */
+  YYSYMBOL_I64IMAGECUBE = 285,             /* I64IMAGECUBE  */
+  YYSYMBOL_U64IMAGECUBE = 286,             /* U64IMAGECUBE  */
+  YYSYMBOL_I64IMAGEBUFFER = 287,           /* I64IMAGEBUFFER  */
+  YYSYMBOL_U64IMAGEBUFFER = 288,           /* U64IMAGEBUFFER  */
+  YYSYMBOL_I64IMAGE1DARRAY = 289,          /* I64IMAGE1DARRAY  */
+  YYSYMBOL_U64IMAGE1DARRAY = 290,          /* U64IMAGE1DARRAY  */
+  YYSYMBOL_I64IMAGE2DARRAY = 291,          /* I64IMAGE2DARRAY  */
+  YYSYMBOL_U64IMAGE2DARRAY = 292,          /* U64IMAGE2DARRAY  */
+  YYSYMBOL_I64IMAGECUBEARRAY = 293,        /* I64IMAGECUBEARRAY  */
+  YYSYMBOL_U64IMAGECUBEARRAY = 294,        /* U64IMAGECUBEARRAY  */
+  YYSYMBOL_I64IMAGE2DMS = 295,             /* I64IMAGE2DMS  */
+  YYSYMBOL_U64IMAGE2DMS = 296,             /* U64IMAGE2DMS  */
+  YYSYMBOL_I64IMAGE2DMSARRAY = 297,        /* I64IMAGE2DMSARRAY  */
+  YYSYMBOL_U64IMAGE2DMSARRAY = 298,        /* U64IMAGE2DMSARRAY  */
+  YYSYMBOL_TEXTURECUBEARRAY = 299,         /* TEXTURECUBEARRAY  */
+  YYSYMBOL_ITEXTURECUBEARRAY = 300,        /* ITEXTURECUBEARRAY  */
+  YYSYMBOL_UTEXTURECUBEARRAY = 301,        /* UTEXTURECUBEARRAY  */
+  YYSYMBOL_TEXTURE1D = 302,                /* TEXTURE1D  */
+  YYSYMBOL_ITEXTURE1D = 303,               /* ITEXTURE1D  */
+  YYSYMBOL_UTEXTURE1D = 304,               /* UTEXTURE1D  */
+  YYSYMBOL_TEXTURE1DARRAY = 305,           /* TEXTURE1DARRAY  */
+  YYSYMBOL_ITEXTURE1DARRAY = 306,          /* ITEXTURE1DARRAY  */
+  YYSYMBOL_UTEXTURE1DARRAY = 307,          /* UTEXTURE1DARRAY  */
+  YYSYMBOL_TEXTURE2DRECT = 308,            /* TEXTURE2DRECT  */
+  YYSYMBOL_ITEXTURE2DRECT = 309,           /* ITEXTURE2DRECT  */
+  YYSYMBOL_UTEXTURE2DRECT = 310,           /* UTEXTURE2DRECT  */
+  YYSYMBOL_TEXTUREBUFFER = 311,            /* TEXTUREBUFFER  */
+  YYSYMBOL_ITEXTUREBUFFER = 312,           /* ITEXTUREBUFFER  */
+  YYSYMBOL_UTEXTUREBUFFER = 313,           /* UTEXTUREBUFFER  */
+  YYSYMBOL_TEXTURE2DMS = 314,              /* TEXTURE2DMS  */
+  YYSYMBOL_ITEXTURE2DMS = 315,             /* ITEXTURE2DMS  */
+  YYSYMBOL_UTEXTURE2DMS = 316,             /* UTEXTURE2DMS  */
+  YYSYMBOL_TEXTURE2DMSARRAY = 317,         /* TEXTURE2DMSARRAY  */
+  YYSYMBOL_ITEXTURE2DMSARRAY = 318,        /* ITEXTURE2DMSARRAY  */
+  YYSYMBOL_UTEXTURE2DMSARRAY = 319,        /* UTEXTURE2DMSARRAY  */
+  YYSYMBOL_F16TEXTURE1D = 320,             /* F16TEXTURE1D  */
+  YYSYMBOL_F16TEXTURE2D = 321,             /* F16TEXTURE2D  */
+  YYSYMBOL_F16TEXTURE3D = 322,             /* F16TEXTURE3D  */
+  YYSYMBOL_F16TEXTURE2DRECT = 323,         /* F16TEXTURE2DRECT  */
+  YYSYMBOL_F16TEXTURECUBE = 324,           /* F16TEXTURECUBE  */
+  YYSYMBOL_F16TEXTURE1DARRAY = 325,        /* F16TEXTURE1DARRAY  */
+  YYSYMBOL_F16TEXTURE2DARRAY = 326,        /* F16TEXTURE2DARRAY  */
+  YYSYMBOL_F16TEXTURECUBEARRAY = 327,      /* F16TEXTURECUBEARRAY  */
+  YYSYMBOL_F16TEXTUREBUFFER = 328,         /* F16TEXTUREBUFFER  */
+  YYSYMBOL_F16TEXTURE2DMS = 329,           /* F16TEXTURE2DMS  */
+  YYSYMBOL_F16TEXTURE2DMSARRAY = 330,      /* F16TEXTURE2DMSARRAY  */
+  YYSYMBOL_SUBPASSINPUT = 331,             /* SUBPASSINPUT  */
+  YYSYMBOL_SUBPASSINPUTMS = 332,           /* SUBPASSINPUTMS  */
+  YYSYMBOL_ISUBPASSINPUT = 333,            /* ISUBPASSINPUT  */
+  YYSYMBOL_ISUBPASSINPUTMS = 334,          /* ISUBPASSINPUTMS  */
+  YYSYMBOL_USUBPASSINPUT = 335,            /* USUBPASSINPUT  */
+  YYSYMBOL_USUBPASSINPUTMS = 336,          /* USUBPASSINPUTMS  */
+  YYSYMBOL_F16SUBPASSINPUT = 337,          /* F16SUBPASSINPUT  */
+  YYSYMBOL_F16SUBPASSINPUTMS = 338,        /* F16SUBPASSINPUTMS  */
+  YYSYMBOL_SPIRV_INSTRUCTION = 339,        /* SPIRV_INSTRUCTION  */
+  YYSYMBOL_SPIRV_EXECUTION_MODE = 340,     /* SPIRV_EXECUTION_MODE  */
+  YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 341,  /* SPIRV_EXECUTION_MODE_ID  */
+  YYSYMBOL_SPIRV_DECORATE = 342,           /* SPIRV_DECORATE  */
+  YYSYMBOL_SPIRV_DECORATE_ID = 343,        /* SPIRV_DECORATE_ID  */
+  YYSYMBOL_SPIRV_DECORATE_STRING = 344,    /* SPIRV_DECORATE_STRING  */
+  YYSYMBOL_SPIRV_TYPE = 345,               /* SPIRV_TYPE  */
+  YYSYMBOL_SPIRV_STORAGE_CLASS = 346,      /* SPIRV_STORAGE_CLASS  */
+  YYSYMBOL_SPIRV_BY_REFERENCE = 347,       /* SPIRV_BY_REFERENCE  */
+  YYSYMBOL_SPIRV_LITERAL = 348,            /* SPIRV_LITERAL  */
+  YYSYMBOL_ATTACHMENTEXT = 349,            /* ATTACHMENTEXT  */
+  YYSYMBOL_IATTACHMENTEXT = 350,           /* IATTACHMENTEXT  */
+  YYSYMBOL_UATTACHMENTEXT = 351,           /* UATTACHMENTEXT  */
+  YYSYMBOL_LEFT_OP = 352,                  /* LEFT_OP  */
+  YYSYMBOL_RIGHT_OP = 353,                 /* RIGHT_OP  */
+  YYSYMBOL_INC_OP = 354,                   /* INC_OP  */
+  YYSYMBOL_DEC_OP = 355,                   /* DEC_OP  */
+  YYSYMBOL_LE_OP = 356,                    /* LE_OP  */
+  YYSYMBOL_GE_OP = 357,                    /* GE_OP  */
+  YYSYMBOL_EQ_OP = 358,                    /* EQ_OP  */
+  YYSYMBOL_NE_OP = 359,                    /* NE_OP  */
+  YYSYMBOL_AND_OP = 360,                   /* AND_OP  */
+  YYSYMBOL_OR_OP = 361,                    /* OR_OP  */
+  YYSYMBOL_XOR_OP = 362,                   /* XOR_OP  */
+  YYSYMBOL_MUL_ASSIGN = 363,               /* MUL_ASSIGN  */
+  YYSYMBOL_DIV_ASSIGN = 364,               /* DIV_ASSIGN  */
+  YYSYMBOL_ADD_ASSIGN = 365,               /* ADD_ASSIGN  */
+  YYSYMBOL_MOD_ASSIGN = 366,               /* MOD_ASSIGN  */
+  YYSYMBOL_LEFT_ASSIGN = 367,              /* LEFT_ASSIGN  */
+  YYSYMBOL_RIGHT_ASSIGN = 368,             /* RIGHT_ASSIGN  */
+  YYSYMBOL_AND_ASSIGN = 369,               /* AND_ASSIGN  */
+  YYSYMBOL_XOR_ASSIGN = 370,               /* XOR_ASSIGN  */
+  YYSYMBOL_OR_ASSIGN = 371,                /* OR_ASSIGN  */
+  YYSYMBOL_SUB_ASSIGN = 372,               /* SUB_ASSIGN  */
+  YYSYMBOL_STRING_LITERAL = 373,           /* STRING_LITERAL  */
+  YYSYMBOL_LEFT_PAREN = 374,               /* LEFT_PAREN  */
+  YYSYMBOL_RIGHT_PAREN = 375,              /* RIGHT_PAREN  */
+  YYSYMBOL_LEFT_BRACKET = 376,             /* LEFT_BRACKET  */
+  YYSYMBOL_RIGHT_BRACKET = 377,            /* RIGHT_BRACKET  */
+  YYSYMBOL_LEFT_BRACE = 378,               /* LEFT_BRACE  */
+  YYSYMBOL_RIGHT_BRACE = 379,              /* RIGHT_BRACE  */
+  YYSYMBOL_DOT = 380,                      /* DOT  */
+  YYSYMBOL_COMMA = 381,                    /* COMMA  */
+  YYSYMBOL_COLON = 382,                    /* COLON  */
+  YYSYMBOL_EQUAL = 383,                    /* EQUAL  */
+  YYSYMBOL_SEMICOLON = 384,                /* SEMICOLON  */
+  YYSYMBOL_BANG = 385,                     /* BANG  */
+  YYSYMBOL_DASH = 386,                     /* DASH  */
+  YYSYMBOL_TILDE = 387,                    /* TILDE  */
+  YYSYMBOL_PLUS = 388,                     /* PLUS  */
+  YYSYMBOL_STAR = 389,                     /* STAR  */
+  YYSYMBOL_SLASH = 390,                    /* SLASH  */
+  YYSYMBOL_PERCENT = 391,                  /* PERCENT  */
+  YYSYMBOL_LEFT_ANGLE = 392,               /* LEFT_ANGLE  */
+  YYSYMBOL_RIGHT_ANGLE = 393,              /* RIGHT_ANGLE  */
+  YYSYMBOL_VERTICAL_BAR = 394,             /* VERTICAL_BAR  */
+  YYSYMBOL_CARET = 395,                    /* CARET  */
+  YYSYMBOL_AMPERSAND = 396,                /* AMPERSAND  */
+  YYSYMBOL_QUESTION = 397,                 /* QUESTION  */
+  YYSYMBOL_INVARIANT = 398,                /* INVARIANT  */
+  YYSYMBOL_HIGH_PRECISION = 399,           /* HIGH_PRECISION  */
+  YYSYMBOL_MEDIUM_PRECISION = 400,         /* MEDIUM_PRECISION  */
+  YYSYMBOL_LOW_PRECISION = 401,            /* LOW_PRECISION  */
+  YYSYMBOL_PRECISION = 402,                /* PRECISION  */
+  YYSYMBOL_PACKED = 403,                   /* PACKED  */
+  YYSYMBOL_RESOURCE = 404,                 /* RESOURCE  */
+  YYSYMBOL_SUPERP = 405,                   /* SUPERP  */
+  YYSYMBOL_FLOATCONSTANT = 406,            /* FLOATCONSTANT  */
+  YYSYMBOL_INTCONSTANT = 407,              /* INTCONSTANT  */
+  YYSYMBOL_UINTCONSTANT = 408,             /* UINTCONSTANT  */
+  YYSYMBOL_BOOLCONSTANT = 409,             /* BOOLCONSTANT  */
+  YYSYMBOL_IDENTIFIER = 410,               /* IDENTIFIER  */
+  YYSYMBOL_TYPE_NAME = 411,                /* TYPE_NAME  */
+  YYSYMBOL_CENTROID = 412,                 /* CENTROID  */
+  YYSYMBOL_IN = 413,                       /* IN  */
+  YYSYMBOL_OUT = 414,                      /* OUT  */
+  YYSYMBOL_INOUT = 415,                    /* INOUT  */
+  YYSYMBOL_STRUCT = 416,                   /* STRUCT  */
+  YYSYMBOL_VOID = 417,                     /* VOID  */
+  YYSYMBOL_WHILE = 418,                    /* WHILE  */
+  YYSYMBOL_BREAK = 419,                    /* BREAK  */
+  YYSYMBOL_CONTINUE = 420,                 /* CONTINUE  */
+  YYSYMBOL_DO = 421,                       /* DO  */
+  YYSYMBOL_ELSE = 422,                     /* ELSE  */
+  YYSYMBOL_FOR = 423,                      /* FOR  */
+  YYSYMBOL_IF = 424,                       /* IF  */
+  YYSYMBOL_DISCARD = 425,                  /* DISCARD  */
+  YYSYMBOL_RETURN = 426,                   /* RETURN  */
+  YYSYMBOL_SWITCH = 427,                   /* SWITCH  */
+  YYSYMBOL_CASE = 428,                     /* CASE  */
+  YYSYMBOL_DEFAULT = 429,                  /* DEFAULT  */
+  YYSYMBOL_TERMINATE_INVOCATION = 430,     /* TERMINATE_INVOCATION  */
+  YYSYMBOL_TERMINATE_RAY = 431,            /* TERMINATE_RAY  */
+  YYSYMBOL_IGNORE_INTERSECTION = 432,      /* IGNORE_INTERSECTION  */
+  YYSYMBOL_UNIFORM = 433,                  /* UNIFORM  */
+  YYSYMBOL_SHARED = 434,                   /* SHARED  */
+  YYSYMBOL_BUFFER = 435,                   /* BUFFER  */
+  YYSYMBOL_TILEIMAGEEXT = 436,             /* TILEIMAGEEXT  */
+  YYSYMBOL_FLAT = 437,                     /* FLAT  */
+  YYSYMBOL_SMOOTH = 438,                   /* SMOOTH  */
+  YYSYMBOL_LAYOUT = 439,                   /* LAYOUT  */
+  YYSYMBOL_DOUBLECONSTANT = 440,           /* DOUBLECONSTANT  */
+  YYSYMBOL_INT16CONSTANT = 441,            /* INT16CONSTANT  */
+  YYSYMBOL_UINT16CONSTANT = 442,           /* UINT16CONSTANT  */
+  YYSYMBOL_FLOAT16CONSTANT = 443,          /* FLOAT16CONSTANT  */
+  YYSYMBOL_INT32CONSTANT = 444,            /* INT32CONSTANT  */
+  YYSYMBOL_UINT32CONSTANT = 445,           /* UINT32CONSTANT  */
+  YYSYMBOL_INT64CONSTANT = 446,            /* INT64CONSTANT  */
+  YYSYMBOL_UINT64CONSTANT = 447,           /* UINT64CONSTANT  */
+  YYSYMBOL_SUBROUTINE = 448,               /* SUBROUTINE  */
+  YYSYMBOL_DEMOTE = 449,                   /* DEMOTE  */
+  YYSYMBOL_FUNCTION = 450,                 /* FUNCTION  */
+  YYSYMBOL_PAYLOADNV = 451,                /* PAYLOADNV  */
+  YYSYMBOL_PAYLOADINNV = 452,              /* PAYLOADINNV  */
+  YYSYMBOL_HITATTRNV = 453,                /* HITATTRNV  */
+  YYSYMBOL_CALLDATANV = 454,               /* CALLDATANV  */
+  YYSYMBOL_CALLDATAINNV = 455,             /* CALLDATAINNV  */
+  YYSYMBOL_PAYLOADEXT = 456,               /* PAYLOADEXT  */
+  YYSYMBOL_PAYLOADINEXT = 457,             /* PAYLOADINEXT  */
+  YYSYMBOL_HITATTREXT = 458,               /* HITATTREXT  */
+  YYSYMBOL_CALLDATAEXT = 459,              /* CALLDATAEXT  */
+  YYSYMBOL_CALLDATAINEXT = 460,            /* CALLDATAINEXT  */
+  YYSYMBOL_PATCH = 461,                    /* PATCH  */
+  YYSYMBOL_SAMPLE = 462,                   /* SAMPLE  */
+  YYSYMBOL_NONUNIFORM = 463,               /* NONUNIFORM  */
+  YYSYMBOL_RESOURCEHEAP = 464,             /* RESOURCEHEAP  */
+  YYSYMBOL_SAMPLERHEAP = 465,              /* SAMPLERHEAP  */
+  YYSYMBOL_COHERENT = 466,                 /* COHERENT  */
+  YYSYMBOL_VOLATILE = 467,                 /* VOLATILE  */
+  YYSYMBOL_RESTRICT = 468,                 /* RESTRICT  */
+  YYSYMBOL_READONLY = 469,                 /* READONLY  */
+  YYSYMBOL_WRITEONLY = 470,                /* WRITEONLY  */
+  YYSYMBOL_NONTEMPORAL = 471,              /* NONTEMPORAL  */
+  YYSYMBOL_DEVICECOHERENT = 472,           /* DEVICECOHERENT  */
+  YYSYMBOL_QUEUEFAMILYCOHERENT = 473,      /* QUEUEFAMILYCOHERENT  */
+  YYSYMBOL_WORKGROUPCOHERENT = 474,        /* WORKGROUPCOHERENT  */
+  YYSYMBOL_SUBGROUPCOHERENT = 475,         /* SUBGROUPCOHERENT  */
+  YYSYMBOL_NONPRIVATE = 476,               /* NONPRIVATE  */
+  YYSYMBOL_SHADERCALLCOHERENT = 477,       /* SHADERCALLCOHERENT  */
+  YYSYMBOL_NOPERSPECTIVE = 478,            /* NOPERSPECTIVE  */
+  YYSYMBOL_EXPLICITINTERPAMD = 479,        /* EXPLICITINTERPAMD  */
+  YYSYMBOL_PERVERTEXEXT = 480,             /* PERVERTEXEXT  */
+  YYSYMBOL_PERVERTEXNV = 481,              /* PERVERTEXNV  */
+  YYSYMBOL_PERPRIMITIVENV = 482,           /* PERPRIMITIVENV  */
+  YYSYMBOL_PERVIEWNV = 483,                /* PERVIEWNV  */
+  YYSYMBOL_PERTASKNV = 484,                /* PERTASKNV  */
+  YYSYMBOL_PERPRIMITIVEEXT = 485,          /* PERPRIMITIVEEXT  */
+  YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 486,  /* TASKPAYLOADWORKGROUPEXT  */
+  YYSYMBOL_PRECISE = 487,                  /* PRECISE  */
+  YYSYMBOL_YYACCEPT = 488,                 /* $accept  */
+  YYSYMBOL_variable_identifier = 489,      /* variable_identifier  */
+  YYSYMBOL_primary_expression = 490,       /* primary_expression  */
+  YYSYMBOL_postfix_expression = 491,       /* postfix_expression  */
+  YYSYMBOL_integer_expression = 492,       /* integer_expression  */
+  YYSYMBOL_function_call = 493,            /* function_call  */
+  YYSYMBOL_function_call_or_method = 494,  /* function_call_or_method  */
+  YYSYMBOL_function_call_generic = 495,    /* function_call_generic  */
+  YYSYMBOL_function_call_header_no_parameters = 496, /* function_call_header_no_parameters  */
+  YYSYMBOL_function_call_header_with_parameters = 497, /* function_call_header_with_parameters  */
+  YYSYMBOL_function_call_header = 498,     /* function_call_header  */
+  YYSYMBOL_function_identifier = 499,      /* function_identifier  */
+  YYSYMBOL_unary_expression = 500,         /* unary_expression  */
+  YYSYMBOL_unary_operator = 501,           /* unary_operator  */
+  YYSYMBOL_multiplicative_expression = 502, /* multiplicative_expression  */
+  YYSYMBOL_additive_expression = 503,      /* additive_expression  */
+  YYSYMBOL_shift_expression = 504,         /* shift_expression  */
+  YYSYMBOL_relational_expression = 505,    /* relational_expression  */
+  YYSYMBOL_equality_expression = 506,      /* equality_expression  */
+  YYSYMBOL_and_expression = 507,           /* and_expression  */
+  YYSYMBOL_exclusive_or_expression = 508,  /* exclusive_or_expression  */
+  YYSYMBOL_inclusive_or_expression = 509,  /* inclusive_or_expression  */
+  YYSYMBOL_logical_and_expression = 510,   /* logical_and_expression  */
+  YYSYMBOL_logical_xor_expression = 511,   /* logical_xor_expression  */
+  YYSYMBOL_logical_or_expression = 512,    /* logical_or_expression  */
+  YYSYMBOL_conditional_expression = 513,   /* conditional_expression  */
+  YYSYMBOL_514_1 = 514,                    /* $@1  */
+  YYSYMBOL_assignment_expression = 515,    /* assignment_expression  */
+  YYSYMBOL_assignment_operator = 516,      /* assignment_operator  */
+  YYSYMBOL_expression = 517,               /* expression  */
+  YYSYMBOL_constant_expression = 518,      /* constant_expression  */
+  YYSYMBOL_declaration = 519,              /* declaration  */
+  YYSYMBOL_block_structure = 520,          /* block_structure  */
+  YYSYMBOL_521_2 = 521,                    /* $@2  */
+  YYSYMBOL_identifier_list = 522,          /* identifier_list  */
+  YYSYMBOL_function_prototype = 523,       /* function_prototype  */
+  YYSYMBOL_function_declarator = 524,      /* function_declarator  */
+  YYSYMBOL_function_header_with_parameters = 525, /* function_header_with_parameters  */
+  YYSYMBOL_function_header = 526,          /* function_header  */
+  YYSYMBOL_parameter_declarator = 527,     /* parameter_declarator  */
+  YYSYMBOL_parameter_declaration = 528,    /* parameter_declaration  */
+  YYSYMBOL_parameter_type_specifier = 529, /* parameter_type_specifier  */
+  YYSYMBOL_init_declarator_list = 530,     /* init_declarator_list  */
+  YYSYMBOL_single_declaration = 531,       /* single_declaration  */
+  YYSYMBOL_fully_specified_type = 532,     /* fully_specified_type  */
+  YYSYMBOL_invariant_qualifier = 533,      /* invariant_qualifier  */
+  YYSYMBOL_interpolation_qualifier = 534,  /* interpolation_qualifier  */
+  YYSYMBOL_layout_qualifier = 535,         /* layout_qualifier  */
+  YYSYMBOL_layout_qualifier_id_list = 536, /* layout_qualifier_id_list  */
+  YYSYMBOL_layout_qualifier_id = 537,      /* layout_qualifier_id  */
+  YYSYMBOL_precise_qualifier = 538,        /* precise_qualifier  */
+  YYSYMBOL_type_qualifier = 539,           /* type_qualifier  */
+  YYSYMBOL_single_type_qualifier = 540,    /* single_type_qualifier  */
+  YYSYMBOL_storage_qualifier = 541,        /* storage_qualifier  */
+  YYSYMBOL_non_uniform_qualifier = 542,    /* non_uniform_qualifier  */
+  YYSYMBOL_type_name_list = 543,           /* type_name_list  */
+  YYSYMBOL_type_specifier = 544,           /* type_specifier  */
+  YYSYMBOL_array_specifier = 545,          /* array_specifier  */
+  YYSYMBOL_type_parameter_specifier_opt = 546, /* type_parameter_specifier_opt  */
+  YYSYMBOL_type_parameter_specifier = 547, /* type_parameter_specifier  */
+  YYSYMBOL_type_parameter_specifier_list = 548, /* type_parameter_specifier_list  */
+  YYSYMBOL_type_specifier_nonarray = 549,  /* type_specifier_nonarray  */
+  YYSYMBOL_precision_qualifier = 550,      /* precision_qualifier  */
+  YYSYMBOL_struct_specifier = 551,         /* struct_specifier  */
+  YYSYMBOL_552_3 = 552,                    /* $@3  */
+  YYSYMBOL_553_4 = 553,                    /* $@4  */
+  YYSYMBOL_struct_declaration_list = 554,  /* struct_declaration_list  */
+  YYSYMBOL_struct_declaration_with_heap = 555, /* struct_declaration_with_heap  */
+  YYSYMBOL_block_heap_inner_structure = 556, /* block_heap_inner_structure  */
+  YYSYMBOL_557_5 = 557,                    /* $@5  */
+  YYSYMBOL_struct_declaration_without_heap = 558, /* struct_declaration_without_heap  */
+  YYSYMBOL_struct_declaration = 559,       /* struct_declaration  */
+  YYSYMBOL_struct_declarator_list = 560,   /* struct_declarator_list  */
+  YYSYMBOL_struct_declarator = 561,        /* struct_declarator  */
+  YYSYMBOL_initializer = 562,              /* initializer  */
+  YYSYMBOL_initializer_list = 563,         /* initializer_list  */
+  YYSYMBOL_declaration_statement = 564,    /* declaration_statement  */
+  YYSYMBOL_statement = 565,                /* statement  */
+  YYSYMBOL_simple_statement = 566,         /* simple_statement  */
+  YYSYMBOL_demote_statement = 567,         /* demote_statement  */
+  YYSYMBOL_compound_statement = 568,       /* compound_statement  */
+  YYSYMBOL_569_6 = 569,                    /* $@6  */
+  YYSYMBOL_570_7 = 570,                    /* $@7  */
+  YYSYMBOL_statement_no_new_scope = 571,   /* statement_no_new_scope  */
+  YYSYMBOL_statement_scoped = 572,         /* statement_scoped  */
+  YYSYMBOL_573_8 = 573,                    /* $@8  */
+  YYSYMBOL_574_9 = 574,                    /* $@9  */
+  YYSYMBOL_compound_statement_no_new_scope = 575, /* compound_statement_no_new_scope  */
+  YYSYMBOL_statement_list = 576,           /* statement_list  */
+  YYSYMBOL_expression_statement = 577,     /* expression_statement  */
+  YYSYMBOL_selection_statement = 578,      /* selection_statement  */
+  YYSYMBOL_selection_statement_nonattributed = 579, /* selection_statement_nonattributed  */
+  YYSYMBOL_selection_rest_statement = 580, /* selection_rest_statement  */
+  YYSYMBOL_condition = 581,                /* condition  */
+  YYSYMBOL_switch_statement = 582,         /* switch_statement  */
+  YYSYMBOL_switch_statement_nonattributed = 583, /* switch_statement_nonattributed  */
+  YYSYMBOL_584_10 = 584,                   /* $@10  */
+  YYSYMBOL_switch_statement_list = 585,    /* switch_statement_list  */
+  YYSYMBOL_case_label = 586,               /* case_label  */
+  YYSYMBOL_iteration_statement = 587,      /* iteration_statement  */
+  YYSYMBOL_iteration_statement_nonattributed = 588, /* iteration_statement_nonattributed  */
+  YYSYMBOL_589_11 = 589,                   /* $@11  */
+  YYSYMBOL_590_12 = 590,                   /* $@12  */
+  YYSYMBOL_591_13 = 591,                   /* $@13  */
+  YYSYMBOL_for_init_statement = 592,       /* for_init_statement  */
+  YYSYMBOL_conditionopt = 593,             /* conditionopt  */
+  YYSYMBOL_for_rest_statement = 594,       /* for_rest_statement  */
+  YYSYMBOL_jump_statement = 595,           /* jump_statement  */
+  YYSYMBOL_translation_unit = 596,         /* translation_unit  */
+  YYSYMBOL_external_declaration = 597,     /* external_declaration  */
+  YYSYMBOL_function_definition = 598,      /* function_definition  */
+  YYSYMBOL_599_14 = 599,                   /* $@14  */
+  YYSYMBOL_attribute = 600,                /* attribute  */
+  YYSYMBOL_attribute_list = 601,           /* attribute_list  */
+  YYSYMBOL_single_attribute = 602,         /* single_attribute  */
+  YYSYMBOL_spirv_requirements_list = 603,  /* spirv_requirements_list  */
+  YYSYMBOL_spirv_requirements_parameter = 604, /* spirv_requirements_parameter  */
+  YYSYMBOL_spirv_extension_list = 605,     /* spirv_extension_list  */
+  YYSYMBOL_spirv_capability_list = 606,    /* spirv_capability_list  */
+  YYSYMBOL_spirv_execution_mode_qualifier = 607, /* spirv_execution_mode_qualifier  */
+  YYSYMBOL_spirv_execution_mode_parameter_list = 608, /* spirv_execution_mode_parameter_list  */
+  YYSYMBOL_spirv_execution_mode_parameter = 609, /* spirv_execution_mode_parameter  */
+  YYSYMBOL_spirv_execution_mode_id_parameter_list = 610, /* spirv_execution_mode_id_parameter_list  */
+  YYSYMBOL_spirv_storage_class_qualifier = 611, /* spirv_storage_class_qualifier  */
+  YYSYMBOL_spirv_decorate_qualifier = 612, /* spirv_decorate_qualifier  */
+  YYSYMBOL_spirv_decorate_parameter_list = 613, /* spirv_decorate_parameter_list  */
+  YYSYMBOL_spirv_decorate_parameter = 614, /* spirv_decorate_parameter  */
+  YYSYMBOL_spirv_decorate_id_parameter_list = 615, /* spirv_decorate_id_parameter_list  */
+  YYSYMBOL_spirv_decorate_id_parameter = 616, /* spirv_decorate_id_parameter  */
+  YYSYMBOL_spirv_decorate_string_parameter_list = 617, /* spirv_decorate_string_parameter_list  */
+  YYSYMBOL_spirv_type_specifier = 618,     /* spirv_type_specifier  */
+  YYSYMBOL_spirv_type_parameter_list = 619, /* spirv_type_parameter_list  */
+  YYSYMBOL_spirv_type_parameter = 620,     /* spirv_type_parameter  */
+  YYSYMBOL_spirv_instruction_qualifier = 621, /* spirv_instruction_qualifier  */
+  YYSYMBOL_spirv_instruction_qualifier_list = 622, /* spirv_instruction_qualifier_list  */
+  YYSYMBOL_spirv_instruction_qualifier_id = 623 /* spirv_instruction_qualifier_id  */
 };
 typedef enum yysymbol_kind_t yysymbol_kind_t;
 
@@ -752,7 +759,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t;
 extern int yylex(YYSTYPE*, TParseContext&);
 
 
-#line 756 "MachineIndependent/glslang_tab.cpp"
+#line 763 "MachineIndependent/glslang_tab.cpp"
 
 
 #ifdef short
@@ -1074,21 +1081,21 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  473
+#define YYFINAL  476
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   13744
+#define YYLAST   13820
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  485
+#define YYNTOKENS  488
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  132
+#define YYNNTS  136
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  721
+#define YYNRULES  731
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  968
+#define YYNSTATES  983
 
 /* YYMAXUTOK -- Last valid token kind.  */
-#define YYMAXUTOK   739
+#define YYMAXUTOK   742
 
 
 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
@@ -1175,86 +1182,88 @@ static const yytype_int16 yytranslate[] =
      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
      455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
      465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484
+     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
+     485,   486,   487
 };
 
 #if YYDEBUG
 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
-       0,   362,   362,   368,   371,   376,   379,   382,   386,   389,
-     392,   396,   400,   404,   408,   412,   416,   422,   429,   432,
-     435,   438,   441,   446,   454,   461,   468,   474,   478,   485,
-     488,   494,   512,   537,   545,   550,   577,   585,   591,   595,
-     599,   619,   620,   621,   622,   628,   629,   634,   639,   648,
-     649,   654,   662,   663,   669,   678,   679,   684,   689,   694,
-     702,   703,   712,   724,   725,   734,   735,   744,   745,   754,
-     755,   763,   764,   772,   773,   781,   782,   782,   800,   801,
-     817,   821,   825,   829,   834,   838,   842,   846,   850,   854,
-     858,   865,   868,   879,   886,   891,   898,   903,   908,   915,
-     918,   921,   924,   929,   937,   937,   948,   952,   959,   964,
-     972,   980,   992,   995,  1002,  1015,  1035,  1042,  1065,  1080,
-    1099,  1110,  1121,  1131,  1141,  1151,  1160,  1163,  1168,  1173,
-    1178,  1186,  1191,  1197,  1202,  1207,  1216,  1226,  1253,  1262,
-    1269,  1276,  1283,  1290,  1298,  1306,  1316,  1326,  1333,  1343,
-    1349,  1352,  1359,  1363,  1367,  1375,  1384,  1387,  1398,  1401,
-    1404,  1408,  1412,  1416,  1420,  1423,  1428,  1432,  1437,  1445,
-    1449,  1454,  1460,  1466,  1473,  1478,  1483,  1491,  1496,  1508,
-    1522,  1528,  1533,  1541,  1549,  1557,  1565,  1573,  1581,  1589,
-    1597,  1605,  1613,  1620,  1627,  1631,  1636,  1641,  1646,  1651,
-    1656,  1661,  1665,  1669,  1673,  1677,  1681,  1687,  1693,  1703,
-    1710,  1713,  1721,  1728,  1739,  1744,  1752,  1756,  1766,  1769,
-    1775,  1781,  1787,  1795,  1805,  1809,  1813,  1817,  1822,  1826,
-    1831,  1836,  1841,  1846,  1851,  1856,  1861,  1866,  1871,  1877,
-    1883,  1889,  1894,  1899,  1904,  1909,  1914,  1919,  1924,  1929,
-    1934,  1939,  1944,  1949,  1956,  1961,  1966,  1971,  1976,  1981,
-    1986,  1991,  1996,  2001,  2006,  2011,  2016,  2021,  2026,  2034,
-    2042,  2050,  2056,  2062,  2068,  2074,  2080,  2086,  2092,  2098,
-    2104,  2110,  2116,  2122,  2128,  2134,  2140,  2146,  2152,  2158,
-    2164,  2170,  2176,  2182,  2188,  2194,  2200,  2206,  2212,  2218,
-    2224,  2230,  2236,  2242,  2248,  2254,  2260,  2266,  2272,  2278,
-    2284,  2290,  2296,  2302,  2310,  2318,  2326,  2334,  2342,  2350,
-    2358,  2366,  2374,  2382,  2390,  2398,  2404,  2410,  2416,  2422,
-    2428,  2434,  2440,  2446,  2452,  2458,  2464,  2470,  2476,  2482,
-    2488,  2494,  2500,  2506,  2512,  2518,  2524,  2530,  2536,  2542,
-    2548,  2554,  2560,  2566,  2572,  2578,  2584,  2590,  2596,  2602,
-    2608,  2614,  2618,  2622,  2626,  2631,  2636,  2641,  2646,  2651,
-    2656,  2661,  2666,  2671,  2676,  2681,  2686,  2691,  2696,  2702,
-    2708,  2714,  2720,  2726,  2732,  2738,  2744,  2750,  2756,  2762,
-    2768,  2774,  2779,  2784,  2789,  2794,  2799,  2804,  2809,  2814,
-    2819,  2824,  2829,  2834,  2839,  2844,  2849,  2854,  2859,  2864,
-    2869,  2874,  2879,  2884,  2889,  2894,  2899,  2904,  2909,  2914,
-    2919,  2924,  2929,  2934,  2939,  2945,  2951,  2956,  2961,  2966,
-    2972,  2977,  2982,  2987,  2993,  2998,  3003,  3008,  3014,  3019,
-    3024,  3029,  3035,  3041,  3047,  3053,  3058,  3064,  3070,  3076,
-    3081,  3086,  3091,  3096,  3101,  3107,  3112,  3117,  3122,  3128,
-    3133,  3138,  3143,  3149,  3154,  3159,  3164,  3170,  3175,  3180,
-    3185,  3191,  3196,  3201,  3206,  3212,  3217,  3222,  3227,  3233,
-    3238,  3243,  3248,  3254,  3259,  3264,  3269,  3275,  3280,  3285,
-    3290,  3296,  3301,  3306,  3311,  3317,  3322,  3327,  3332,  3338,
-    3343,  3348,  3353,  3359,  3364,  3369,  3374,  3380,  3385,  3390,
-    3395,  3401,  3406,  3411,  3416,  3421,  3426,  3431,  3436,  3441,
-    3446,  3451,  3456,  3461,  3466,  3471,  3476,  3481,  3486,  3491,
-    3496,  3501,  3506,  3511,  3516,  3521,  3527,  3533,  3539,  3545,
-    3551,  3557,  3563,  3570,  3577,  3583,  3589,  3595,  3601,  3608,
-    3615,  3622,  3629,  3634,  3639,  3643,  3649,  3655,  3659,  3663,
-    3667,  3672,  3688,  3693,  3698,  3706,  3706,  3723,  3723,  3733,
-    3736,  3749,  3771,  3798,  3802,  3808,  3813,  3824,  3827,  3833,
-    3839,  3848,  3851,  3857,  3861,  3862,  3868,  3869,  3870,  3871,
-    3872,  3873,  3874,  3875,  3879,  3887,  3888,  3892,  3888,  3906,
-    3907,  3911,  3911,  3918,  3918,  3932,  3935,  3945,  3953,  3964,
-    3965,  3969,  3972,  3979,  3986,  3990,  3998,  4002,  4011,  4014,
-    4021,  4021,  4041,  4044,  4050,  4062,  4074,  4077,  4085,  4085,
-    4104,  4104,  4126,  4126,  4147,  4150,  4156,  4159,  4165,  4169,
-    4176,  4181,  4186,  4193,  4196,  4200,  4204,  4208,  4217,  4221,
-    4230,  4233,  4236,  4244,  4244,  4286,  4291,  4294,  4299,  4302,
-    4307,  4310,  4315,  4318,  4323,  4326,  4331,  4334,  4339,  4343,
-    4348,  4352,  4357,  4361,  4368,  4371,  4376,  4379,  4382,  4385,
-    4388,  4393,  4402,  4413,  4418,  4426,  4430,  4435,  4439,  4444,
-    4448,  4453,  4457,  4464,  4467,  4472,  4475,  4478,  4481,  4486,
-    4489,  4494,  4500,  4503,  4506,  4509,  4514,  4518,  4523,  4527,
-    4532,  4536,  4543,  4546,  4551,  4554,  4559,  4562,  4568,  4571,
-    4576,  4579
+       0,   365,   365,   371,   374,   379,   382,   385,   389,   392,
+     395,   399,   403,   407,   411,   415,   419,   425,   432,   435,
+     438,   441,   444,   449,   457,   464,   471,   477,   481,   488,
+     491,   497,   515,   540,   548,   553,   580,   588,   594,   598,
+     602,   622,   623,   624,   625,   631,   632,   637,   642,   651,
+     652,   657,   665,   666,   672,   681,   682,   687,   692,   697,
+     705,   706,   715,   727,   728,   737,   738,   747,   748,   757,
+     758,   766,   767,   775,   776,   784,   785,   785,   803,   804,
+     820,   824,   828,   832,   837,   841,   845,   849,   853,   857,
+     861,   868,   871,   882,   889,   894,   901,   906,   911,   918,
+     921,   924,   927,   932,   940,   940,   952,   956,   963,   968,
+     976,   984,   996,   999,  1006,  1019,  1039,  1046,  1069,  1084,
+    1103,  1114,  1125,  1135,  1145,  1155,  1164,  1167,  1172,  1177,
+    1182,  1190,  1195,  1201,  1206,  1211,  1220,  1230,  1257,  1266,
+    1273,  1280,  1287,  1294,  1302,  1310,  1320,  1330,  1337,  1347,
+    1353,  1356,  1363,  1367,  1371,  1379,  1388,  1391,  1402,  1405,
+    1408,  1412,  1416,  1420,  1424,  1427,  1432,  1436,  1441,  1449,
+    1453,  1458,  1464,  1470,  1477,  1482,  1487,  1495,  1500,  1512,
+    1526,  1532,  1537,  1542,  1547,  1555,  1563,  1571,  1579,  1587,
+    1595,  1603,  1611,  1619,  1627,  1634,  1641,  1645,  1650,  1655,
+    1660,  1665,  1670,  1675,  1679,  1683,  1687,  1691,  1695,  1701,
+    1707,  1717,  1724,  1727,  1735,  1742,  1753,  1758,  1766,  1770,
+    1780,  1783,  1789,  1795,  1801,  1809,  1819,  1823,  1827,  1831,
+    1836,  1840,  1845,  1850,  1855,  1860,  1865,  1870,  1875,  1880,
+    1885,  1891,  1897,  1903,  1908,  1913,  1918,  1923,  1928,  1933,
+    1938,  1943,  1948,  1953,  1958,  1963,  1970,  1975,  1980,  1985,
+    1990,  1995,  2000,  2005,  2010,  2015,  2020,  2025,  2030,  2035,
+    2040,  2048,  2056,  2064,  2070,  2076,  2082,  2088,  2094,  2100,
+    2106,  2112,  2118,  2124,  2130,  2136,  2142,  2148,  2154,  2160,
+    2166,  2172,  2178,  2184,  2190,  2196,  2202,  2208,  2214,  2220,
+    2226,  2232,  2238,  2244,  2250,  2256,  2262,  2268,  2274,  2280,
+    2286,  2292,  2298,  2304,  2310,  2316,  2324,  2332,  2340,  2348,
+    2356,  2364,  2372,  2380,  2388,  2396,  2404,  2412,  2418,  2424,
+    2430,  2436,  2442,  2448,  2454,  2460,  2466,  2472,  2478,  2484,
+    2490,  2496,  2502,  2508,  2514,  2520,  2526,  2532,  2538,  2544,
+    2550,  2556,  2562,  2568,  2574,  2580,  2586,  2592,  2598,  2604,
+    2610,  2616,  2622,  2628,  2632,  2636,  2640,  2645,  2650,  2655,
+    2660,  2665,  2670,  2675,  2680,  2685,  2690,  2695,  2700,  2705,
+    2710,  2716,  2722,  2728,  2734,  2740,  2746,  2752,  2758,  2764,
+    2770,  2776,  2782,  2788,  2793,  2798,  2803,  2808,  2813,  2818,
+    2823,  2828,  2833,  2838,  2843,  2848,  2853,  2858,  2863,  2868,
+    2873,  2878,  2883,  2888,  2893,  2898,  2903,  2908,  2913,  2918,
+    2923,  2928,  2933,  2938,  2943,  2948,  2953,  2959,  2965,  2970,
+    2975,  2980,  2986,  2991,  2996,  3001,  3007,  3012,  3017,  3022,
+    3028,  3033,  3038,  3043,  3049,  3055,  3061,  3067,  3072,  3078,
+    3084,  3090,  3095,  3100,  3105,  3110,  3115,  3121,  3126,  3131,
+    3136,  3142,  3147,  3152,  3157,  3163,  3168,  3173,  3178,  3184,
+    3189,  3194,  3199,  3205,  3210,  3215,  3220,  3226,  3231,  3236,
+    3241,  3247,  3252,  3257,  3262,  3268,  3273,  3278,  3283,  3289,
+    3294,  3299,  3304,  3310,  3315,  3320,  3325,  3331,  3336,  3341,
+    3346,  3352,  3357,  3362,  3367,  3373,  3378,  3383,  3388,  3394,
+    3399,  3404,  3409,  3415,  3420,  3425,  3430,  3435,  3440,  3445,
+    3450,  3455,  3460,  3465,  3470,  3475,  3480,  3485,  3490,  3495,
+    3500,  3505,  3510,  3515,  3520,  3525,  3530,  3535,  3541,  3547,
+    3553,  3559,  3565,  3571,  3577,  3584,  3591,  3597,  3603,  3609,
+    3615,  3622,  3629,  3636,  3643,  3648,  3653,  3657,  3663,  3669,
+    3675,  3679,  3683,  3687,  3692,  3708,  3713,  3718,  3726,  3726,
+    3742,  3742,  3752,  3755,  3758,  3768,  3781,  3798,  3798,  3813,
+    3816,  3829,  3851,  3878,  3882,  3888,  3893,  3904,  3907,  3913,
+    3919,  3928,  3931,  3937,  3941,  3942,  3948,  3949,  3950,  3951,
+    3952,  3953,  3954,  3955,  3959,  3967,  3968,  3972,  3968,  3986,
+    3987,  3991,  3991,  3998,  3998,  4012,  4015,  4025,  4033,  4044,
+    4045,  4049,  4052,  4059,  4066,  4070,  4078,  4082,  4091,  4094,
+    4101,  4101,  4121,  4124,  4130,  4142,  4154,  4157,  4165,  4165,
+    4184,  4184,  4206,  4206,  4227,  4230,  4236,  4239,  4245,  4249,
+    4256,  4261,  4266,  4273,  4276,  4280,  4284,  4288,  4297,  4301,
+    4310,  4313,  4316,  4324,  4324,  4366,  4371,  4374,  4379,  4382,
+    4387,  4390,  4395,  4398,  4403,  4406,  4411,  4414,  4419,  4423,
+    4428,  4432,  4437,  4441,  4448,  4451,  4456,  4459,  4462,  4465,
+    4468,  4473,  4482,  4493,  4498,  4506,  4510,  4515,  4519,  4524,
+    4528,  4533,  4537,  4544,  4547,  4552,  4555,  4558,  4561,  4566,
+    4569,  4574,  4580,  4583,  4586,  4589,  4594,  4598,  4603,  4607,
+    4612,  4616,  4623,  4626,  4631,  4634,  4639,  4642,  4648,  4651,
+    4656,  4659
 };
 #endif
 
@@ -1302,10 +1311,10 @@ static const char *const yytname[] =
   "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4",
   "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV",
   "ACCSTRUCTEXT", "RAYQUERYEXT", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV",
-  "COOPMAT", "COOPVECNV", "HITOBJECTNV", "HITOBJECTATTRNV", "HITOBJECTEXT",
-  "HITOBJECTATTREXT", "TENSORLAYOUTNV", "TENSORVIEWNV", "TENSORARM",
-  "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY",
-  "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY",
+  "COOPMAT", "COOPVECNV", "VECTOR", "HITOBJECTNV", "HITOBJECTATTRNV",
+  "HITOBJECTEXT", "HITOBJECTATTREXT", "TENSORLAYOUTNV", "TENSORVIEWNV",
+  "TENSORARM", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW",
+  "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY",
   "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT",
   "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT",
   "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS",
@@ -1370,10 +1379,10 @@ static const char *const yytname[] =
   "DEMOTE", "FUNCTION", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV",
   "CALLDATANV", "CALLDATAINNV", "PAYLOADEXT", "PAYLOADINEXT", "HITATTREXT",
   "CALLDATAEXT", "CALLDATAINEXT", "PATCH", "SAMPLE", "NONUNIFORM",
-  "COHERENT", "VOLATILE", "RESTRICT", "READONLY", "WRITEONLY",
-  "NONTEMPORAL", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT",
-  "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE",
-  "SHADERCALLCOHERENT", "NOPERSPECTIVE", "EXPLICITINTERPAMD",
+  "RESOURCEHEAP", "SAMPLERHEAP", "COHERENT", "VOLATILE", "RESTRICT",
+  "READONLY", "WRITEONLY", "NONTEMPORAL", "DEVICECOHERENT",
+  "QUEUEFAMILYCOHERENT", "WORKGROUPCOHERENT", "SUBGROUPCOHERENT",
+  "NONPRIVATE", "SHADERCALLCOHERENT", "NOPERSPECTIVE", "EXPLICITINTERPAMD",
   "PERVERTEXEXT", "PERVERTEXNV", "PERPRIMITIVENV", "PERVIEWNV",
   "PERTASKNV", "PERPRIMITIVEEXT", "TASKPAYLOADWORKGROUPEXT", "PRECISE",
   "$accept", "variable_identifier", "primary_expression",
@@ -1400,20 +1409,21 @@ static const char *const yytname[] =
   "type_specifier", "array_specifier", "type_parameter_specifier_opt",
   "type_parameter_specifier", "type_parameter_specifier_list",
   "type_specifier_nonarray", "precision_qualifier", "struct_specifier",
-  "$@3", "$@4", "struct_declaration_list", "struct_declaration",
-  "struct_declarator_list", "struct_declarator", "initializer",
-  "initializer_list", "declaration_statement", "statement",
-  "simple_statement", "demote_statement", "compound_statement", "$@5",
-  "$@6", "statement_no_new_scope", "statement_scoped", "$@7", "$@8",
+  "$@3", "$@4", "struct_declaration_list", "struct_declaration_with_heap",
+  "block_heap_inner_structure", "$@5", "struct_declaration_without_heap",
+  "struct_declaration", "struct_declarator_list", "struct_declarator",
+  "initializer", "initializer_list", "declaration_statement", "statement",
+  "simple_statement", "demote_statement", "compound_statement", "$@6",
+  "$@7", "statement_no_new_scope", "statement_scoped", "$@8", "$@9",
   "compound_statement_no_new_scope", "statement_list",
   "expression_statement", "selection_statement",
   "selection_statement_nonattributed", "selection_rest_statement",
-  "condition", "switch_statement", "switch_statement_nonattributed", "$@9",
-  "switch_statement_list", "case_label", "iteration_statement",
-  "iteration_statement_nonattributed", "$@10", "$@11", "$@12",
+  "condition", "switch_statement", "switch_statement_nonattributed",
+  "$@10", "switch_statement_list", "case_label", "iteration_statement",
+  "iteration_statement_nonattributed", "$@11", "$@12", "$@13",
   "for_init_statement", "conditionopt", "for_rest_statement",
   "jump_statement", "translation_unit", "external_declaration",
-  "function_definition", "$@13", "attribute", "attribute_list",
+  "function_definition", "$@14", "attribute", "attribute_list",
   "single_attribute", "spirv_requirements_list",
   "spirv_requirements_parameter", "spirv_extension_list",
   "spirv_capability_list", "spirv_execution_mode_qualifier",
@@ -1435,12 +1445,12 @@ yysymbol_name (yysymbol_kind_t yysymbol)
 }
 #endif
 
-#define YYPACT_NINF (-894)
+#define YYPACT_NINF (-832)
 
 #define yypact_value_is_default(Yyn) \
   ((Yyn) == YYPACT_NINF)
 
-#define YYTABLE_NINF (-716)
+#define YYTABLE_NINF (-726)
 
 #define yytable_value_is_error(Yyn) \
   0
@@ -1449,103 +1459,105 @@ yysymbol_name (yysymbol_kind_t yysymbol)
    STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    4827,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -305,  -284,  -273,  -250,
-    -220,  -203,  -187,  -131,  -894,  -894,  -894,  -894,  -894,  -227,
-    -894,  -894,  -894,  -894,  -894,   -59,  -894,  -894,  -894,  -894,
-    -894,  -328,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -102,
-    -100,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -342,  -217,
-    -319,  -177,  8683,  -225,  -894,  -153,  -894,  -894,  -894,  -894,
-    5791,  -894,  -894,  -894,  -894,  -106,  -894,  -894,   971,  -894,
-    -894,  8683,   -92,  -894,  -894,  -894,  6273,  -128,  -219,  -156,
-    -155,  -127,  -123,  -128,  -119,   -75, 13295,  -894,   -68,  -369,
-     -64,  -894,  -330,  -894,   -41,   -22,  6755,  -894,  -894,  -894,
-    8683,   -55,   -54,  -894,  -285,  -894,   -21,  -140,  -894,  -894,
-   11918,   -18,  -894,  -894,  -894,   -16,   -50,  8683,  -894,   -23,
-     -20,   -19,  -894,  -318,  -894,  -259,   -17,   -14,   -13,   -12,
-    -231,   -11,   -10,    -9,    -8,    -7,    -5,  -230,     6,    -4,
-       8,  -322,  -894,    -1,  8683,  -894,    -3,  -894,  -228,  -894,
-    -894,  -212, 10082,  -894,  -323,  1453,  -894,  -894,   -15,  -894,
-    -894,  -894,  -281,  -256,  -894, 10541,  -255,  -894,   -46,  -894,
-   11918, 11918,  -894, 11918,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -316,  -894,  -894,  -894,    10,  -209, 12377,
-      12,  -894, 11918,  -894,    13,  -294,     3,   -22,    14,  -894,
-    -341,  -128,  -894,    -6,  -894,  -329,    15,  -117, 11918,  -110,
-    -894,  -139,  -109,  -148,  -108,    16,  -104,  -128,  -894, 12836,
-    -894,  -103, 11918,    17,   -75,  -894,  8683,    -2,  7237,  -894,
-    8683, 11918,  -894,  -369,  -894,     1,  -894,  -894,  -126,  -251,
-    -234,  -320,  -130,     7,    11,    21,    30,    31,  -321,    18,
-    -894, 11000,  -894,    19,  -894,  -894,    22,    23,    25,  -894,
-      27,    28,    32, 11459,    43, 11918,    37,    36,    39,    40,
-      41,  -257,  -894,  -894,  -136,  -894,  -217,    53,    13,  -894,
-    -894,  -894,  -894,  -894,  1935,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  5309,    48, 10541,     3, 10541,  -243,
-    9164,  -894,  -894, 10541,  8683,  -894,  -894,  -894,  -207,  -894,
-    -894, 11918,    26,  -894,  -894, 11918,    68,  -894,  -894,  -894,
-   11918,  -894,  -894,  -894,  -326,  -894,  -894,  -200,    61,  -894,
-    -894,  -894,  -894,  -894,  -894,  -199,  -894,  -196,  -894,  -894,
-    -195,    24,  -894,  -894,  -894,  -894,  -192,  -894,  -175,  -894,
-    -894,  -894,  -894,  -894,  -174,  -894,    64,  -894,  -173,    67,
-    -170,    61,  -894,  -289,  -166,  -894,    74,    76,  -894,  -894,
-      -2,   -18,   -73,  -894,  -894,  -894,  7719,  -894,  -894,  -894,
-   11918, 11918, 11918, 11918, 11918, 11918, 11918, 11918, 11918, 11918,
-   11918, 11918, 11918, 11918, 11918, 11918, 11918, 11918, 11918,  -894,
-    -894,  -894,    20,  -894,  2417,  -894,  -894,  -894,  2417,  -894,
-   11918,  -894,  -894,   -72, 11918,   -38,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894, 11918, 11918,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894, 10541,  -894,  -894,  -132,  -894,  8201,  -894,
-      77,    72,  -894,  -894,  -894,  -894,  -894,  -277,  -235,  -894,
-    -324,  -894,  -329,  -894,  -329,  -894, 11918, 11918,  -894,  -139,
-    -894,  -139,  -894,  -148,  -148,  -894,    82,    16,  -894, 12836,
-    -894, 11918,  -894,  -894,   -45,     3,    -2,  -894,  -894,  -894,
-    -894,  -894,  -126,  -126,  -251,  -251,  -234,  -234,  -234,  -234,
-    -320,  -320,  -130,     7,    11,    21,    30,    31, 11918,  -894,
-    2417,  4345,   -26,  3863,  -163,  -894,  -162,  -894,  -894,  -894,
-    -894,  -894,  9623,  -894,  -894,  -894,    83,  -894,    52,  -894,
-    -161,  -894,  -159,  -894,  -158,  -894,  -154,  -894,  -151,  -150,
-    -894,  -894,  -894,   -33,    81,    72,    54,    87,    89,  -894,
-    -894,  4345,    90,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894, 11918,  -894,    84,  2899, 11918,  -894,
-      85,    97,    55,    96,  3381,  -894,    98,  -894, 10541,  -894,
-    -894,  -894,  -149, 11918,  2899,    90,  -894,  -894,  2417,  -894,
-      91,    72,  -894,  -894,  2417,    86,  -894,  -894
+    4866,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -320,  -282,  -220,
+    -210,  -141,  -139,  -102,   -92,  -832,  -832,  -832,  -832,  -832,
+    -244,  -832,  -832,  -832,  -832,  -832,   -54,  -832,  -832,  -832,
+    -832,  -832,  -339,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+     -90,   -88,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -352,  -250,  -197,  -195,  8746,  -130,  -832,  -211,  -832,
+    -832,  -832,  -832,  5836,  -832,  -832,  -832,  -832,  -168,  -832,
+    -832,   986,  -832,  -832,  8746,   -93,  -832,  -832,  -832,  6321,
+     -76,  -185,  -151,  -150,  -146,  -145,   -76,  -144,   -74, 13370,
+    -832,   -34,  -375,   -50,  -832,  -302,  -832,   -22,   -15,  6806,
+    -832,  -832,  -832,  8746,   -48,   -47,  -832,  -247,  -832,   -14,
+    -114,  -832,  -832, 11990,   -11,  -832,  -832,  -832,    -9,   -43,
+    8746,  -832,   -16,   -13,   -12,  -832,  -251,  -832,  -242,   -10,
+      -7,    -5,    -4,  -240,    -2,    -1,     1,     6,     7,     8,
+    -225,    -3,    10,    11,  -215,  -832,    12,  8746,  -832,     3,
+    -832,  -216,  -832,  -832,  -214, 10150,  -832,  -296,  1471,  -832,
+    -832,    14,  -832,  -832,  -832,  -290,  -279,  -832, 10610,  -276,
+    -832,   -39,  -832, 11990, 11990,  -832, 11990,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -299,  -832,  -832,  -832,
+      15,  -212, 12450,    21,  -832, 11990,  -832,    23,  -336,    22,
+     -15,    25,  -832,  -323,   -76,  -832,   -29,  -832,  -340,    24,
+    -136, 11990,  -134,  -832,  -159,  -129,  -178,  -110,    28,  -109,
+     -76,  -832, 12910,  -832,  -108, 11990,    26,   -74,  -832,  7291,
+     -27,    27,  8746,   -27,  8746,  -832,  8746, 11990,  -832,  -375,
+    -832,    -8,  -832,  -832,   -41,  -344,  -113,  -331,  -253,    13,
+      16,    18,    44,    46,  -327,    33,  -832, 11070,  -832,    34,
+    -832,  -832,    40,    32,    36,  -832,    47,    48,    41, 11530,
+      52, 11990,    45,    54,    61,    62,    63,  -252,  -832,  -832,
+    -104,  -832,  -250,    55,    23,  -832,  -832,  -832,  -832,  -832,
+    1956,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    5351,    38, 10610,    22, 10610,  -275,  9230,  -832,  -832, 10610,
+    8746,  -832,  -832,  -832,  -201,  -832,  -832, 11990,    20,  -832,
+    -832, 11990,    75,  -832,  -832,  -832, 11990,  -832,  -832,  -832,
+    -343,  -832,  -832,  -200,    68,  -832,  -832,  -832,  -832,  -832,
+    -832,  -199,  -832,  -198,  -832,  -832,  -196,    73,  -832,  -832,
+    -832,  -832,  -188,  -832,  -186,  -832,  -832,  -832,  -832,  -832,
+    -184,  -832,    74,  -832,  -179,    76,  -177,    68,  -832,  -329,
+    -175,  -832,    81,    83,  -832,  -832,  -832,   -27,   -11,   -56,
+    -832,  -832,  8746,  8746,   -55,  -832,  -832,    85,  -832,  -832,
+    -832, 11990, 11990, 11990, 11990, 11990, 11990, 11990, 11990, 11990,
+   11990, 11990, 11990, 11990, 11990, 11990, 11990, 11990, 11990, 11990,
+    -832,  -832,  -832,    88,  -832,  2441,  -832,  -832,  -832,  2441,
+    -832, 11990,  -832,  -832,   -51, 11990,   -77,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832, 11990, 11990,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832, 10610,  -832,  -832,  -126,  -832,  7776,
+    -832,    89,    86,  -832,  -832,  -832,  -832,  -832,  -154,  -143,
+    -832,  -322,  -832,  -340,  -832,  -340,  -832, 11990, 11990,  -832,
+    -159,  -832,  -159,  -832,  -178,  -178,  -832,    96,    28,  -832,
+   12910,  -832, 11990,  -832,  -832,  8746,   -46,    22,   -27,  -832,
+    -832,  -832,  -832,  -832,  -832,   -41,   -41,  -344,  -344,  -113,
+    -113,  -113,  -113,  -331,  -331,  -253,    13,    16,    18,    44,
+      46, 11990,  -832,  2441,  4381,    53,  3896,  -174,  -832,  -172,
+    -832,  -832,  -832,  -832,  -832,  9690,  -832,  -832,  -832,    97,
+    -832,    67,  -832,  -167,  -832,  -165,  -832,  -164,  -832,  -163,
+    -832,  -162,  -160,  -832,  8261,  -832,  -832,   -42,    98,    86,
+      65,    87,   102,  -832,  -832,  4381,   100,  -832,  -832,  -832,
+    -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832, 11990,
+    -832,   101,  2926, 11990,  -832,    95,   106,    64,   105,  3411,
+    -832,   107,  -832, 10610,  -832,  -832,  -832,  -155, 11990,  2926,
+     100,  -832,  -832,  2441,  -832,   103,    86,  -832,  -832,  2441,
+     109,  -832,  -832
 };
 
 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1553,141 +1565,143 @@ static const yytype_int16 yypact[] =
    means the default is an error.  */
 static const yytype_int16 yydefact[] =
 {
-       0,   169,   228,   226,   227,   225,   232,   233,   234,   235,
-     236,   237,   238,   239,   240,   229,   230,   231,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     366,   367,   368,   369,   370,   371,   372,   392,   393,   394,
-     395,   396,   397,   398,   407,   420,   421,   408,   409,   411,
-     410,   412,   413,   414,   415,   416,   417,   418,   419,   178,
-     179,   255,   256,   254,   257,   258,   253,   259,   266,   267,
-     264,   265,   262,   263,   260,   261,   298,   299,   300,   310,
-     311,   312,   295,   296,   297,   307,   308,   309,   292,   293,
-     294,   304,   305,   306,   289,   290,   291,   301,   302,   303,
-     268,   269,   270,   313,   314,   315,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   325,   326,
-     327,   283,   284,   285,   337,   338,   339,   286,   287,   288,
-     349,   350,   351,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   328,   329,   330,   331,   332,   333,   334,   335,
-     336,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   364,
-     361,   362,   363,   548,   549,   550,   551,   555,   558,   183,
-     559,   184,   552,   553,   556,   376,   377,   400,   403,   365,
-     374,   375,   391,   373,   422,   423,   426,   427,   428,   430,
-     431,   432,   434,   435,   436,   438,   439,   535,   536,   399,
-     401,   402,   378,   379,   380,   424,   381,   385,   386,   389,
-     429,   433,   437,   382,   383,   387,   388,   425,   384,   390,
-     469,   471,   472,   473,   475,   476,   477,   479,   480,   481,
-     483,   484,   485,   487,   488,   489,   491,   492,   493,   495,
-     496,   497,   499,   500,   501,   503,   504,   505,   507,   508,
-     509,   511,   512,   470,   474,   478,   482,   486,   494,   498,
-     502,   490,   506,   510,   513,   514,   515,   516,   517,   518,
-     519,   520,   521,   522,   523,   524,   525,   526,   527,   528,
-     529,   530,   531,   532,   533,   534,   404,   405,   406,   440,
-     449,   451,   445,   450,   452,   453,   455,   456,   457,   459,
-     460,   461,   463,   464,   465,   467,   468,   441,   442,   443,
-     454,   444,   446,   447,   448,   458,   462,   466,   540,   541,
-     544,   545,   546,   547,   542,   543,     0,     0,     0,     0,
-       0,     0,     0,     0,   167,   168,   537,   538,   539,     0,
-     652,   138,   562,   563,   564,     0,   561,   173,   171,   172,
-     170,     0,   224,   174,   176,   177,   175,   140,   139,     0,
-     206,   554,   186,   188,   182,   190,   192,   187,   189,   185,
-     191,   193,   180,   181,   209,   194,   201,   202,   203,   204,
-     205,   195,   196,   197,   198,   199,   200,   141,   142,   144,
-     143,   145,   147,   148,   146,   208,   155,   651,     0,   653,
-       0,   113,   112,     0,   126,   131,   162,   161,   159,   163,
-       0,   156,   158,   164,   136,   219,   160,   560,     0,   648,
-     650,     0,     0,   165,   166,   557,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   567,     0,     0,
-       0,    99,     0,    94,     0,   108,     0,   122,   114,   124,
-       0,   125,     0,    97,   132,   102,   106,     0,   157,   137,
-       0,   212,   218,     1,   649,     0,     0,     0,    96,     0,
-       0,     0,   660,     0,   718,     0,     0,     0,     0,     0,
+       0,   169,   230,   228,   229,   227,   234,   235,   236,   237,
+     238,   239,   240,   241,   242,   231,   232,   233,   243,   244,
+     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
+     368,   369,   370,   371,   372,   373,   374,   394,   395,   396,
+     397,   398,   399,   400,   409,   422,   423,   410,   411,   413,
+     412,   414,   415,   416,   417,   418,   419,   420,   421,   178,
+     179,   257,   258,   256,   259,   260,   255,   261,   268,   269,
+     266,   267,   264,   265,   262,   263,   300,   301,   302,   312,
+     313,   314,   297,   298,   299,   309,   310,   311,   294,   295,
+     296,   306,   307,   308,   291,   292,   293,   303,   304,   305,
+     270,   271,   272,   315,   316,   317,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   327,   328,
+     329,   285,   286,   287,   339,   340,   341,   288,   289,   290,
+     351,   352,   353,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,   330,   331,   332,   333,   334,   335,   336,   337,
+     338,   342,   343,   344,   345,   346,   347,   348,   349,   350,
+     354,   355,   356,   357,   358,   359,   360,   361,   362,   366,
+     363,   364,   365,   550,   551,   552,   553,   557,   559,   561,
+     185,   562,   186,   554,   555,   558,   378,   379,   402,   405,
+     367,   376,   377,   393,   375,   424,   425,   428,   429,   430,
+     432,   433,   434,   436,   437,   438,   440,   441,   537,   538,
+     401,   403,   404,   380,   381,   382,   426,   383,   387,   388,
+     391,   431,   435,   439,   384,   385,   389,   390,   427,   386,
+     392,   471,   473,   474,   475,   477,   478,   479,   481,   482,
+     483,   485,   486,   487,   489,   490,   491,   493,   494,   495,
+     497,   498,   499,   501,   502,   503,   505,   506,   507,   509,
+     510,   511,   513,   514,   472,   476,   480,   484,   488,   496,
+     500,   504,   492,   508,   512,   515,   516,   517,   518,   519,
+     520,   521,   522,   523,   524,   525,   526,   527,   528,   529,
+     530,   531,   532,   533,   534,   535,   536,   406,   407,   408,
+     442,   451,   453,   447,   452,   454,   455,   457,   458,   459,
+     461,   462,   463,   465,   466,   467,   469,   470,   443,   444,
+     445,   456,   446,   448,   449,   450,   460,   464,   468,   542,
+     543,   546,   547,   548,   549,   544,   545,     0,     0,     0,
+       0,     0,     0,     0,     0,   167,   168,   539,   540,   541,
+       0,   662,   138,   565,   566,   567,     0,   564,   173,   171,
+     172,   170,     0,   226,   174,   176,   177,   175,   140,   139,
+       0,   208,   556,   188,   190,   184,   192,   194,   189,   191,
+     187,   193,   195,   180,   181,   211,   182,   183,   196,   203,
+     204,   205,   206,   207,   197,   198,   199,   200,   201,   202,
+     141,   142,   144,   143,   145,   147,   148,   146,   210,   155,
+     661,     0,   663,     0,   113,   112,     0,   126,   131,   162,
+     161,   159,   163,     0,   156,   158,   164,   136,   221,   160,
+     563,     0,   658,   660,     0,     0,   165,   166,   560,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     658,     0,   656,     0,     0,   565,   152,   154,     0,   150,
-     210,     0,     0,   100,     0,     0,   654,   109,     0,   115,
-     121,   123,   118,   127,   117,     0,   133,   104,     0,   103,
-       0,     0,     9,     0,    43,    42,    44,    41,     5,     6,
-       7,     8,     2,    16,    14,    15,    17,    10,    11,    12,
-      13,     3,    18,    37,    20,    25,    26,     0,     0,    30,
-       0,   222,     0,    36,   221,     0,   213,   110,     0,    95,
-       0,     0,   716,     0,   668,     0,     0,     0,     0,     0,
-     685,     0,     0,     0,     0,     0,     0,     0,   710,     0,
-     683,     0,     0,     0,     0,    98,     0,     0,     0,   569,
-       0,     0,   149,     0,   207,     0,   214,    45,    49,    52,
-      55,    60,    63,    65,    67,    69,    71,    73,    75,     0,
-      34,     0,   101,   596,   605,   609,     0,     0,     0,   630,
+     570,     0,     0,     0,    99,     0,    94,     0,   108,     0,
+     122,   114,   124,     0,   125,     0,    97,   132,   102,   106,
+       0,   157,   137,     0,   214,   220,     1,   659,     0,     0,
+       0,    96,     0,     0,     0,   670,     0,   728,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    45,    78,    91,     0,   583,     0,   164,   136,   586,
-     607,   585,   593,   584,     0,   587,   588,   611,   589,   618,
-     590,   591,   626,   592,     0,     0,     0,   119,     0,   128,
-       0,   577,   135,     0,     0,   107,    38,    39,     0,    22,
-      23,     0,     0,    28,    27,     0,   224,    31,    33,    40,
-       0,   220,   111,   720,     0,   721,   661,     0,     0,   719,
-     680,   676,   677,   678,   679,     0,   674,     0,    93,   681,
-       0,     0,   695,   696,   697,   698,     0,   693,     0,   702,
-     703,   704,   705,   701,     0,   699,     0,   706,     0,     0,
-       0,     2,   714,   219,     0,   712,     0,     0,   655,   657,
-       0,   575,     0,   573,   568,   570,     0,   153,   151,   211,
+       0,     0,     0,   668,     0,   666,     0,     0,   568,   152,
+     154,     0,   150,   212,     0,     0,   100,     0,     0,   664,
+     109,     0,   115,   121,   123,   118,   127,   117,     0,   133,
+     104,     0,   103,     0,     0,     9,     0,    43,    42,    44,
+      41,     5,     6,     7,     8,     2,    16,    14,    15,    17,
+      10,    11,    12,    13,     3,    18,    37,    20,    25,    26,
+       0,     0,    30,     0,   224,     0,    36,   223,     0,   215,
+     110,     0,    95,     0,     0,   726,     0,   678,     0,     0,
+       0,     0,     0,   695,     0,     0,     0,     0,     0,     0,
+       0,   720,     0,   693,     0,     0,     0,     0,    98,     0,
+       0,     0,   573,     0,   572,   579,     0,     0,   149,     0,
+     209,     0,   216,    45,    49,    52,    55,    60,    63,    65,
+      67,    69,    71,    73,    75,     0,    34,     0,   101,   606,
+     615,   619,     0,     0,     0,   640,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    45,    78,    91,
+       0,   593,     0,   164,   136,   596,   617,   595,   603,   594,
+       0,   597,   598,   621,   599,   628,   600,   601,   636,   602,
+       0,     0,     0,   119,     0,   128,     0,   587,   135,     0,
+       0,   107,    38,    39,     0,    22,    23,     0,     0,    28,
+      27,     0,   226,    31,    33,    40,     0,   222,   111,   730,
+       0,   731,   671,     0,     0,   729,   690,   686,   687,   688,
+     689,     0,   684,     0,    93,   691,     0,     0,   705,   706,
+     707,   708,     0,   703,     0,   712,   713,   714,   715,   711,
+       0,   709,     0,   716,     0,     0,     0,     2,   724,   221,
+       0,   722,     0,     0,   665,   667,   577,     0,   585,     0,
+     583,   571,     0,   574,     0,   575,   580,     0,   153,   151,
+     213,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    76,
-     215,   216,     0,   595,     0,   628,   641,   640,     0,   632,
-       0,   644,   642,     0,     0,     0,   625,   645,   646,   647,
-     594,    81,    82,    84,    83,    86,    87,    88,    89,    90,
-      85,    80,     0,     0,   610,   606,   608,   612,   619,   627,
-     116,   120,   130,     0,   580,   581,     0,   134,     0,     4,
-       0,    24,    21,    32,   223,   664,   666,     0,     0,   717,
-       0,   670,     0,   669,     0,   672,     0,     0,   687,     0,
-     686,     0,   689,     0,     0,   691,     0,     0,   711,     0,
-     708,     0,   684,   659,     0,   576,     0,   571,   566,    46,
-      47,    48,    51,    50,    53,    54,    58,    59,    56,    57,
-      61,    62,    64,    66,    68,    70,    72,    74,     0,   217,
-     597,     0,     0,     0,     0,   643,     0,   624,    79,    92,
-     129,   578,     0,   105,    19,   662,     0,   663,     0,   675,
-       0,   682,     0,   694,     0,   700,     0,   707,     0,     0,
-     713,   572,   574,     0,     0,   616,     0,     0,     0,   635,
-     634,   637,   603,   620,   579,   582,   665,   667,   671,   673,
-     688,   690,   692,   709,     0,   598,     0,     0,     0,   636,
-       0,     0,   615,     0,     0,   613,     0,    77,     0,   600,
-     629,   599,     0,   638,     0,   603,   602,   604,   622,   617,
-       0,   639,   633,   614,   623,     0,   631,   621
+      76,   217,   218,     0,   605,     0,   638,   651,   650,     0,
+     642,     0,   654,   652,     0,     0,     0,   635,   655,   656,
+     657,   604,    81,    82,    84,    83,    86,    87,    88,    89,
+      90,    85,    80,     0,     0,   620,   616,   618,   622,   629,
+     637,   116,   120,   130,     0,   590,   591,     0,   134,     0,
+       4,     0,    24,    21,    32,   225,   674,   676,     0,     0,
+     727,     0,   680,     0,   679,     0,   682,     0,     0,   697,
+       0,   696,     0,   699,     0,     0,   701,     0,     0,   721,
+       0,   718,     0,   694,   669,     0,     0,   586,     0,   581,
+     576,   569,    46,    47,    48,    51,    50,    53,    54,    58,
+      59,    56,    57,    61,    62,    64,    66,    68,    70,    72,
+      74,     0,   219,   607,     0,     0,     0,     0,   653,     0,
+     634,    79,    92,   129,   588,     0,   105,    19,   672,     0,
+     673,     0,   685,     0,   692,     0,   704,     0,   710,     0,
+     717,     0,     0,   723,     0,   582,   584,     0,     0,   626,
+       0,     0,     0,   645,   644,   647,   613,   630,   589,   592,
+     675,   677,   681,   683,   698,   700,   702,   719,   578,     0,
+     608,     0,     0,     0,   646,     0,     0,   625,     0,     0,
+     623,     0,    77,     0,   610,   639,   609,     0,   648,     0,
+     613,   612,   614,   632,   627,     0,   649,   643,   624,   633,
+       0,   641,   631
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -894,  -569,  -894,  -894,  -894,  -894,  -894,  -894,  -894,  -894,
-    -894,  -894,  -438,  -894,  -521,  -406,  -522,  -410,  -283,  -286,
-    -282,  -287,  -280,  -279,  -894,  -505,  -894,  -509,  -894,  -504,
-    -559,     4,  -894,  -894,  -894,     5,  -419,  -894,  -894,    33,
-      29,    34,  -894,  -894,  -430,  -894,  -894,  -894,  -894,  -122,
-    -894,  -409,  -394,  -894,     9,  -894,     0,  -453,  -894,  -894,
-    -894,  -579,   127,  -894,  -894,  -894,  -570,  -577,  -252,  -372,
-    -653,  -894,  -393,  -631,  -893,  -894,  -451,  -894,  -894,  -459,
-    -458,  -894,  -894,    42,  -749,  -385,  -894,  -165,  -894,  -421,
-    -894,  -157,  -894,  -894,  -894,  -894,  -147,  -894,  -894,  -894,
-    -894,  -894,  -894,  -894,  -894,    73,  -894,  -894,     2,  -894,
-     -91,  -246,  -449,  -894,  -894,  -894,  -332,  -327,  -331,  -894,
-    -894,  -333,  -325,  -335,  -317,  -337,  -894,  -338,  -315,  -894,
-    -415,  -565
+    -832,  -567,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,
+    -832,  -832,  -455,  -832,  -413,  -408,  -526,  -419,  -284,  -283,
+    -285,  -281,  -280,  -286,  -832,  -505,  -832,  -521,  -832,  -516,
+    -558,     4,  -832,  -832,  -832,     5,  -418,  -832,  -832,    31,
+      42,    37,  -832,  -832,  -433,  -832,  -832,  -832,  -832,  -112,
+    -832,  -412,  -415,  -832,     9,  -832,     0,  -453,  -832,  -832,
+    -832,  -577,   139,  -832,  -832,  -832,  -107,  -101,  -832,  -832,
+    -571,  -593,  -579,  -364,  -636,  -832,  -391,  -647,  -831,  -832,
+    -452,  -832,  -832,  -461,  -460,  -832,  -832,    56,  -768,  -387,
+    -832,  -156,  -832,  -424,  -832,  -153,  -832,  -832,  -832,  -832,
+    -149,  -832,  -832,  -832,  -832,  -832,  -832,  -832,  -832,    84,
+    -832,  -832,     2,  -832,   -78,  -298,  -491,  -832,  -832,  -832,
+    -325,  -321,  -324,  -832,  -832,  -326,  -319,  -330,  -318,  -328,
+    -832,  -332,  -333,  -832,  -417,  -564
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-       0,   551,   552,   553,   820,   554,   555,   556,   557,   558,
-     559,   560,   641,   562,   608,   609,   610,   611,   612,   613,
-     614,   615,   616,   617,   618,   642,   878,   643,   802,   644,
-     732,   645,   408,   674,   467,   646,   410,   411,   412,   457,
-     458,   459,   413,   414,   415,   416,   417,   418,   508,   509,
-     419,   420,   421,   422,   563,   511,   620,   514,   471,   472,
-     565,   425,   426,   427,   600,   504,   598,   599,   742,   743,
-     672,   816,   649,   650,   651,   652,   653,   774,   914,   950,
-     942,   943,   944,   951,   654,   655,   656,   657,   945,   917,
-     658,   659,   946,   965,   660,   661,   662,   881,   778,   883,
-     921,   940,   941,   663,   428,   429,   430,   454,   664,   501,
-     502,   481,   482,   827,   828,   432,   705,   706,   710,   433,
-     434,   716,   717,   724,   725,   728,   435,   734,   735,   436,
-     483,   484
+       0,   554,   555,   556,   831,   557,   558,   559,   560,   561,
+     562,   563,   647,   565,   614,   615,   616,   617,   618,   619,
+     620,   621,   622,   623,   624,   648,   891,   649,   813,   650,
+     738,   651,   411,   680,   470,   652,   413,   414,   415,   460,
+     461,   462,   416,   417,   418,   419,   420,   421,   511,   512,
+     422,   423,   424,   425,   566,   514,   626,   517,   474,   475,
+     568,   428,   429,   430,   606,   507,   601,   602,   603,   865,
+     604,   605,   749,   750,   678,   827,   655,   656,   657,   658,
+     659,   785,   928,   965,   957,   958,   959,   966,   660,   661,
+     662,   663,   960,   931,   664,   665,   961,   980,   666,   667,
+     668,   894,   789,   896,   935,   955,   956,   669,   431,   432,
+     433,   457,   670,   504,   505,   484,   485,   838,   839,   435,
+     711,   712,   716,   436,   437,   722,   723,   730,   731,   734,
+     438,   740,   741,   439,   486,   487
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1695,104 +1709,154 @@ static const yytype_int16 yydefgoto[] =
    number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     424,   476,   431,   460,   407,   409,   476,   619,   699,   423,
-     733,   526,   475,   811,   723,   812,   671,   815,   566,   709,
-     817,   745,   477,   806,   699,   880,   468,   477,   497,   678,
-     746,   693,   561,   737,   694,   757,   758,   679,   680,   768,
-     506,   451,   747,   700,   949,   512,   825,   460,   693,   447,
-     687,   957,   621,   513,   593,   455,   572,   -35,   594,   681,
-     622,   949,   573,   682,   507,   695,   468,   452,   437,   667,
-     669,   759,   760,   708,   607,   769,   701,   702,   703,   704,
-     826,   448,   695,   468,   708,  -715,   690,   708,   524,   438,
-     512,  -715,   676,   677,   512,   596,   708,   525,   691,   895,
-     439,   666,   470,   896,   818,   791,   792,   793,   794,   795,
-     796,   797,   798,   799,   800,   574,   772,   755,   756,   512,
-     621,   575,   696,   440,   689,   801,   668,   673,   696,   783,
-     696,   785,   621,   696,   753,   696,   754,   696,   696,   813,
-     607,   897,   696,   580,   588,   898,   602,   882,   445,   581,
-     589,   607,   603,   441,   607,   462,   697,   671,   463,   671,
-     890,   671,   604,   607,   671,   684,   453,   819,   605,   745,
-     442,   685,   730,   803,   829,   831,   823,   821,   833,   835,
-     573,   832,   838,   607,   834,   836,   443,   485,   839,   596,
-     486,   596,   487,   489,   491,   493,   495,   496,   499,   840,
-     842,   845,   468,   456,   848,   841,   843,   846,   850,   964,
-     849,   922,   923,   928,   851,   929,   930,   803,   803,   832,
-     931,   836,   839,   932,   933,   960,   843,   761,   762,   846,
-     851,   803,   862,   863,   476,   866,   867,   868,   869,   925,
-     528,   745,   444,   529,   803,   475,   891,   804,   892,   806,
-     488,   490,   824,   486,   486,   477,   464,   719,   720,   721,
-     722,   542,   750,   751,   752,   596,   712,   713,   714,   715,
-     733,   449,   733,   450,   723,   723,   884,   901,   709,   492,
-     886,   480,   486,   494,   699,   470,   486,   498,   855,   707,
-     486,   478,   486,   888,   889,   959,   711,   718,   726,   486,
-     486,   486,   729,   736,   671,   486,   486,   856,   803,   505,
-     857,   885,   859,   860,   861,   607,   607,   607,   607,   607,
-     607,   607,   607,   607,   607,   607,   607,   607,   607,   607,
-     607,   708,   708,   806,   500,   856,   515,   596,   911,   352,
-     353,   354,   803,   887,   708,   510,   708,   803,   934,   864,
-     865,   870,   871,   349,   522,   523,   527,   512,   567,   568,
-     569,   571,   570,   675,   665,   576,   577,   578,   579,   582,
-     583,   584,   585,   586,   913,   587,   591,   915,   621,   601,
-     590,   592,   595,   671,   683,   688,   -34,   524,   727,   766,
-     694,   918,   767,   738,   770,   775,   879,   773,   607,   607,
-     779,   780,   763,   698,   837,   764,   776,   741,   777,   596,
-     749,   607,   461,   607,   765,   781,   784,   915,   786,   787,
-     469,   423,   788,   789,   790,   947,   -36,   810,   424,   423,
-     431,   424,   407,   409,   952,   822,   424,   423,   431,   671,
-     423,   479,   -29,   830,   844,   423,   503,   847,   852,   961,
-     853,   916,   803,   894,   907,   926,   461,   517,   927,   935,
-     461,   937,   938,   936,   967,   423,   948,  -601,   953,   423,
-     564,   954,   477,   623,   966,   958,   955,   469,   873,   875,
-     872,   748,   446,   874,   912,   519,   423,   876,   854,   877,
-     919,   916,   956,   520,   521,   962,   516,   963,   920,   807,
-     939,   474,   900,   739,   597,   899,   902,   808,   904,   906,
-     908,   909,   477,   423,   903,   648,     0,   809,     0,     0,
-       0,     0,     0,     0,   647,     0,   905,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   910,     0,     0,     0,
+     427,   479,   434,   463,   410,   412,   479,   677,   471,   426,
+     625,   756,   705,   817,   529,   739,   478,   893,   564,   729,
+     684,   569,   480,   715,   754,   768,   769,   480,   705,   500,
+     836,   753,   454,   706,   779,   509,   822,   743,   823,   450,
+     826,   693,   764,   828,   765,   696,  -725,   463,   471,   758,
+     699,   699,  -725,   700,   440,   685,   686,   697,   455,   510,
+     613,   770,   771,   473,   837,   471,   707,   708,   709,   710,
+     780,   451,   673,   675,   515,   -35,   714,   687,   682,   683,
+     627,   688,   516,   702,   701,   701,   515,   714,   628,   702,
+     714,   702,   441,   672,   702,   599,   702,   515,   702,   702,
+     627,   627,   714,   702,   674,   772,   773,   679,   824,   829,
+     695,   802,   803,   804,   805,   806,   807,   808,   809,   810,
+     811,   964,   783,   794,   575,   796,   613,   527,   972,   515,
+     576,   812,   448,   577,   456,   583,   528,   613,   964,   578,
+     613,   584,   895,   490,   492,   494,   496,   498,   499,   502,
+     591,   677,   613,   677,   442,   677,   592,   703,   677,   608,
+     756,   610,   596,   690,   443,   609,   597,   611,   866,   691,
+     834,   832,   613,   736,   830,   840,   842,   844,   458,   846,
+     814,   576,   843,   845,   471,   847,   459,   849,   903,   851,
+     752,   853,   599,   850,   599,   852,   856,   854,   859,   467,
+     861,   936,   857,   937,   860,   979,   862,   814,   942,   814,
+     943,   944,   945,   946,   843,   947,   847,   850,   854,   857,
+     975,   862,   488,   908,   473,   489,   814,   909,   725,   726,
+     727,   728,   545,   444,   910,   445,   756,   479,   911,   766,
+     767,   835,   879,   880,   881,   882,   817,   718,   719,   720,
+     721,   465,   478,   904,   466,   905,   491,   493,   480,   489,
+     489,   495,   497,   501,   489,   489,   489,   531,   752,   939,
+     532,   713,   446,   717,   489,   897,   489,   814,   724,   899,
+     815,   489,   447,   739,   452,   739,   453,   729,   729,   914,
+     715,   481,   901,   902,   924,   867,   705,   732,   735,   742,
+     489,   489,   489,   677,   814,   900,   872,   873,   874,   613,
+     613,   613,   613,   613,   613,   613,   613,   613,   613,   613,
+     613,   613,   613,   613,   613,   868,   868,   974,   869,   870,
+     814,   756,   817,   898,   483,   868,   503,   471,   925,   814,
+     949,   752,   714,   714,   508,   353,   354,   355,   761,   762,
+     763,   875,   876,   883,   884,   714,   518,   714,   877,   878,
+     513,   350,   525,   526,   530,   515,   570,   571,   572,   574,
+     573,   681,   593,   579,   580,   927,   581,   582,   929,   585,
+     586,   704,   587,   748,   677,   595,   607,   588,   589,   590,
+     689,   594,   613,   613,   671,   694,   598,   -34,   627,   527,
+     700,   733,   760,   744,   777,   613,   751,   613,   778,   774,
+     781,   775,   776,   784,   786,   464,   787,   752,   821,   929,
+     788,   790,   791,   472,   426,   792,   795,   797,   962,   -36,
+     833,   427,   426,   434,   427,   410,   412,   967,   798,   427,
+     426,   434,   677,   426,   482,   799,   800,   801,   426,   506,
+     -29,   841,   976,   752,   848,   855,   863,   858,   864,   464,
+     520,   930,   952,   464,   871,   892,   907,   814,   426,   920,
+     940,   932,   426,   567,   941,   951,   953,   950,  -611,   968,
+     472,   969,   480,   629,   963,   973,   970,   981,   982,   426,
+     885,   887,   886,   890,   523,   449,   888,   759,   889,   757,
+     524,   522,   930,   755,   926,   933,   971,   600,   977,   934,
+     978,   954,   752,   519,   818,   477,   426,   819,   654,   745,
+     913,   820,   912,   480,   915,   919,   917,   653,   922,   923,
+     921,   916,     0,     0,     0,     0,   918,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   692,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   698,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   740,     0,   597,     0,
-     597,     0,     0,     0,     0,   423,     0,   423,     0,   423,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   747,
+       0,     0,   600,     0,   600,     0,   600,     0,   426,     0,
+       0,   426,     0,   426,     0,   426,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   648,     0,     0,     0,     0,     0,
-       0,     0,     0,   647,   424,     0,     0,     0,     0,     0,
-       0,     0,     0,   423,   597,     0,     0,     0,     0,     0,
-       0,     0,     0,   423,     0,     0,     0,     0,     0,     0,
+     654,     0,     0,     0,     0,     0,     0,     0,     0,   653,
+     427,     0,     0,     0,     0,     0,     0,     0,     0,   426,
+     600,     0,     0,     0,     0,     0,     0,     0,     0,   426,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   597,     0,     0,     0,
-       0,     0,     0,     0,     0,   423,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   648,     0,     0,     0,   648,     0,
-       0,     0,     0,   647,     0,     0,     0,   647,     0,     0,
+       0,     0,   747,   600,     0,     0,     0,     0,     0,     0,
+       0,   426,   426,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   654,     0,     0,     0,   654,
+       0,     0,     0,     0,   653,     0,     0,     0,   653,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   597,     0,
-       0,     0,     0,     0,     0,     0,     0,   423,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   600,
+       0,     0,     0,     0,     0,     0,     0,     0,   426,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   600,     0,     0,     0,     0,
+       0,     0,     0,     0,   426,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   654,   654,     0,   654,     0,   434,     0,
+       0,     0,   653,   653,     0,   653,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   600,     0,     0,     0,     0,     0,
+       0,     0,     0,   426,     0,   654,     0,     0,     0,     0,
+       0,     0,     0,     0,   653,     0,     0,     0,     0,     0,
+       0,     0,   654,     0,     0,     0,     0,     0,     0,   654,
+       0,   653,     0,     0,     0,     0,     0,     0,   653,   654,
+       0,     0,     0,   654,     0,     0,     0,     0,   653,   654,
+       0,     0,   653,     0,     0,     0,   476,     0,   653,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     648,   648,     0,   648,     0,   431,     0,     0,     0,   647,
-     647,     0,   647,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   648,     0,     0,     0,     0,     0,     0,     0,     0,
-     647,     0,     0,     0,     0,     0,     0,   648,     0,     0,
-       0,     0,     0,     0,   648,     0,   647,     0,     0,     0,
-       0,     0,     0,   647,   648,     0,     0,     0,   648,     0,
-       0,     0,     0,   647,   648,     0,     0,   647,     0,     0,
-       0,   473,     0,   647,     1,     2,     3,     4,     5,     6,
+       0,     0,   350,     0,     0,     0,     0,     0,     0,     0,
+     351,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,   356,     0,
+       0,     0,     0,     0,     0,     0,     0,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -1827,213 +1891,457 @@ static const yytype_int16 yytable[] =
      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
      327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
      337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,     0,     0,     0,     0,     0,     0,     0,     0,
+     347,   348,   349,     0,     0,   533,   534,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   349,     0,     0,     0,
-       0,     0,     0,     0,   350,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   351,   352,
+       0,     0,     0,     0,   535,   536,     0,   350,     0,   629,
+     630,     0,     0,     0,     0,   631,   537,   538,   539,   540,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,   356,     0,     0,     0,   541,   542,   543,
+     544,   545,   357,   358,   359,   360,   361,   362,   363,   632,
+     633,   634,   635,     0,   636,   637,   638,   639,   640,   641,
+     642,   643,   644,   645,   364,   365,   366,   367,   368,   369,
+     370,   546,   547,   548,   549,   550,   551,   552,   553,   371,
+     646,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
+     533,   534,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   535,
+     536,     0,   350,     0,   629,   816,     0,     0,     0,     0,
+     631,   537,   538,   539,   540,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,   356,     0,
+       0,     0,   541,   542,   543,   544,   545,   357,   358,   359,
+     360,   361,   362,   363,   632,   633,   634,   635,     0,   636,
+     637,   638,   639,   640,   641,   642,   643,   644,   645,   364,
+     365,   366,   367,   368,   369,   370,   546,   547,   548,   549,
+     550,   551,   552,   553,   371,   646,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,   533,   534,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   535,   536,     0,   350,     0,   629,
+       0,     0,     0,     0,     0,   631,   537,   538,   539,   540,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,   356,     0,     0,     0,   541,   542,   543,
+     544,   545,   357,   358,   359,   360,   361,   362,   363,   632,
+     633,   634,   635,     0,   636,   637,   638,   639,   640,   641,
+     642,   643,   644,   645,   364,   365,   366,   367,   368,   369,
+     370,   546,   547,   548,   549,   550,   551,   552,   553,   371,
+     646,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
+     533,   534,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   535,
+     536,     0,   350,     0,   518,     0,     0,     0,     0,     0,
+     631,   537,   538,   539,   540,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,   356,     0,
+       0,     0,   541,   542,   543,   544,   545,   357,   358,   359,
+     360,   361,   362,   363,   632,   633,   634,   635,     0,   636,
+     637,   638,   639,   640,   641,   642,   643,   644,   645,   364,
+     365,   366,   367,   368,   369,   370,   546,   547,   548,   549,
+     550,   551,   552,   553,   371,   646,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,   533,   534,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   535,   536,     0,   350,     0,     0,
+       0,     0,     0,     0,     0,   631,   537,   538,   539,   540,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,   356,     0,     0,     0,   541,   542,   543,
+     544,   545,   357,   358,   359,   360,   361,   362,   363,   632,
+     633,   634,   635,     0,   636,   637,   638,   639,   640,   641,
+     642,   643,   644,   645,   364,   365,   366,   367,   368,   369,
+     370,   546,   547,   548,   549,   550,   551,   552,   553,   371,
+     646,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
+     533,   534,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   535,
+     536,     0,   350,     0,     0,     0,     0,     0,     0,     0,
+     631,   537,   538,   539,   540,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,   356,     0,
+       0,     0,   541,   542,   543,   544,   545,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,   546,   547,   548,   549,
+     550,   551,   552,   553,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+       0,     0,     0,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,   533,   534,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   535,   536,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   537,   538,   539,   540,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,     0,     0,     0,     0,   541,   542,   543,
+     544,   545,   357,   358,   359,   360,   361,   362,   363,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   364,   365,   366,   367,   368,   369,
+     370,   546,   547,   548,   549,   550,   551,   552,   553,   371,
+       0,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+     381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   350,     0,     0,     0,     0,     0,     0,     0,
+     351,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,   356,     0,
+       0,     0,     0,     0,     0,     0,     0,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
+     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
+     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
+     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
+     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
+     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
+     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+       0,     0,     0,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
      353,   354,   355,     0,     0,     0,     0,     0,     0,     0,
-       0,   356,   357,   358,   359,   360,   361,   362,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   363,   364,   365,   366,   367,   368,   369,
-       0,     0,     0,     0,     0,     0,     0,     0,   370,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+       0,     0,   357,   358,   359,   360,   361,   362,   363,   632,
+       0,     0,   635,     0,   636,   637,     0,     0,   640,     0,
+       0,     0,     0,     0,   364,   365,   366,   367,   368,   369,
+     370,     0,     0,     0,     0,     0,     0,     0,     0,   371,
+       0,   372,   373,   374,   375,   376,   377,   378,   379,   380,
      381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
      391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,     0,     0,   530,   531,     0,     0,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,     0,     0,     0,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   532,   533,     0,   349,     0,
-     623,   624,     0,     0,     0,     0,   625,   534,   535,   536,
-     537,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     351,   352,   353,   354,   355,     0,     0,     0,   538,   539,
-     540,   541,   542,   356,   357,   358,   359,   360,   361,   362,
-     626,   627,   628,   629,     0,   630,   631,   632,   633,   634,
-     635,   636,   637,   638,   639,   363,   364,   365,   366,   367,
-     368,   369,   543,   544,   545,   546,   547,   548,   549,   550,
-     370,   640,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,     0,     0,   530,   531,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   532,   533,     0,
-     349,     0,   623,   805,     0,     0,     0,     0,   625,   534,
-     535,   536,   537,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   351,   352,   353,   354,   355,     0,     0,     0,
-     538,   539,   540,   541,   542,   356,   357,   358,   359,   360,
-     361,   362,   626,   627,   628,   629,     0,   630,   631,   632,
-     633,   634,   635,   636,   637,   638,   639,   363,   364,   365,
-     366,   367,   368,   369,   543,   544,   545,   546,   547,   548,
-     549,   550,   370,   640,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,     0,     0,
-     530,   531,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   532,
-     533,     0,   349,     0,   623,     0,     0,     0,     0,     0,
-     625,   534,   535,   536,   537,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   351,   352,   353,   354,   355,     0,
-       0,     0,   538,   539,   540,   541,   542,   356,   357,   358,
-     359,   360,   361,   362,   626,   627,   628,   629,     0,   630,
-     631,   632,   633,   634,   635,   636,   637,   638,   639,   363,
-     364,   365,   366,   367,   368,   369,   543,   544,   545,   546,
-     547,   548,   549,   550,   370,   640,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,     1,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-       0,     0,   530,   531,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   532,   533,     0,   349,     0,   515,     0,     0,     0,
-       0,     0,   625,   534,   535,   536,   537,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   351,   352,   353,   354,
-     355,     0,     0,     0,   538,   539,   540,   541,   542,   356,
-     357,   358,   359,   360,   361,   362,   626,   627,   628,   629,
-       0,   630,   631,   632,   633,   634,   635,   636,   637,   638,
-     639,   363,   364,   365,   366,   367,   368,   369,   543,   544,
-     545,   546,   547,   548,   549,   550,   370,   640,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,     1,     2,     3,     4,     5,     6,
+     468,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   352,   353,   354,   355,     0,     0,
+       0,     0,     0,     0,     0,     0,   469,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2067,214 +2375,70 @@ static const yytype_int16 yytable[] =
      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
      327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,     0,     0,   530,   531,     0,     0,     0,     0,
+       0,     0,     0,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   532,   533,     0,   349,     0,     0,     0,
-       0,     0,     0,     0,   625,   534,   535,   536,   537,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   351,   352,
-     353,   354,   355,     0,     0,     0,   538,   539,   540,   541,
-     542,   356,   357,   358,   359,   360,   361,   362,   626,   627,
-     628,   629,     0,   630,   631,   632,   633,   634,   635,   636,
-     637,   638,   639,   363,   364,   365,   366,   367,   368,   369,
-     543,   544,   545,   546,   547,   548,   549,   550,   370,   640,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+       0,     0,     0,     0,     0,     0,     0,   350,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   357,   358,   359,   360,   361,   362,   363,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   364,   365,   366,   367,   368,   369,
+     370,     0,     0,     0,     0,     0,     0,     0,     0,   371,
+       0,   372,   373,   374,   375,   376,   377,   378,   379,   380,
      381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
      391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,     0,     0,   530,   531,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   532,   533,     0,   349,     0,
-       0,     0,     0,     0,     0,     0,   625,   534,   535,   536,
-     537,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     351,   352,   353,   354,   355,     0,     0,     0,   538,   539,
-     540,   541,   542,   356,   357,   358,   359,   360,   361,   362,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   363,   364,   365,   366,   367,
-     368,   369,   543,   544,   545,   546,   547,   548,   549,   550,
-     370,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,     0,     0,     0,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,     0,     0,   530,   531,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   532,   533,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   534,
-     535,   536,   537,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   351,   352,   353,   354,     0,     0,     0,     0,
-     538,   539,   540,   541,   542,   356,   357,   358,   359,   360,
-     361,   362,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   363,   364,   365,
-     366,   367,   368,   369,   543,   544,   545,   546,   547,   548,
-     549,   550,   370,     0,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,     0,     0,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,     0,     0,     0,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   349,     0,     0,     0,     0,     0,     0,     0,
-     350,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   351,   352,   353,   354,   355,     0,
-       0,     0,     0,     0,     0,     0,     0,   356,   357,   358,
-     359,   360,   361,   362,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   363,
-     364,   365,   366,   367,   368,   369,     0,     0,     0,     0,
-       0,     0,     0,     0,   370,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,     1,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,     0,     0,     0,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+       0,     0,     0,     0,     0,     0,   521,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   351,   352,   353,   354,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   356,
-     357,   358,   359,   360,   361,   362,   626,     0,     0,   629,
-       0,   630,   631,     0,     0,   634,     0,     0,     0,     0,
-       0,   363,   364,   365,   366,   367,   368,   369,     0,     0,
-       0,     0,     0,     0,     0,     0,   370,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   352,   353,   354,   355,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2307,215 +2471,71 @@ static const yytype_int16 yytable[] =
      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,     0,
-       0,     0,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,     0,     0,     0,     0,     0,     0,     0,     0,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+       0,     0,     0,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   746,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   465,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   351,   352,
-     353,   354,     0,     0,     0,     0,     0,     0,     0,     0,
-     466,   356,   357,   358,   359,   360,   361,   362,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   357,   358,   359,   360,   361,   362,   363,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   363,   364,   365,   366,   367,   368,   369,
-       0,     0,     0,     0,     0,     0,     0,     0,   370,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+       0,     0,     0,     0,   364,   365,   366,   367,   368,   369,
+     370,     0,     0,     0,     0,     0,     0,     0,     0,   371,
+       0,   372,   373,   374,   375,   376,   377,   378,   379,   380,
      381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
      391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,     0,     0,     0,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   349,     0,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,     0,     0,     0,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     351,   352,   353,   354,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   356,   357,   358,   359,   360,   361,   362,
+       0,     0,     0,     0,     0,   906,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   363,   364,   365,   366,   367,
-     368,   369,     0,     0,     0,     0,     0,     0,     0,     0,
-     370,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,     0,     0,     0,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   518,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   351,   352,   353,   354,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   356,   357,   358,   359,   360,
-     361,   362,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   363,   364,   365,
-     366,   367,   368,   369,     0,     0,     0,     0,     0,     0,
-       0,     0,   370,     0,   371,   372,   373,   374,   375,   376,
-     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
-     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
-     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,     0,     0,     0,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   744,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   351,   352,   353,   354,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   356,   357,   358,
-     359,   360,   361,   362,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   363,
-     364,   365,   366,   367,   368,   369,     0,     0,     0,     0,
-       0,     0,     0,     0,   370,     0,   371,   372,   373,   374,
-     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
-     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
-     405,   406,     1,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,     0,     0,     0,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   858,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   351,   352,   353,   354,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   356,
-     357,   358,   359,   360,   361,   362,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   363,   364,   365,   366,   367,   368,   369,     0,     0,
-       0,     0,     0,     0,     0,     0,   370,     0,   371,   372,
-     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
-     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
-     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
-     403,   404,   405,   406,     1,     2,     3,     4,     5,     6,
+       0,     0,     0,     0,   352,   353,   354,   355,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     1,     2,     3,     4,     5,     6,
        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
@@ -2548,254 +2568,71 @@ static const yytype_int16 yytable[] =
      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,     0,
-       0,     0,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,     0,     0,     0,     0,     0,     0,     0,     0,
+     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
+       0,     0,     0,   340,   341,   342,   343,   344,   345,   346,
+     347,   348,   349,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   893,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   351,   352,
-     353,   354,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   356,   357,   358,   359,   360,   361,   362,     0,     0,
+     948,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   352,
+     353,   354,   355,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   357,   358,   359,   360,   361,   362,   363,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   363,   364,   365,   366,   367,   368,   369,
-       0,     0,     0,     0,     0,     0,     0,     0,   370,     0,
-     371,   372,   373,   374,   375,   376,   377,   378,   379,   380,
+       0,     0,     0,     0,   364,   365,   366,   367,   368,   369,
+     370,     0,     0,     0,     0,     0,     0,     0,     0,   371,
+       0,   372,   373,   374,   375,   376,   377,   378,   379,   380,
      381,   382,   383,   384,   385,   386,   387,   388,   389,   390,
      391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
-     401,   402,   403,   404,   405,   406,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,     0,     0,     0,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,     0,     0,     0,     0,     0,     0,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
+     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
+     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
+     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
+     332,   333,   334,   335,   336,     0,     0,     0,   340,   341,
+     342,   343,   344,   345,   346,   347,   348,   349,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     351,   352,   353,   354,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   356,   357,   358,   359,   360,   361,   362,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   363,   364,   365,   366,   367,
-     368,   369,     0,     0,     0,     0,     0,     0,     0,     0,
-     370,     0,   371,   372,   373,   374,   375,   376,   377,   378,
-     379,   380,   381,   382,   383,   384,   385,   386,   387,   388,
-     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
-     399,   400,   401,   402,   403,   404,   405,   406,     2,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    57,    58,     0,     0,    61,    62,    63,
-      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
-     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,   177,   178,     0,   180,     0,   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,     0,     0,     0,     0,     0,     0,   342,     0,
-       0,     0,   346,   347,   348,     0,     0,   530,   531,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   532,   533,     0,     0,
-       0,   670,   814,     0,     0,     0,     0,     0,   534,   535,
-     536,   537,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   538,
-     539,   540,   541,   542,   356,     0,     0,     0,     0,   361,
-     362,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   543,   544,   545,   546,   547,   548,   549,
-     550,     0,     0,   371,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   384,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,     0,     0,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,     0,   180,     0,   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,     0,     0,     0,     0,     0,     0,   342,     0,     0,
-       0,   346,   347,   348,     0,     0,   530,   531,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   532,   533,     0,     0,     0,
-     670,   924,     0,     0,     0,     0,     0,   534,   535,   536,
-     537,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   538,   539,
-     540,   541,   542,   356,     0,     0,     0,     0,   361,   362,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   543,   544,   545,   546,   547,   548,   549,   550,
-       0,     0,   371,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   384,     2,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    58,     0,     0,    61,    62,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,     0,   180,     0,   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,
-       0,     0,     0,     0,     0,     0,   342,     0,     0,     0,
-     346,   347,   348,     0,     0,   530,   531,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   532,   533,     0,     0,   606,     0,
-       0,     0,     0,     0,     0,     0,   534,   535,   536,   537,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   538,   539,   540,
-     541,   542,   356,     0,     0,     0,     0,   361,   362,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   543,   544,   545,   546,   547,   548,   549,   550,     0,
-       0,   371,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   384,     2,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,     0,   180,     0,   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,     0,
-       0,     0,     0,     0,     0,   342,     0,     0,     0,   346,
-     347,   348,     0,     0,   530,   531,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   532,   533,     0,     0,     0,   670,     0,
-       0,     0,     0,     0,     0,   534,   535,   536,   537,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   538,   539,   540,   541,
-     542,   356,     0,     0,     0,     0,   361,   362,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     543,   544,   545,   546,   547,   548,   549,   550,     0,     0,
-     371,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   384,     2,     3,     4,     5,     6,     7,
+       0,     0,     0,     0,   352,   353,   354,   355,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   357,   358,   359,
+     360,   361,   362,   363,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   364,
+     365,   366,   367,   368,   369,   370,     0,     0,     0,     0,
+       0,     0,     0,     0,   371,     0,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,     2,     3,     4,     5,     6,     7,
        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
@@ -2813,7 +2650,7 @@ static const yytype_int16 yytable[] =
      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,     0,   180,     0,   182,   183,   184,   185,   186,   187,
+     178,   179,     0,   181,     0,   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,
@@ -2828,1267 +2665,26 @@ static const yytype_int16 yytable[] =
      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,     0,     0,
-       0,     0,     0,     0,   342,     0,     0,     0,   346,   347,
-     348,     0,     0,   530,   531,     0,     0,     0,     0,     0,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   532,   533,     0,     0,   771,     0,     0,     0,
-       0,     0,     0,     0,   534,   535,   536,   537,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,   676,   825,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   538,   539,   540,   541,   542,
-     356,     0,     0,     0,     0,   361,   362,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   543,
-     544,   545,   546,   547,   548,   549,   550,     0,     0,   371,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   384,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-       0,     0,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-       0,   180,     0,   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,     0,     0,     0,
-       0,     0,     0,   342,     0,     0,     0,   346,   347,   348,
-       0,     0,   530,   531,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   532,   533,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   782,   534,   535,   536,   537,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   538,   539,   540,   541,   542,   356,
-       0,     0,     0,     0,   361,   362,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   543,   544,
-     545,   546,   547,   548,   549,   550,     0,     0,   371,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   384,     2,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    57,    58,     0,
-       0,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
-     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
-     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,   177,   178,     0,
-     180,     0,   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,     0,     0,     0,     0,
-       0,     0,   342,     0,     0,     0,   346,   347,   348,     0,
-       0,   530,   531,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     532,   533,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   534,   535,   536,   537,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   538,   539,   540,   541,   542,   356,     0,
-       0,     0,     0,   361,   362,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   543,   544,   545,
-     546,   547,   548,   549,   550,     0,     0,   371,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     384,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,     0,     0,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,     0,   180,
-       0,   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,     0,     0,     0,     0,     0,
-       0,   342,     0,     0,     0,   346,   347,   348,     0,     0,
-     530,   531,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   532,
-     533,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   534,   535,   536,   537,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   538,   539,   540,   541,   542,   356,     0,     0,
-       0,     0,   361,   686,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   543,   544,   545,   546,
-     547,   548,   549,   550,     0,     0,   371,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   384,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    58,     0,     0,    61,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,   177,   178,     0,   180,     0,
-     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,     0,     0,     0,     0,     0,     0,
-     342,     0,     0,     0,   346,   347,   348,     0,     0,   530,
-     531,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   532,   533,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     534,   535,   536,   537,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   538,   539,   540,   541,   731,   356,     0,     0,     0,
-       0,   361,   362,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   543,   544,   545,   546,   547,
-     548,   549,   550,     0,     0,   371,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   384,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,     0,     0,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,     0,   180,     0,   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,     0,     0,     0,     0,     0,     0,   342,
-       0,     0,     0,   346,   347,   348,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   356,     0,     0,     0,     0,
-     361,   362,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   371
-};
-
-static const yytype_int16 yycheck[] =
-{
-       0,   431,     0,   412,     0,     0,   436,   512,   573,     0,
-     589,   464,   431,   666,   583,   668,   525,   670,   471,   578,
-     673,   598,   431,   654,   589,   774,   420,   436,   443,   533,
-     600,   372,   470,   592,   375,   355,   356,   353,   354,   360,
-     409,   383,   601,   372,   937,   375,   372,   456,   372,   377,
-     559,   944,   375,   383,   376,   374,   374,   373,   380,   375,
-     383,   954,   380,   379,   433,   406,   460,   409,   373,   522,
-     523,   391,   392,   578,   512,   396,   405,   406,   407,   408,
-     406,   409,   406,   477,   589,   374,   380,   592,   373,   373,
-     375,   380,   530,   531,   375,   504,   601,   382,   392,   376,
-     373,   382,   391,   380,   674,   362,   363,   364,   365,   366,
-     367,   368,   369,   370,   371,   374,   621,   351,   352,   375,
-     375,   380,   571,   373,   562,   382,   382,   382,   577,   633,
-     579,   635,   375,   582,   385,   584,   387,   586,   587,   382,
-     578,   376,   591,   374,   374,   380,   374,   778,   375,   380,
-     380,   589,   380,   373,   592,   380,   571,   666,   383,   668,
-     813,   670,   374,   601,   673,   374,   383,   374,   380,   746,
-     373,   380,   587,   380,   374,   374,   685,   681,   374,   374,
-     380,   380,   374,   621,   380,   380,   373,   406,   380,   598,
-     409,   600,   438,   439,   440,   441,   442,   443,   444,   374,
-     374,   374,   596,   380,   374,   380,   380,   380,   374,   958,
-     380,   374,   374,   374,   380,   374,   374,   380,   380,   380,
-     374,   380,   380,   374,   374,   374,   380,   357,   358,   380,
-     380,   380,   753,   754,   664,   757,   758,   759,   760,   892,
-     380,   818,   373,   383,   380,   664,   378,   383,   380,   880,
-     406,   406,   690,   409,   409,   664,   409,   405,   406,   407,
-     408,   409,   388,   389,   390,   674,   405,   406,   407,   408,
-     849,   373,   851,   373,   843,   844,   780,   836,   837,   406,
-     784,   409,   409,   406,   849,   391,   409,   406,   741,   406,
-     409,   383,   409,   802,   803,   948,   406,   406,   406,   409,
-     409,   409,   406,   406,   813,   409,   409,   380,   380,   377,
-     383,   383,   750,   751,   752,   753,   754,   755,   756,   757,
-     758,   759,   760,   761,   762,   763,   764,   765,   766,   767,
-     768,   836,   837,   964,   409,   380,   377,   746,   383,   398,
-     399,   400,   380,   381,   849,   409,   851,   380,   381,   755,
-     756,   761,   762,   375,   409,   409,   377,   375,   374,   409,
-     383,   380,   382,   409,   379,   382,   380,   380,   380,   380,
-     380,   380,   380,   380,   878,   380,   380,   881,   375,   382,
-     374,   373,   383,   892,   374,   373,   373,   373,   372,   359,
-     375,   417,   361,   376,   376,   373,   376,   378,   836,   837,
-     373,   373,   395,   409,   380,   394,   383,   409,   383,   818,
-     409,   849,   412,   851,   393,   383,   373,   921,   381,   383,
-     420,   412,   383,   383,   383,   934,   373,   379,   428,   420,
-     428,   431,   428,   428,   938,   409,   436,   428,   436,   948,
-     431,   436,   374,   382,   380,   436,   446,   380,   374,   953,
-     374,   881,   380,   376,   372,   372,   456,   455,   406,   378,
-     460,   374,   373,   409,   378,   456,   382,   377,   383,   460,
-     470,   374,   881,   377,   383,   377,   421,   477,   764,   766,
-     763,   603,   355,   765,   856,   456,   477,   767,   740,   768,
-     883,   921,   943,   460,   460,   954,   454,   955,   883,   664,
-     921,   428,   834,   594,   504,   832,   837,   664,   841,   844,
-     847,   849,   921,   504,   839,   515,    -1,   664,    -1,    -1,
-      -1,    -1,    -1,    -1,   515,    -1,   843,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   851,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   567,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   596,    -1,   598,    -1,
-     600,    -1,    -1,    -1,    -1,   596,    -1,   598,    -1,   600,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   654,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   654,   664,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   664,   674,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   674,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   746,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   746,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   774,    -1,    -1,    -1,   778,    -1,
-      -1,    -1,    -1,   774,    -1,    -1,    -1,   778,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   818,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   818,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     880,   881,    -1,   883,    -1,   883,    -1,    -1,    -1,   880,
-     881,    -1,   883,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   921,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     921,    -1,    -1,    -1,    -1,    -1,    -1,   937,    -1,    -1,
-      -1,    -1,    -1,    -1,   944,    -1,   937,    -1,    -1,    -1,
-      -1,    -1,    -1,   944,   954,    -1,    -1,    -1,   958,    -1,
-      -1,    -1,    -1,   954,   964,    -1,    -1,   958,    -1,    -1,
-      -1,     0,    -1,   964,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   383,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   397,   398,
-     399,   400,   401,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   410,   411,   412,   413,   414,   415,   416,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   432,   433,   434,   435,   436,   437,   438,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   484,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,    -1,    -1,   353,   354,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   372,   373,    -1,   375,    -1,
-     377,   378,    -1,    -1,    -1,    -1,   383,   384,   385,   386,
-     387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     397,   398,   399,   400,   401,    -1,    -1,    -1,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-     417,   418,   419,   420,    -1,   422,   423,   424,   425,   426,
-     427,   428,   429,   430,   431,   432,   433,   434,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     447,   448,   449,   450,   451,   452,   453,   454,   455,   456,
-     457,   458,   459,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   484,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,    -1,    -1,   353,   354,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,   373,    -1,
-     375,    -1,   377,   378,    -1,    -1,    -1,    -1,   383,   384,
-     385,   386,   387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   397,   398,   399,   400,   401,    -1,    -1,    -1,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,   417,   418,   419,   420,    -1,   422,   423,   424,
-     425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,    -1,    -1,
-     353,   354,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,
-     373,    -1,   375,    -1,   377,    -1,    -1,    -1,    -1,    -1,
-     383,   384,   385,   386,   387,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   397,   398,   399,   400,   401,    -1,
-      -1,    -1,   405,   406,   407,   408,   409,   410,   411,   412,
-     413,   414,   415,   416,   417,   418,   419,   420,    -1,   422,
-     423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
-     433,   434,   435,   436,   437,   438,   439,   440,   441,   442,
-     443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
-     453,   454,   455,   456,   457,   458,   459,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   484,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,   338,   339,   340,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-      -1,    -1,   353,   354,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   372,   373,    -1,   375,    -1,   377,    -1,    -1,    -1,
-      -1,    -1,   383,   384,   385,   386,   387,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   397,   398,   399,   400,
-     401,    -1,    -1,    -1,   405,   406,   407,   408,   409,   410,
-     411,   412,   413,   414,   415,   416,   417,   418,   419,   420,
-      -1,   422,   423,   424,   425,   426,   427,   428,   429,   430,
-     431,   432,   433,   434,   435,   436,   437,   438,   439,   440,
-     441,   442,   443,   444,   445,   446,   447,   448,   449,   450,
-     451,   452,   453,   454,   455,   456,   457,   458,   459,   460,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   484,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,    -1,    -1,   353,   354,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   372,   373,    -1,   375,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   383,   384,   385,   386,   387,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   397,   398,
-     399,   400,   401,    -1,    -1,    -1,   405,   406,   407,   408,
-     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
-     419,   420,    -1,   422,   423,   424,   425,   426,   427,   428,
-     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
-     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   484,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,   338,   339,   340,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,    -1,    -1,   353,   354,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   372,   373,    -1,   375,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   383,   384,   385,   386,
-     387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     397,   398,   399,   400,   401,    -1,    -1,    -1,   405,   406,
-     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   432,   433,   434,   435,   436,
-     437,   438,   439,   440,   441,   442,   443,   444,   445,   446,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,   456,
-     457,   458,   459,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   484,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,    -1,    -1,    -1,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,    -1,    -1,   353,   354,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,   373,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,
-     385,   386,   387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   397,   398,   399,   400,    -1,    -1,    -1,    -1,
-     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
-     415,   416,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
-     445,   446,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   375,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     383,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   397,   398,   399,   400,   401,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   410,   411,   412,
-     413,   414,   415,   416,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   432,
-     433,   434,   435,   436,   437,   438,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,   456,   457,   458,   459,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   484,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,    -1,    -1,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   397,   398,   399,   400,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   410,
-     411,   412,   413,   414,   415,   416,   417,    -1,    -1,   420,
-      -1,   422,   423,    -1,    -1,   426,    -1,    -1,    -1,    -1,
-      -1,   432,   433,   434,   435,   436,   437,   438,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,   456,   457,   458,   459,   460,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   484,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,    -1,
-      -1,    -1,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   383,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   397,   398,
-     399,   400,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     409,   410,   411,   412,   413,   414,   415,   416,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   432,   433,   434,   435,   436,   437,   438,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   484,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,    -1,    -1,    -1,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   375,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     397,   398,   399,   400,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   410,   411,   412,   413,   414,   415,   416,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   432,   433,   434,   435,   436,
-     437,   438,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,   456,
-     457,   458,   459,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   484,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,    -1,    -1,    -1,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   379,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   397,   398,   399,   400,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   410,   411,   412,   413,   414,
-     415,   416,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   432,   433,   434,
-     435,   436,   437,   438,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   447,    -1,   449,   450,   451,   452,   453,   454,
-     455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
-     465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
-     475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,    -1,    -1,    -1,   341,   342,
-     343,   344,   345,   346,   347,   348,   349,   350,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   378,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   397,   398,   399,   400,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   410,   411,   412,
-     413,   414,   415,   416,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   432,
-     433,   434,   435,   436,   437,   438,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   447,    -1,   449,   450,   451,   452,
-     453,   454,   455,   456,   457,   458,   459,   460,   461,   462,
-     463,   464,   465,   466,   467,   468,   469,   470,   471,   472,
-     473,   474,   475,   476,   477,   478,   479,   480,   481,   482,
-     483,   484,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,    -1,    -1,
-     341,   342,   343,   344,   345,   346,   347,   348,   349,   350,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   378,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   397,   398,   399,   400,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   410,
-     411,   412,   413,   414,   415,   416,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   432,   433,   434,   435,   436,   437,   438,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   447,    -1,   449,   450,
-     451,   452,   453,   454,   455,   456,   457,   458,   459,   460,
-     461,   462,   463,   464,   465,   466,   467,   468,   469,   470,
-     471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
-     481,   482,   483,   484,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
-      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
-      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
-     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
-     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
-     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
-     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
-     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
-     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
-     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
-     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
-     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
-     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
-     329,   330,   331,   332,   333,   334,   335,   336,   337,    -1,
-      -1,    -1,   341,   342,   343,   344,   345,   346,   347,   348,
-     349,   350,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   378,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   397,   398,
-     399,   400,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   410,   411,   412,   413,   414,   415,   416,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   432,   433,   434,   435,   436,   437,   438,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   447,    -1,
-     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
-     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
-     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
-     479,   480,   481,   482,   483,   484,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,    -1,    -1,    -1,   341,   342,   343,   344,   345,   346,
-     347,   348,   349,   350,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     397,   398,   399,   400,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   410,   411,   412,   413,   414,   415,   416,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   432,   433,   434,   435,   436,
-     437,   438,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     447,    -1,   449,   450,   451,   452,   453,   454,   455,   456,
-     457,   458,   459,   460,   461,   462,   463,   464,   465,   466,
-     467,   468,   469,   470,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   482,   483,   484,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
-      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
-      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
-      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
-     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
-     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
-     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,   177,   178,   179,   180,    -1,   182,    -1,   184,   185,
-     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
-     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
-     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
-     216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
-     236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
-     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
-     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
-     286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
-     296,   297,   298,   299,   300,   301,   302,   303,   304,   305,
-     306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
-     316,   317,   318,   319,   320,   321,   322,   323,   324,   325,
-     326,   327,   328,   329,   330,   331,   332,   333,   334,   335,
-     336,   337,    -1,    -1,    -1,    -1,    -1,    -1,   344,    -1,
-      -1,    -1,   348,   349,   350,    -1,    -1,   353,   354,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   372,   373,    -1,    -1,
-      -1,   377,   378,    -1,    -1,    -1,    -1,    -1,   384,   385,
-     386,   387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   405,
-     406,   407,   408,   409,   410,    -1,    -1,    -1,    -1,   415,
-     416,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   439,   440,   441,   442,   443,   444,   445,
-     446,    -1,    -1,   449,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   462,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    58,    59,    60,    -1,    -1,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-     167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-     177,   178,   179,   180,    -1,   182,    -1,   184,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
-     227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
-     237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
-     247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
-     277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
-     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
-     317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
-     327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
-     337,    -1,    -1,    -1,    -1,    -1,    -1,   344,    -1,    -1,
-      -1,   348,   349,   350,    -1,    -1,   353,   354,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   372,   373,    -1,    -1,    -1,
-     377,   378,    -1,    -1,    -1,    -1,    -1,   384,   385,   386,
-     387,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   405,   406,
-     407,   408,   409,   410,    -1,    -1,    -1,    -1,   415,   416,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   439,   440,   441,   442,   443,   444,   445,   446,
-      -1,    -1,   449,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   462,     4,     5,     6,     7,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
-      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
@@ -4100,7 +2696,7 @@ static const yytype_int16 yycheck[] =
      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,    -1,   182,    -1,   184,   185,   186,   187,
+     178,   179,     0,   181,     0,   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,
@@ -4115,26 +2711,545 @@ static const yytype_int16 yycheck[] =
      298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
      308,   309,   310,   311,   312,   313,   314,   315,   316,   317,
      318,   319,   320,   321,   322,   323,   324,   325,   326,   327,
-     328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
-      -1,    -1,    -1,    -1,    -1,    -1,   344,    -1,    -1,    -1,
-     348,   349,   350,    -1,    -1,   353,   354,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   372,   373,    -1,    -1,   376,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   384,   385,   386,   387,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   405,   406,   407,
-     408,   409,   410,    -1,    -1,    -1,    -1,   415,   416,    -1,
+     328,   329,   330,   331,   332,   333,   334,   335,   336,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,   676,   938,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,   612,     0,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,   676,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,   782,     0,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   793,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     545,   357,     0,     0,     0,     0,   362,   692,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,   533,   534,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   535,   536,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   537,   538,   539,   540,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   541,   542,   543,   544,
+     737,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     546,   547,   548,   549,   550,   551,   552,   553,     0,     0,
+     372,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   385,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,     0,   181,     0,   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,     0,
+       0,     0,     0,     0,     0,   343,     0,     0,     0,   347,
+     348,   349,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   357,     0,     0,     0,     0,   362,   363,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     372
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,   434,     0,   415,     0,     0,   439,   528,   423,     0,
+     515,   604,   576,   660,   467,   592,   434,   785,   473,   586,
+     536,   474,   434,   581,   603,   356,   357,   439,   592,   446,
+     373,   602,   384,   373,   361,   410,   672,   595,   674,   378,
+     676,   562,   386,   679,   388,   381,   375,   459,   463,   607,
+     373,   373,   381,   376,   374,   354,   355,   393,   410,   434,
+     515,   392,   393,   392,   407,   480,   406,   407,   408,   409,
+     397,   410,   525,   526,   376,   374,   581,   376,   533,   534,
+     376,   380,   384,   574,   407,   407,   376,   592,   384,   580,
+     595,   582,   374,   383,   585,   507,   587,   376,   589,   590,
+     376,   376,   607,   594,   383,   358,   359,   383,   383,   680,
+     565,   363,   364,   365,   366,   367,   368,   369,   370,   371,
+     372,   952,   627,   639,   375,   641,   581,   374,   959,   376,
+     381,   383,   376,   375,   384,   375,   383,   592,   969,   381,
+     595,   381,   789,   441,   442,   443,   444,   445,   446,   447,
+     375,   672,   607,   674,   374,   676,   381,   574,   679,   375,
+     753,   375,   377,   375,   374,   381,   381,   381,   747,   381,
+     691,   687,   627,   590,   375,   375,   375,   375,   375,   375,
+     381,   381,   381,   381,   599,   381,   381,   375,   824,   375,
+     602,   375,   604,   381,   606,   381,   375,   381,   375,   410,
+     375,   375,   381,   375,   381,   973,   381,   381,   375,   381,
+     375,   375,   375,   375,   381,   375,   381,   381,   381,   381,
+     375,   381,   407,   377,   392,   410,   381,   381,   406,   407,
+     408,   409,   410,   374,   377,   374,   829,   670,   381,   352,
+     353,   696,   768,   769,   770,   771,   893,   406,   407,   408,
+     409,   381,   670,   379,   384,   381,   407,   407,   670,   410,
+     410,   407,   407,   407,   410,   410,   410,   381,   680,   905,
+     384,   407,   374,   407,   410,   791,   410,   381,   407,   795,
+     384,   410,   374,   860,   374,   862,   374,   854,   855,   847,
+     848,   384,   813,   814,   865,   748,   860,   407,   407,   407,
+     410,   410,   410,   824,   381,   382,   761,   762,   763,   764,
+     765,   766,   767,   768,   769,   770,   771,   772,   773,   774,
+     775,   776,   777,   778,   779,   381,   381,   963,   384,   384,
+     381,   924,   979,   384,   410,   381,   410,   752,   384,   381,
+     382,   753,   847,   848,   378,   399,   400,   401,   389,   390,
+     391,   764,   765,   772,   773,   860,   378,   862,   766,   767,
+     410,   376,   410,   410,   378,   376,   375,   410,   384,   381,
+     383,   410,   375,   383,   381,   891,   381,   381,   894,   381,
+     381,   410,   381,   410,   905,   374,   383,   381,   381,   381,
+     375,   381,   847,   848,   380,   374,   384,   374,   376,   374,
+     376,   373,   410,   377,   360,   860,   379,   862,   362,   396,
+     377,   395,   394,   379,   374,   415,   384,   829,   380,   935,
+     384,   374,   374,   423,   415,   384,   374,   382,   949,   374,
+     410,   431,   423,   431,   434,   431,   431,   953,   384,   439,
+     431,   439,   963,   434,   439,   384,   384,   384,   439,   449,
+     375,   383,   968,   865,   381,   381,   375,   381,   375,   459,
+     458,   894,   375,   463,   379,   377,   377,   381,   459,   373,
+     373,   418,   463,   473,   407,   410,   374,   379,   378,   384,
+     480,   375,   894,   378,   383,   378,   422,   384,   379,   480,
+     774,   776,   775,   779,   463,   356,   777,   609,   778,   606,
+     463,   459,   935,   604,   868,   896,   958,   507,   969,   896,
+     970,   935,   924,   457,   670,   431,   507,   670,   518,   597,
+     845,   670,   843,   935,   848,   855,   852,   518,   860,   862,
+     858,   850,    -1,    -1,    -1,    -1,   854,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   439,   440,   441,   442,   443,   444,   445,   446,    -1,
-      -1,   449,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   462,     4,     5,     6,     7,     8,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   570,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   599,
+      -1,    -1,   602,    -1,   604,    -1,   606,    -1,   599,    -1,
+      -1,   602,    -1,   604,    -1,   606,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     660,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   660,
+     670,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   670,
+     680,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   680,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   752,   753,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   752,   753,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   785,    -1,    -1,    -1,   789,
+      -1,    -1,    -1,    -1,   785,    -1,    -1,    -1,   789,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   829,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   829,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   865,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   865,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   893,   894,    -1,   896,    -1,   896,    -1,
+      -1,    -1,   893,   894,    -1,   896,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   924,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   924,    -1,   935,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   935,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   952,    -1,    -1,    -1,    -1,    -1,    -1,   959,
+      -1,   952,    -1,    -1,    -1,    -1,    -1,    -1,   959,   969,
+      -1,    -1,    -1,   973,    -1,    -1,    -1,    -1,   969,   979,
+      -1,    -1,   973,    -1,    -1,    -1,     0,    -1,   979,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   376,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     384,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
+      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,
@@ -4146,7 +3261,7 @@ static const yytype_int16 yycheck[] =
      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,    -1,   182,    -1,   184,   185,   186,   187,   188,
+     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,
@@ -4161,20 +3276,750 @@ 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,   337,    -1,
-      -1,    -1,    -1,    -1,    -1,   344,    -1,    -1,    -1,   348,
-     349,   350,    -1,    -1,   353,   354,    -1,    -1,    -1,    -1,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   372,   373,    -1,    -1,    -1,   377,    -1,
-      -1,    -1,    -1,    -1,    -1,   384,   385,   386,   387,    -1,
+      -1,    -1,    -1,    -1,   373,   374,    -1,   376,    -1,   378,
+     379,    -1,    -1,    -1,    -1,   384,   385,   386,   387,   388,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,   402,    -1,    -1,    -1,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,    -1,   423,   424,   425,   426,   427,   428,
+     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+     354,   355,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,
+     374,    -1,   376,    -1,   378,   379,    -1,    -1,    -1,    -1,
+     384,   385,   386,   387,   388,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,    -1,
+      -1,    -1,   406,   407,   408,   409,   410,   411,   412,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,    -1,   423,
+     424,   425,   426,   427,   428,   429,   430,   431,   432,   433,
+     434,   435,   436,   437,   438,   439,   440,   441,   442,   443,
+     444,   445,   446,   447,   448,   449,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   405,   406,   407,   408,
-     409,   410,    -1,    -1,    -1,    -1,   415,   416,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,    -1,   376,    -1,   378,
+      -1,    -1,    -1,    -1,    -1,   384,   385,   386,   387,   388,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,   402,    -1,    -1,    -1,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,    -1,   423,   424,   425,   426,   427,   428,
+     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+     354,   355,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,
+     374,    -1,   376,    -1,   378,    -1,    -1,    -1,    -1,    -1,
+     384,   385,   386,   387,   388,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,    -1,
+      -1,    -1,   406,   407,   408,   409,   410,   411,   412,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,    -1,   423,
+     424,   425,   426,   427,   428,   429,   430,   431,   432,   433,
+     434,   435,   436,   437,   438,   439,   440,   441,   442,   443,
+     444,   445,   446,   447,   448,   449,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+     339,   340,   341,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,    -1,   376,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   384,   385,   386,   387,   388,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,   402,    -1,    -1,    -1,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
+     419,   420,   421,    -1,   423,   424,   425,   426,   427,   428,
+     429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+     449,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+     354,   355,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,
+     374,    -1,   376,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     384,   385,   386,   387,   388,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,    -1,
+      -1,    -1,   406,   407,   408,   409,   410,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,   440,   441,   442,   443,
+     444,   445,   446,   447,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,    -1,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,    -1,    -1,    -1,    -1,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   433,   434,   435,   436,   437,   438,
+     439,   440,   441,   442,   443,   444,   445,   446,   447,   448,
+      -1,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     439,   440,   441,   442,   443,   444,   445,   446,    -1,    -1,
-     449,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   462,     4,     5,     6,     7,     8,     9,
+      -1,    -1,   376,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     384,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,   402,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,    -1,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   411,   412,   413,   414,   415,   416,   417,   418,
+      -1,    -1,   421,    -1,   423,   424,    -1,    -1,   427,    -1,
+      -1,    -1,    -1,    -1,   433,   434,   435,   436,   437,   438,
+     439,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   448,
+      -1,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,    -1,    -1,    -1,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     384,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   410,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,    -1,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   411,   412,   413,   414,   415,   416,   417,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   433,   434,   435,   436,   437,   438,
+     439,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   448,
+      -1,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,    -1,    -1,    -1,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   380,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,    -1,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   378,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   411,   412,   413,   414,   415,   416,   417,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   433,   434,   435,   436,   437,   438,
+     439,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   448,
+      -1,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,    -1,    -1,    -1,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   379,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+     159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
+     239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
+     249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
+     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
+     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
+     289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
+     299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
+     329,   330,   331,   332,   333,   334,   335,   336,   337,   338,
+      -1,    -1,    -1,   342,   343,   344,   345,   346,   347,   348,
+     349,   350,   351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     379,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   398,
+     399,   400,   401,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   411,   412,   413,   414,   415,   416,   417,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   433,   434,   435,   436,   437,   438,
+     439,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   448,
+      -1,   450,   451,   452,   453,   454,   455,   456,   457,   458,
+     459,   460,   461,   462,   463,   464,   465,   466,   467,   468,
+     469,   470,   471,   472,   473,   474,   475,   476,   477,   478,
+     479,   480,   481,   482,   483,   484,   485,   486,   487,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
+     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
+     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
+     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
+     334,   335,   336,   337,   338,    -1,    -1,    -1,   342,   343,
+     344,   345,   346,   347,   348,   349,   350,   351,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   398,   399,   400,   401,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   411,   412,   413,
+     414,   415,   416,   417,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   433,
+     434,   435,   436,   437,   438,   439,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   448,    -1,   450,   451,   452,   453,
+     454,   455,   456,   457,   458,   459,   460,   461,   462,   463,
+     464,   465,   466,   467,   468,   469,   470,   471,   472,   473,
+     474,   475,   476,   477,   478,   479,   480,   481,   482,   483,
+     484,   485,   486,   487,     4,     5,     6,     7,     8,     9,
       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
@@ -4192,7 +4037,7 @@ static const yytype_int16 yycheck[] =
      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,    -1,   182,    -1,   184,   185,   186,   187,   188,   189,
+     180,   181,    -1,   183,    -1,   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,
@@ -4207,248 +4052,433 @@ static const yytype_int16 yycheck[] =
      300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
      310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
      320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
-     330,   331,   332,   333,   334,   335,   336,   337,    -1,    -1,
-      -1,    -1,    -1,    -1,   344,    -1,    -1,    -1,   348,   349,
-     350,    -1,    -1,   353,   354,    -1,    -1,    -1,    -1,    -1,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   372,   373,    -1,    -1,   376,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   384,   385,   386,   387,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,   378,   379,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   405,   406,   407,   408,   409,
-     410,    -1,    -1,    -1,    -1,   415,   416,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   439,
-     440,   441,   442,   443,   444,   445,   446,    -1,    -1,   449,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   462,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      -1,    -1,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
-     161,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-      -1,   182,    -1,   184,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
-     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-     211,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-     221,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   232,   233,   234,   235,   236,   237,   238,   239,   240,
-     241,   242,   243,   244,   245,   246,   247,   248,   249,   250,
-     251,   252,   253,   254,   255,   256,   257,   258,   259,   260,
-     261,   262,   263,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
-     291,   292,   293,   294,   295,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
-     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
-     321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
-     331,   332,   333,   334,   335,   336,   337,    -1,    -1,    -1,
-      -1,    -1,    -1,   344,    -1,    -1,    -1,   348,   349,   350,
-      -1,    -1,   353,   354,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   372,   373,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   383,   384,   385,   386,   387,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,   378,   379,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   405,   406,   407,   408,   409,   410,
-      -1,    -1,    -1,    -1,   415,   416,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   439,   440,
-     441,   442,   443,   444,   445,   446,    -1,    -1,   449,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   462,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
-      -1,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,    -1,
-     182,    -1,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-     292,   293,   294,   295,   296,   297,   298,   299,   300,   301,
-     302,   303,   304,   305,   306,   307,   308,   309,   310,   311,
-     312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
-     322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
-     332,   333,   334,   335,   336,   337,    -1,    -1,    -1,    -1,
-      -1,    -1,   344,    -1,    -1,    -1,   348,   349,   350,    -1,
-      -1,   353,   354,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     372,   373,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   384,   385,   386,   387,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,   377,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   405,   406,   407,   408,   409,   410,    -1,
-      -1,    -1,    -1,   415,   416,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   439,   440,   441,
-     442,   443,   444,   445,   446,    -1,    -1,   449,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     462,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    -1,    -1,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
-     163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,    -1,   182,
-      -1,   184,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   227,   228,   229,   230,   231,   232,
-     233,   234,   235,   236,   237,   238,   239,   240,   241,   242,
-     243,   244,   245,   246,   247,   248,   249,   250,   251,   252,
-     253,   254,   255,   256,   257,   258,   259,   260,   261,   262,
-     263,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
-     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
-     293,   294,   295,   296,   297,   298,   299,   300,   301,   302,
-     303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
-     333,   334,   335,   336,   337,    -1,    -1,    -1,    -1,    -1,
-      -1,   344,    -1,    -1,    -1,   348,   349,   350,    -1,    -1,
-     353,   354,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,
-     373,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   384,   385,   386,   387,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   405,   406,   407,   408,   409,   410,    -1,    -1,
-      -1,    -1,   415,   416,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,   378,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   439,   440,   441,   442,
-     443,   444,   445,   446,    -1,    -1,   449,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   462,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
-      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
-     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
-     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
-     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,   177,   178,   179,   180,    -1,   182,    -1,
-     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
-     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
-     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
-     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
-     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
-     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
-     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
-     294,   295,   296,   297,   298,   299,   300,   301,   302,   303,
-     304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
-     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   331,   332,   333,
-     334,   335,   336,   337,    -1,    -1,    -1,    -1,    -1,    -1,
-     344,    -1,    -1,    -1,   348,   349,   350,    -1,    -1,   353,
-     354,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,   373,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     384,   385,   386,   387,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   405,   406,   407,   408,   409,   410,    -1,    -1,    -1,
-      -1,   415,   416,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   439,   440,   441,   442,   443,
-     444,   445,   446,    -1,    -1,   449,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   462,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    -1,    -1,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,    -1,   182,    -1,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,    -1,    -1,    -1,    -1,    -1,    -1,   344,
-      -1,    -1,    -1,   348,   349,   350,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,   377,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   384,   385,   386,   387,   388,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,   354,   355,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   385,   386,   387,   388,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   406,   407,   408,   409,
+     410,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     440,   441,   442,   443,   444,   445,   446,   447,    -1,    -1,
+     450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   463,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,    -1,   183,    -1,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   304,   305,   306,   307,   308,   309,
+     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
+     320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
+     330,   331,   332,   333,   334,   335,   336,   337,   338,    -1,
+      -1,    -1,    -1,    -1,    -1,   345,    -1,    -1,    -1,   349,
+     350,   351,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   410,    -1,    -1,    -1,    -1,
-     415,   416,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   411,    -1,    -1,    -1,    -1,   416,   417,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   449
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     450
 };
 
 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
@@ -4489,147 +4519,150 @@ static const yytype_int16 yystos[] =
      312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
      322,   323,   324,   325,   326,   327,   328,   329,   330,   331,
      332,   333,   334,   335,   336,   337,   338,   339,   340,   341,
-     342,   343,   344,   345,   346,   347,   348,   349,   350,   375,
-     383,   397,   398,   399,   400,   401,   410,   411,   412,   413,
-     414,   415,   416,   432,   433,   434,   435,   436,   437,   438,
-     447,   449,   450,   451,   452,   453,   454,   455,   456,   457,
+     342,   343,   344,   345,   346,   347,   348,   349,   350,   351,
+     376,   384,   398,   399,   400,   401,   402,   411,   412,   413,
+     414,   415,   416,   417,   433,   434,   435,   436,   437,   438,
+     439,   448,   450,   451,   452,   453,   454,   455,   456,   457,
      458,   459,   460,   461,   462,   463,   464,   465,   466,   467,
      468,   469,   470,   471,   472,   473,   474,   475,   476,   477,
-     478,   479,   480,   481,   482,   483,   484,   516,   517,   520,
-     521,   522,   523,   527,   528,   529,   530,   531,   532,   535,
-     536,   537,   538,   539,   541,   546,   547,   548,   589,   590,
-     591,   593,   600,   604,   605,   611,   614,   373,   373,   373,
-     373,   373,   373,   373,   373,   375,   547,   377,   409,   373,
-     373,   383,   409,   383,   592,   374,   380,   524,   525,   526,
-     536,   541,   380,   383,   409,   383,   409,   519,   537,   541,
-     391,   543,   544,     0,   590,   521,   529,   536,   383,   520,
-     409,   596,   597,   615,   616,   406,   409,   596,   406,   596,
-     406,   596,   406,   596,   406,   596,   596,   615,   406,   596,
-     409,   594,   595,   541,   550,   377,   409,   433,   533,   534,
-     409,   540,   375,   383,   542,   377,   568,   593,   379,   525,
-     524,   526,   409,   409,   373,   382,   542,   377,   380,   383,
-     353,   354,   372,   373,   384,   385,   386,   387,   405,   406,
-     407,   408,   409,   439,   440,   441,   442,   443,   444,   445,
-     446,   486,   487,   488,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   539,   541,   545,   542,   374,   409,   383,
-     382,   380,   374,   380,   374,   380,   382,   380,   380,   380,
-     374,   380,   380,   380,   380,   380,   380,   380,   374,   380,
-     374,   380,   373,   376,   380,   383,   536,   541,   551,   552,
-     549,   382,   374,   380,   374,   380,   376,   497,   499,   500,
-     501,   502,   503,   504,   505,   506,   507,   508,   509,   510,
-     541,   375,   383,   377,   378,   383,   417,   418,   419,   420,
-     422,   423,   424,   425,   426,   427,   428,   429,   430,   431,
-     448,   497,   510,   512,   514,   516,   520,   539,   541,   557,
-     558,   559,   560,   561,   569,   570,   571,   572,   575,   576,
-     579,   580,   581,   588,   593,   379,   382,   542,   382,   542,
-     377,   512,   555,   382,   518,   409,   497,   497,   514,   353,
-     354,   375,   379,   374,   374,   380,   416,   512,   373,   497,
-     380,   392,   593,   372,   375,   406,   597,   615,   409,   616,
-     372,   405,   406,   407,   408,   601,   602,   406,   510,   515,
-     603,   406,   405,   406,   407,   408,   606,   607,   406,   405,
-     406,   407,   408,   486,   608,   609,   406,   372,   610,   406,
-     615,   409,   515,   546,   612,   613,   406,   515,   376,   595,
-     541,   409,   553,   554,   378,   552,   551,   515,   534,   409,
-     388,   389,   390,   385,   387,   351,   352,   355,   356,   391,
-     392,   357,   358,   395,   394,   393,   359,   361,   360,   396,
-     376,   376,   510,   378,   562,   373,   383,   383,   583,   373,
-     373,   383,   383,   514,   373,   514,   381,   383,   383,   383,
-     383,   362,   363,   364,   365,   366,   367,   368,   369,   370,
-     371,   382,   513,   380,   383,   378,   558,   572,   576,   581,
-     379,   555,   555,   382,   378,   555,   556,   555,   551,   374,
-     489,   514,   409,   512,   497,   372,   406,   598,   599,   374,
-     382,   374,   380,   374,   380,   374,   380,   380,   374,   380,
-     374,   380,   374,   380,   380,   374,   380,   380,   374,   380,
-     374,   380,   374,   374,   553,   542,   380,   383,   378,   497,
-     497,   497,   499,   499,   500,   500,   501,   501,   501,   501,
-     502,   502,   503,   504,   505,   506,   507,   508,   511,   376,
-     569,   582,   558,   584,   514,   383,   514,   381,   512,   512,
-     555,   378,   380,   378,   376,   376,   380,   376,   380,   602,
-     601,   515,   603,   607,   606,   609,   608,   372,   610,   612,
-     613,   383,   554,   514,   563,   514,   529,   574,   417,   557,
-     570,   585,   374,   374,   378,   555,   372,   406,   374,   374,
-     374,   374,   374,   374,   381,   378,   409,   374,   373,   574,
-     586,   587,   565,   566,   567,   573,   577,   512,   382,   559,
-     564,   568,   514,   383,   374,   421,   561,   559,   377,   555,
-     374,   514,   564,   565,   569,   578,   383,   378
+     478,   479,   480,   481,   482,   483,   484,   485,   486,   487,
+     519,   520,   523,   524,   525,   526,   530,   531,   532,   533,
+     534,   535,   538,   539,   540,   541,   542,   544,   549,   550,
+     551,   596,   597,   598,   600,   607,   611,   612,   618,   621,
+     374,   374,   374,   374,   374,   374,   374,   374,   376,   550,
+     378,   410,   374,   374,   384,   410,   384,   599,   375,   381,
+     527,   528,   529,   539,   544,   381,   384,   410,   384,   410,
+     522,   540,   544,   392,   546,   547,     0,   597,   524,   532,
+     539,   384,   523,   410,   603,   604,   622,   623,   407,   410,
+     603,   407,   603,   407,   603,   407,   603,   407,   603,   603,
+     622,   407,   603,   410,   601,   602,   544,   553,   378,   410,
+     434,   536,   537,   410,   543,   376,   384,   545,   378,   575,
+     600,   380,   528,   527,   529,   410,   410,   374,   383,   545,
+     378,   381,   384,   354,   355,   373,   374,   385,   386,   387,
+     388,   406,   407,   408,   409,   410,   440,   441,   442,   443,
+     444,   445,   446,   447,   489,   490,   491,   493,   494,   495,
+     496,   497,   498,   499,   500,   501,   542,   544,   548,   545,
+     375,   410,   384,   383,   381,   375,   381,   375,   381,   383,
+     381,   381,   381,   375,   381,   381,   381,   381,   381,   381,
+     381,   375,   381,   375,   381,   374,   377,   381,   384,   539,
+     544,   554,   555,   556,   558,   559,   552,   383,   375,   381,
+     375,   381,   377,   500,   502,   503,   504,   505,   506,   507,
+     508,   509,   510,   511,   512,   513,   544,   376,   384,   378,
+     379,   384,   418,   419,   420,   421,   423,   424,   425,   426,
+     427,   428,   429,   430,   431,   432,   449,   500,   513,   515,
+     517,   519,   523,   542,   544,   564,   565,   566,   567,   568,
+     576,   577,   578,   579,   582,   583,   586,   587,   588,   595,
+     600,   380,   383,   545,   383,   545,   378,   515,   562,   383,
+     521,   410,   500,   500,   517,   354,   355,   376,   380,   375,
+     375,   381,   417,   515,   374,   500,   381,   393,   600,   373,
+     376,   407,   604,   622,   410,   623,   373,   406,   407,   408,
+     409,   608,   609,   407,   513,   518,   610,   407,   406,   407,
+     408,   409,   613,   614,   407,   406,   407,   408,   409,   489,
+     615,   616,   407,   373,   617,   407,   622,   410,   518,   549,
+     619,   620,   407,   518,   377,   602,   378,   544,   410,   560,
+     561,   379,   539,   558,   560,   555,   559,   554,   518,   537,
+     410,   389,   390,   391,   386,   388,   352,   353,   356,   357,
+     392,   393,   358,   359,   396,   395,   394,   360,   362,   361,
+     397,   377,   377,   513,   379,   569,   374,   384,   384,   590,
+     374,   374,   384,   384,   517,   374,   517,   382,   384,   384,
+     384,   384,   363,   364,   365,   366,   367,   368,   369,   370,
+     371,   372,   383,   516,   381,   384,   379,   565,   579,   583,
+     588,   380,   562,   562,   383,   379,   562,   563,   562,   558,
+     375,   492,   517,   410,   515,   500,   373,   407,   605,   606,
+     375,   383,   375,   381,   375,   381,   375,   381,   381,   375,
+     381,   375,   381,   375,   381,   381,   375,   381,   381,   375,
+     381,   375,   381,   375,   375,   557,   560,   545,   381,   384,
+     384,   379,   500,   500,   500,   502,   502,   503,   503,   504,
+     504,   504,   504,   505,   505,   506,   507,   508,   509,   510,
+     511,   514,   377,   576,   589,   565,   591,   517,   384,   517,
+     382,   515,   515,   562,   379,   381,   379,   377,   377,   381,
+     377,   381,   609,   608,   518,   610,   614,   613,   616,   615,
+     373,   617,   619,   620,   558,   384,   561,   517,   570,   517,
+     532,   581,   418,   564,   577,   592,   375,   375,   379,   562,
+     373,   407,   375,   375,   375,   375,   375,   375,   379,   382,
+     379,   410,   375,   374,   581,   593,   594,   572,   573,   574,
+     580,   584,   515,   383,   566,   571,   575,   517,   384,   375,
+     422,   568,   566,   378,   562,   375,   517,   571,   572,   576,
+     585,   384,   379
 };
 
 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
 static const yytype_int16 yyr1[] =
 {
-       0,   485,   486,   487,   487,   487,   487,   487,   487,   487,
-     487,   487,   487,   487,   487,   487,   487,   487,   488,   488,
-     488,   488,   488,   488,   489,   490,   491,   492,   492,   493,
-     493,   494,   494,   495,   496,   496,   496,   497,   497,   497,
-     497,   498,   498,   498,   498,   499,   499,   499,   499,   500,
-     500,   500,   501,   501,   501,   502,   502,   502,   502,   502,
-     503,   503,   503,   504,   504,   505,   505,   506,   506,   507,
-     507,   508,   508,   509,   509,   510,   511,   510,   512,   512,
-     513,   513,   513,   513,   513,   513,   513,   513,   513,   513,
-     513,   514,   514,   515,   516,   516,   516,   516,   516,   516,
-     516,   516,   516,   516,   518,   517,   519,   519,   520,   520,
-     520,   520,   521,   521,   522,   522,   522,   523,   524,   524,
-     524,   525,   525,   525,   525,   526,   527,   527,   527,   527,
-     527,   528,   528,   528,   528,   528,   529,   529,   530,   531,
-     531,   531,   531,   531,   531,   531,   531,   531,   531,   532,
-     533,   533,   534,   534,   534,   535,   536,   536,   537,   537,
-     537,   537,   537,   537,   537,   537,   537,   537,   537,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   538,
-     538,   538,   538,   538,   538,   538,   538,   538,   538,   539,
-     540,   540,   541,   541,   542,   542,   542,   542,   543,   543,
-     544,   545,   545,   545,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   546,   546,   546,   546,   546,   546,   546,   546,
-     546,   546,   547,   547,   547,   549,   548,   550,   548,   551,
-     551,   552,   552,   553,   553,   554,   554,   555,   555,   555,
-     555,   556,   556,   557,   558,   558,   559,   559,   559,   559,
-     559,   559,   559,   559,   560,   561,   562,   563,   561,   564,
-     564,   566,   565,   567,   565,   568,   568,   569,   569,   570,
-     570,   571,   571,   572,   573,   573,   574,   574,   575,   575,
-     577,   576,   578,   578,   579,   579,   580,   580,   582,   581,
-     583,   581,   584,   581,   585,   585,   586,   586,   587,   587,
-     588,   588,   588,   588,   588,   588,   588,   588,   589,   589,
-     590,   590,   590,   592,   591,   593,   594,   594,   595,   595,
-     596,   596,   597,   597,   598,   598,   599,   599,   600,   600,
-     600,   600,   600,   600,   601,   601,   602,   602,   602,   602,
-     602,   603,   603,   604,   604,   605,   605,   605,   605,   605,
-     605,   605,   605,   606,   606,   607,   607,   607,   607,   608,
-     608,   609,   609,   609,   609,   609,   610,   610,   611,   611,
-     611,   611,   612,   612,   613,   613,   614,   614,   615,   615,
-     616,   616
+       0,   488,   489,   490,   490,   490,   490,   490,   490,   490,
+     490,   490,   490,   490,   490,   490,   490,   490,   491,   491,
+     491,   491,   491,   491,   492,   493,   494,   495,   495,   496,
+     496,   497,   497,   498,   499,   499,   499,   500,   500,   500,
+     500,   501,   501,   501,   501,   502,   502,   502,   502,   503,
+     503,   503,   504,   504,   504,   505,   505,   505,   505,   505,
+     506,   506,   506,   507,   507,   508,   508,   509,   509,   510,
+     510,   511,   511,   512,   512,   513,   514,   513,   515,   515,
+     516,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+     516,   517,   517,   518,   519,   519,   519,   519,   519,   519,
+     519,   519,   519,   519,   521,   520,   522,   522,   523,   523,
+     523,   523,   524,   524,   525,   525,   525,   526,   527,   527,
+     527,   528,   528,   528,   528,   529,   530,   530,   530,   530,
+     530,   531,   531,   531,   531,   531,   532,   532,   533,   534,
+     534,   534,   534,   534,   534,   534,   534,   534,   534,   535,
+     536,   536,   537,   537,   537,   538,   539,   539,   540,   540,
+     540,   540,   540,   540,   540,   540,   540,   540,   540,   541,
+     541,   541,   541,   541,   541,   541,   541,   541,   541,   541,
+     541,   541,   541,   541,   541,   541,   541,   541,   541,   541,
+     541,   541,   541,   541,   541,   541,   541,   541,   541,   541,
+     541,   541,   541,   541,   541,   541,   541,   541,   541,   541,
+     541,   542,   543,   543,   544,   544,   545,   545,   545,   545,
+     546,   546,   547,   548,   548,   548,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   549,   549,   549,   549,   549,
+     549,   549,   549,   549,   549,   550,   550,   550,   552,   551,
+     553,   551,   554,   554,   554,   554,   555,   557,   556,   558,
+     558,   559,   559,   560,   560,   561,   561,   562,   562,   562,
+     562,   563,   563,   564,   565,   565,   566,   566,   566,   566,
+     566,   566,   566,   566,   567,   568,   569,   570,   568,   571,
+     571,   573,   572,   574,   572,   575,   575,   576,   576,   577,
+     577,   578,   578,   579,   580,   580,   581,   581,   582,   582,
+     584,   583,   585,   585,   586,   586,   587,   587,   589,   588,
+     590,   588,   591,   588,   592,   592,   593,   593,   594,   594,
+     595,   595,   595,   595,   595,   595,   595,   595,   596,   596,
+     597,   597,   597,   599,   598,   600,   601,   601,   602,   602,
+     603,   603,   604,   604,   605,   605,   606,   606,   607,   607,
+     607,   607,   607,   607,   608,   608,   609,   609,   609,   609,
+     609,   610,   610,   611,   611,   612,   612,   612,   612,   612,
+     612,   612,   612,   613,   613,   614,   614,   614,   614,   615,
+     615,   616,   616,   616,   616,   616,   617,   617,   618,   618,
+     618,   618,   619,   619,   620,   620,   621,   621,   622,   622,
+     623,   623
 };
 
 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
@@ -4655,9 +4688,9 @@ static const yytype_int8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     4,     1,     1,
-       1,     3,     2,     3,     2,     3,     3,     4,     1,     0,
-       3,     1,     1,     3,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
+       1,     1,     1,     3,     2,     3,     2,     3,     3,     4,
+       1,     0,     3,     1,     1,     3,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
@@ -4691,7 +4724,8 @@ static const yytype_int8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     0,     6,     0,     5,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     6,
+       0,     5,     1,     1,     2,     2,     3,     0,     5,     1,
        2,     3,     4,     1,     3,     1,     2,     1,     3,     4,
        2,     1,     3,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     2,     2,     0,     0,     5,     1,
@@ -5449,260 +5483,260 @@ yyreduce:
   switch (yyn)
     {
   case 2: /* variable_identifier: IDENTIFIER  */
-#line 362 "MachineIndependent/glslang.y"
+#line 365 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
     }
-#line 5457 "MachineIndependent/glslang_tab.cpp"
+#line 5491 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 3: /* primary_expression: variable_identifier  */
-#line 368 "MachineIndependent/glslang.y"
+#line 371 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5465 "MachineIndependent/glslang_tab.cpp"
+#line 5499 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN  */
-#line 371 "MachineIndependent/glslang.y"
+#line 374 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
     }
-#line 5475 "MachineIndependent/glslang_tab.cpp"
+#line 5509 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 5: /* primary_expression: FLOATCONSTANT  */
-#line 376 "MachineIndependent/glslang.y"
+#line 379 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 5483 "MachineIndependent/glslang_tab.cpp"
+#line 5517 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 6: /* primary_expression: INTCONSTANT  */
-#line 379 "MachineIndependent/glslang.y"
-                  {
-        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
-    }
-#line 5491 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 7: /* primary_expression: UINTCONSTANT  */
 #line 382 "MachineIndependent/glslang.y"
-                   {
-        parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
-        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
-    }
-#line 5500 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 8: /* primary_expression: BOOLCONSTANT  */
-#line 386 "MachineIndependent/glslang.y"
-                   {
-        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
-    }
-#line 5508 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 9: /* primary_expression: STRING_LITERAL  */
-#line 389 "MachineIndependent/glslang.y"
-                     {
-        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
-    }
-#line 5516 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 10: /* primary_expression: INT32CONSTANT  */
-#line 392 "MachineIndependent/glslang.y"
-                    {
-        parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
+                  {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
 #line 5525 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 11: /* primary_expression: UINT32CONSTANT  */
-#line 396 "MachineIndependent/glslang.y"
-                     {
-        parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
+  case 7: /* primary_expression: UINTCONSTANT  */
+#line 385 "MachineIndependent/glslang.y"
+                   {
+        parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
 #line 5534 "MachineIndependent/glslang_tab.cpp"
     break;
 
+  case 8: /* primary_expression: BOOLCONSTANT  */
+#line 389 "MachineIndependent/glslang.y"
+                   {
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
+    }
+#line 5542 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 9: /* primary_expression: STRING_LITERAL  */
+#line 392 "MachineIndependent/glslang.y"
+                     {
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
+    }
+#line 5550 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 10: /* primary_expression: INT32CONSTANT  */
+#line 395 "MachineIndependent/glslang.y"
+                    {
+        parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
+    }
+#line 5559 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 11: /* primary_expression: UINT32CONSTANT  */
+#line 399 "MachineIndependent/glslang.y"
+                     {
+        parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
+    }
+#line 5568 "MachineIndependent/glslang_tab.cpp"
+    break;
+
   case 12: /* primary_expression: INT64CONSTANT  */
-#line 400 "MachineIndependent/glslang.y"
+#line 403 "MachineIndependent/glslang.y"
                     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
     }
-#line 5543 "MachineIndependent/glslang_tab.cpp"
+#line 5577 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 13: /* primary_expression: UINT64CONSTANT  */
-#line 404 "MachineIndependent/glslang.y"
+#line 407 "MachineIndependent/glslang.y"
                      {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
     }
-#line 5552 "MachineIndependent/glslang_tab.cpp"
+#line 5586 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 14: /* primary_expression: INT16CONSTANT  */
-#line 408 "MachineIndependent/glslang.y"
+#line 411 "MachineIndependent/glslang.y"
                     {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 5561 "MachineIndependent/glslang_tab.cpp"
+#line 5595 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 15: /* primary_expression: UINT16CONSTANT  */
-#line 412 "MachineIndependent/glslang.y"
+#line 415 "MachineIndependent/glslang.y"
                      {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 5570 "MachineIndependent/glslang_tab.cpp"
+#line 5604 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 16: /* primary_expression: DOUBLECONSTANT  */
-#line 416 "MachineIndependent/glslang.y"
+#line 419 "MachineIndependent/glslang.y"
                      {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal");
         if (! parseContext.symbolTable.atBuiltInLevel())
             parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true);
     }
-#line 5581 "MachineIndependent/glslang_tab.cpp"
+#line 5615 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 17: /* primary_expression: FLOAT16CONSTANT  */
-#line 422 "MachineIndependent/glslang.y"
+#line 425 "MachineIndependent/glslang.y"
                       {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
     }
-#line 5590 "MachineIndependent/glslang_tab.cpp"
+#line 5624 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 18: /* postfix_expression: primary_expression  */
-#line 429 "MachineIndependent/glslang.y"
+#line 432 "MachineIndependent/glslang.y"
                          {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5598 "MachineIndependent/glslang_tab.cpp"
+#line 5632 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET  */
-#line 432 "MachineIndependent/glslang.y"
+#line 435 "MachineIndependent/glslang.y"
                                                                        {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
     }
-#line 5606 "MachineIndependent/glslang_tab.cpp"
+#line 5640 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 20: /* postfix_expression: function_call  */
-#line 435 "MachineIndependent/glslang.y"
+#line 438 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5614 "MachineIndependent/glslang_tab.cpp"
+#line 5648 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER  */
-#line 438 "MachineIndependent/glslang.y"
+#line 441 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
     }
-#line 5622 "MachineIndependent/glslang_tab.cpp"
+#line 5656 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 22: /* postfix_expression: postfix_expression INC_OP  */
-#line 441 "MachineIndependent/glslang.y"
+#line 444 "MachineIndependent/glslang.y"
                                 {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 5632 "MachineIndependent/glslang_tab.cpp"
+#line 5666 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 23: /* postfix_expression: postfix_expression DEC_OP  */
-#line 446 "MachineIndependent/glslang.y"
+#line 449 "MachineIndependent/glslang.y"
                                 {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 5642 "MachineIndependent/glslang_tab.cpp"
+#line 5676 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 24: /* integer_expression: expression  */
-#line 454 "MachineIndependent/glslang.y"
+#line 457 "MachineIndependent/glslang.y"
                  {
         parseContext.arrayIndexCheck((yyvsp[0].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5651 "MachineIndependent/glslang_tab.cpp"
+#line 5685 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 25: /* function_call: function_call_or_method  */
-#line 461 "MachineIndependent/glslang.y"
+#line 464 "MachineIndependent/glslang.y"
                               {
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
         delete (yyvsp[0].interm).function;
     }
-#line 5660 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 26: /* function_call_or_method: function_call_generic  */
-#line 468 "MachineIndependent/glslang.y"
-                            {
-        (yyval.interm) = (yyvsp[0].interm);
-    }
-#line 5668 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN  */
-#line 474 "MachineIndependent/glslang.y"
-                                                       {
-        (yyval.interm) = (yyvsp[-1].interm);
-        (yyval.interm).loc = (yyvsp[0].lex).loc;
-    }
-#line 5677 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN  */
-#line 478 "MachineIndependent/glslang.y"
-                                                     {
-        (yyval.interm) = (yyvsp[-1].interm);
-        (yyval.interm).loc = (yyvsp[0].lex).loc;
-    }
-#line 5686 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 29: /* function_call_header_no_parameters: function_call_header VOID  */
-#line 485 "MachineIndependent/glslang.y"
-                                {
-        (yyval.interm) = (yyvsp[-1].interm);
-    }
 #line 5694 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 30: /* function_call_header_no_parameters: function_call_header  */
-#line 488 "MachineIndependent/glslang.y"
-                           {
+  case 26: /* function_call_or_method: function_call_generic  */
+#line 471 "MachineIndependent/glslang.y"
+                            {
         (yyval.interm) = (yyvsp[0].interm);
     }
 #line 5702 "MachineIndependent/glslang_tab.cpp"
     break;
 
+  case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN  */
+#line 477 "MachineIndependent/glslang.y"
+                                                       {
+        (yyval.interm) = (yyvsp[-1].interm);
+        (yyval.interm).loc = (yyvsp[0].lex).loc;
+    }
+#line 5711 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN  */
+#line 481 "MachineIndependent/glslang.y"
+                                                     {
+        (yyval.interm) = (yyvsp[-1].interm);
+        (yyval.interm).loc = (yyvsp[0].lex).loc;
+    }
+#line 5720 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 29: /* function_call_header_no_parameters: function_call_header VOID  */
+#line 488 "MachineIndependent/glslang.y"
+                                {
+        (yyval.interm) = (yyvsp[-1].interm);
+    }
+#line 5728 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 30: /* function_call_header_no_parameters: function_call_header  */
+#line 491 "MachineIndependent/glslang.y"
+                           {
+        (yyval.interm) = (yyvsp[0].interm);
+    }
+#line 5736 "MachineIndependent/glslang_tab.cpp"
+    break;
+
   case 31: /* function_call_header_with_parameters: function_call_header assignment_expression  */
-#line 494 "MachineIndependent/glslang.y"
+#line 497 "MachineIndependent/glslang.y"
                                                  {
         if (parseContext.spvVersion.vulkan > 0
             && parseContext.spvVersion.vulkanRelaxed
@@ -5721,11 +5755,11 @@ yyreduce:
             (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 5725 "MachineIndependent/glslang_tab.cpp"
+#line 5759 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression  */
-#line 512 "MachineIndependent/glslang.y"
+#line 515 "MachineIndependent/glslang.y"
                                                                        {
         if (parseContext.spvVersion.vulkan > 0
             && parseContext.spvVersion.vulkanRelaxed
@@ -5748,29 +5782,29 @@ yyreduce:
             (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
         }
     }
-#line 5752 "MachineIndependent/glslang_tab.cpp"
+#line 5786 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 33: /* function_call_header: function_identifier LEFT_PAREN  */
-#line 537 "MachineIndependent/glslang.y"
+#line 540 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 5760 "MachineIndependent/glslang_tab.cpp"
+#line 5794 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 34: /* function_identifier: type_specifier  */
-#line 545 "MachineIndependent/glslang.y"
+#line 548 "MachineIndependent/glslang.y"
                      {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 5770 "MachineIndependent/glslang_tab.cpp"
+#line 5804 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 35: /* function_identifier: postfix_expression  */
-#line 550 "MachineIndependent/glslang.y"
+#line 553 "MachineIndependent/glslang.y"
                          {
         //
         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
@@ -5798,50 +5832,50 @@ yyreduce:
             (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
         }
     }
-#line 5802 "MachineIndependent/glslang_tab.cpp"
+#line 5836 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 36: /* function_identifier: non_uniform_qualifier  */
-#line 577 "MachineIndependent/glslang.y"
+#line 580 "MachineIndependent/glslang.y"
                             {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 5812 "MachineIndependent/glslang_tab.cpp"
+#line 5846 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 37: /* unary_expression: postfix_expression  */
-#line 585 "MachineIndependent/glslang.y"
+#line 588 "MachineIndependent/glslang.y"
                          {
         parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
     }
-#line 5823 "MachineIndependent/glslang_tab.cpp"
+#line 5857 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 38: /* unary_expression: INC_OP unary_expression  */
-#line 591 "MachineIndependent/glslang.y"
+#line 594 "MachineIndependent/glslang.y"
                               {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 5832 "MachineIndependent/glslang_tab.cpp"
+#line 5866 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 39: /* unary_expression: DEC_OP unary_expression  */
-#line 595 "MachineIndependent/glslang.y"
+#line 598 "MachineIndependent/glslang.y"
                               {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 5841 "MachineIndependent/glslang_tab.cpp"
+#line 5875 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 40: /* unary_expression: unary_operator unary_expression  */
-#line 599 "MachineIndependent/glslang.y"
+#line 602 "MachineIndependent/glslang.y"
                                       {
         if ((yyvsp[-1].interm).op != EOpNull) {
             char errorOp[2] = {0, 0};
@@ -5858,179 +5892,179 @@ yyreduce:
                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
         }
     }
-#line 5862 "MachineIndependent/glslang_tab.cpp"
+#line 5896 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 41: /* unary_operator: PLUS  */
-#line 619 "MachineIndependent/glslang.y"
+#line 622 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
-#line 5868 "MachineIndependent/glslang_tab.cpp"
+#line 5902 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 42: /* unary_operator: DASH  */
-#line 620 "MachineIndependent/glslang.y"
+#line 623 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
-#line 5874 "MachineIndependent/glslang_tab.cpp"
+#line 5908 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 43: /* unary_operator: BANG  */
-#line 621 "MachineIndependent/glslang.y"
+#line 624 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
-#line 5880 "MachineIndependent/glslang_tab.cpp"
+#line 5914 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 44: /* unary_operator: TILDE  */
-#line 622 "MachineIndependent/glslang.y"
+#line 625 "MachineIndependent/glslang.y"
             { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
               parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
-#line 5887 "MachineIndependent/glslang_tab.cpp"
+#line 5921 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 45: /* multiplicative_expression: unary_expression  */
-#line 628 "MachineIndependent/glslang.y"
+#line 631 "MachineIndependent/glslang.y"
                        { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5893 "MachineIndependent/glslang_tab.cpp"
+#line 5927 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 46: /* multiplicative_expression: multiplicative_expression STAR unary_expression  */
-#line 629 "MachineIndependent/glslang.y"
+#line 632 "MachineIndependent/glslang.y"
                                                       {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5903 "MachineIndependent/glslang_tab.cpp"
+#line 5937 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 47: /* multiplicative_expression: multiplicative_expression SLASH unary_expression  */
-#line 634 "MachineIndependent/glslang.y"
+#line 637 "MachineIndependent/glslang.y"
                                                        {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5913 "MachineIndependent/glslang_tab.cpp"
+#line 5947 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 48: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression  */
-#line 639 "MachineIndependent/glslang.y"
+#line 642 "MachineIndependent/glslang.y"
                                                          {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5924 "MachineIndependent/glslang_tab.cpp"
+#line 5958 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 49: /* additive_expression: multiplicative_expression  */
-#line 648 "MachineIndependent/glslang.y"
+#line 651 "MachineIndependent/glslang.y"
                                 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5930 "MachineIndependent/glslang_tab.cpp"
+#line 5964 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 50: /* additive_expression: additive_expression PLUS multiplicative_expression  */
-#line 649 "MachineIndependent/glslang.y"
+#line 652 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5940 "MachineIndependent/glslang_tab.cpp"
+#line 5974 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 51: /* additive_expression: additive_expression DASH multiplicative_expression  */
-#line 654 "MachineIndependent/glslang.y"
+#line 657 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5950 "MachineIndependent/glslang_tab.cpp"
+#line 5984 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 52: /* shift_expression: additive_expression  */
-#line 662 "MachineIndependent/glslang.y"
+#line 665 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5956 "MachineIndependent/glslang_tab.cpp"
+#line 5990 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 53: /* shift_expression: shift_expression LEFT_OP additive_expression  */
-#line 663 "MachineIndependent/glslang.y"
+#line 666 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5967 "MachineIndependent/glslang_tab.cpp"
+#line 6001 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 54: /* shift_expression: shift_expression RIGHT_OP additive_expression  */
-#line 669 "MachineIndependent/glslang.y"
+#line 672 "MachineIndependent/glslang.y"
                                                     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 5978 "MachineIndependent/glslang_tab.cpp"
+#line 6012 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 55: /* relational_expression: shift_expression  */
-#line 678 "MachineIndependent/glslang.y"
+#line 681 "MachineIndependent/glslang.y"
                        { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 5984 "MachineIndependent/glslang_tab.cpp"
+#line 6018 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 56: /* relational_expression: relational_expression LEFT_ANGLE shift_expression  */
-#line 679 "MachineIndependent/glslang.y"
+#line 682 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 5994 "MachineIndependent/glslang_tab.cpp"
+#line 6028 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 57: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression  */
-#line 684 "MachineIndependent/glslang.y"
+#line 687 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6004 "MachineIndependent/glslang_tab.cpp"
+#line 6038 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 58: /* relational_expression: relational_expression LE_OP shift_expression  */
-#line 689 "MachineIndependent/glslang.y"
+#line 692 "MachineIndependent/glslang.y"
                                                     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6014 "MachineIndependent/glslang_tab.cpp"
+#line 6048 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 59: /* relational_expression: relational_expression GE_OP shift_expression  */
-#line 694 "MachineIndependent/glslang.y"
+#line 697 "MachineIndependent/glslang.y"
                                                     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6024 "MachineIndependent/glslang_tab.cpp"
+#line 6058 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 60: /* equality_expression: relational_expression  */
-#line 702 "MachineIndependent/glslang.y"
+#line 705 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6030 "MachineIndependent/glslang_tab.cpp"
+#line 6064 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 61: /* equality_expression: equality_expression EQ_OP relational_expression  */
-#line 703 "MachineIndependent/glslang.y"
+#line 706 "MachineIndependent/glslang.y"
                                                        {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
@@ -6040,11 +6074,11 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6044 "MachineIndependent/glslang_tab.cpp"
+#line 6078 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 62: /* equality_expression: equality_expression NE_OP relational_expression  */
-#line 712 "MachineIndependent/glslang.y"
+#line 715 "MachineIndependent/glslang.y"
                                                       {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
@@ -6054,124 +6088,124 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6058 "MachineIndependent/glslang_tab.cpp"
+#line 6092 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 63: /* and_expression: equality_expression  */
-#line 724 "MachineIndependent/glslang.y"
+#line 727 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6064 "MachineIndependent/glslang_tab.cpp"
+#line 6098 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 64: /* and_expression: and_expression AMPERSAND equality_expression  */
-#line 725 "MachineIndependent/glslang.y"
+#line 728 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 6075 "MachineIndependent/glslang_tab.cpp"
+#line 6109 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 65: /* exclusive_or_expression: and_expression  */
-#line 734 "MachineIndependent/glslang.y"
+#line 737 "MachineIndependent/glslang.y"
                      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6081 "MachineIndependent/glslang_tab.cpp"
+#line 6115 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 66: /* exclusive_or_expression: exclusive_or_expression CARET and_expression  */
-#line 735 "MachineIndependent/glslang.y"
+#line 738 "MachineIndependent/glslang.y"
                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 6092 "MachineIndependent/glslang_tab.cpp"
+#line 6126 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 67: /* inclusive_or_expression: exclusive_or_expression  */
-#line 744 "MachineIndependent/glslang.y"
+#line 747 "MachineIndependent/glslang.y"
                               { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6098 "MachineIndependent/glslang_tab.cpp"
+#line 6132 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 68: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression  */
-#line 745 "MachineIndependent/glslang.y"
+#line 748 "MachineIndependent/glslang.y"
                                                                    {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 6109 "MachineIndependent/glslang_tab.cpp"
+#line 6143 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 69: /* logical_and_expression: inclusive_or_expression  */
-#line 754 "MachineIndependent/glslang.y"
+#line 757 "MachineIndependent/glslang.y"
                               { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6115 "MachineIndependent/glslang_tab.cpp"
+#line 6149 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 70: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression  */
-#line 755 "MachineIndependent/glslang.y"
+#line 758 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6125 "MachineIndependent/glslang_tab.cpp"
+#line 6159 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 71: /* logical_xor_expression: logical_and_expression  */
-#line 763 "MachineIndependent/glslang.y"
+#line 766 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6131 "MachineIndependent/glslang_tab.cpp"
+#line 6165 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 72: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression  */
-#line 764 "MachineIndependent/glslang.y"
+#line 767 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6141 "MachineIndependent/glslang_tab.cpp"
+#line 6175 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 73: /* logical_or_expression: logical_xor_expression  */
-#line 772 "MachineIndependent/glslang.y"
+#line 775 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6147 "MachineIndependent/glslang_tab.cpp"
+#line 6181 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 74: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression  */
-#line 773 "MachineIndependent/glslang.y"
+#line 776 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 6157 "MachineIndependent/glslang_tab.cpp"
+#line 6191 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 75: /* conditional_expression: logical_or_expression  */
-#line 781 "MachineIndependent/glslang.y"
+#line 784 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6163 "MachineIndependent/glslang_tab.cpp"
+#line 6197 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 76: /* $@1: %empty  */
-#line 782 "MachineIndependent/glslang.y"
+#line 785 "MachineIndependent/glslang.y"
                                      {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 6171 "MachineIndependent/glslang_tab.cpp"
+#line 6205 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 77: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression  */
-#line 785 "MachineIndependent/glslang.y"
+#line 788 "MachineIndependent/glslang.y"
                                              {
         --parseContext.controlFlowNestingLevel;
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
@@ -6184,17 +6218,17 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 6188 "MachineIndependent/glslang_tab.cpp"
+#line 6222 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 78: /* assignment_expression: conditional_expression  */
-#line 800 "MachineIndependent/glslang.y"
+#line 803 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 6194 "MachineIndependent/glslang_tab.cpp"
+#line 6228 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 79: /* assignment_expression: unary_expression assignment_operator assignment_expression  */
-#line 801 "MachineIndependent/glslang.y"
+#line 804 "MachineIndependent/glslang.y"
                                                                  {
         parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
         parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
@@ -6208,119 +6242,119 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
         }
     }
-#line 6212 "MachineIndependent/glslang_tab.cpp"
+#line 6246 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 80: /* assignment_operator: EQUAL  */
-#line 817 "MachineIndependent/glslang.y"
+#line 820 "MachineIndependent/glslang.y"
             {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
-#line 6221 "MachineIndependent/glslang_tab.cpp"
+#line 6255 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 81: /* assignment_operator: MUL_ASSIGN  */
-#line 821 "MachineIndependent/glslang.y"
+#line 824 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
-#line 6230 "MachineIndependent/glslang_tab.cpp"
+#line 6264 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 82: /* assignment_operator: DIV_ASSIGN  */
-#line 825 "MachineIndependent/glslang.y"
+#line 828 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
-#line 6239 "MachineIndependent/glslang_tab.cpp"
+#line 6273 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 83: /* assignment_operator: MOD_ASSIGN  */
-#line 829 "MachineIndependent/glslang.y"
+#line 832 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpModAssign;
     }
-#line 6249 "MachineIndependent/glslang_tab.cpp"
+#line 6283 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 84: /* assignment_operator: ADD_ASSIGN  */
-#line 834 "MachineIndependent/glslang.y"
+#line 837 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
-#line 6258 "MachineIndependent/glslang_tab.cpp"
+#line 6292 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 85: /* assignment_operator: SUB_ASSIGN  */
-#line 838 "MachineIndependent/glslang.y"
+#line 841 "MachineIndependent/glslang.y"
                  {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
-#line 6267 "MachineIndependent/glslang_tab.cpp"
+#line 6301 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 86: /* assignment_operator: LEFT_ASSIGN  */
-#line 842 "MachineIndependent/glslang.y"
+#line 845 "MachineIndependent/glslang.y"
                   {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
-#line 6276 "MachineIndependent/glslang_tab.cpp"
+#line 6310 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 87: /* assignment_operator: RIGHT_ASSIGN  */
-#line 846 "MachineIndependent/glslang.y"
+#line 849 "MachineIndependent/glslang.y"
                    {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
-#line 6285 "MachineIndependent/glslang_tab.cpp"
+#line 6319 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 88: /* assignment_operator: AND_ASSIGN  */
-#line 850 "MachineIndependent/glslang.y"
+#line 853 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
-#line 6294 "MachineIndependent/glslang_tab.cpp"
+#line 6328 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 89: /* assignment_operator: XOR_ASSIGN  */
-#line 854 "MachineIndependent/glslang.y"
+#line 857 "MachineIndependent/glslang.y"
                  {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
-#line 6303 "MachineIndependent/glslang_tab.cpp"
+#line 6337 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 90: /* assignment_operator: OR_ASSIGN  */
-#line 858 "MachineIndependent/glslang.y"
+#line 861 "MachineIndependent/glslang.y"
                 {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
-#line 6312 "MachineIndependent/glslang_tab.cpp"
+#line 6346 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 91: /* expression: assignment_expression  */
-#line 865 "MachineIndependent/glslang.y"
+#line 868 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 6320 "MachineIndependent/glslang_tab.cpp"
+#line 6354 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 92: /* expression: expression COMMA assignment_expression  */
-#line 868 "MachineIndependent/glslang.y"
+#line 871 "MachineIndependent/glslang.y"
                                              {
         parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
@@ -6329,30 +6363,30 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 6333 "MachineIndependent/glslang_tab.cpp"
+#line 6367 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 93: /* constant_expression: conditional_expression  */
-#line 879 "MachineIndependent/glslang.y"
+#line 882 "MachineIndependent/glslang.y"
                              {
         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 6342 "MachineIndependent/glslang_tab.cpp"
+#line 6376 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 94: /* declaration: function_prototype SEMICOLON  */
-#line 886 "MachineIndependent/glslang.y"
+#line 889 "MachineIndependent/glslang.y"
                                    {
         parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
         (yyval.interm.intermNode) = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
-#line 6352 "MachineIndependent/glslang_tab.cpp"
+#line 6386 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 95: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON  */
-#line 891 "MachineIndependent/glslang.y"
+#line 894 "MachineIndependent/glslang.y"
                                                                {
         parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier");
         (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier
@@ -6360,31 +6394,31 @@ yyreduce:
         (yyval.interm.intermNode) = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
-#line 6364 "MachineIndependent/glslang_tab.cpp"
+#line 6398 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 96: /* declaration: spirv_execution_mode_qualifier SEMICOLON  */
-#line 898 "MachineIndependent/glslang.y"
+#line 901 "MachineIndependent/glslang.y"
                                                {
         parseContext.globalCheck((yyvsp[0].lex).loc, "SPIR-V execution mode qualifier");
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier");
         (yyval.interm.intermNode) = 0;
     }
-#line 6374 "MachineIndependent/glslang_tab.cpp"
+#line 6408 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 97: /* declaration: init_declarator_list SEMICOLON  */
-#line 903 "MachineIndependent/glslang.y"
+#line 906 "MachineIndependent/glslang.y"
                                      {
         if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
             (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
     }
-#line 6384 "MachineIndependent/glslang_tab.cpp"
+#line 6418 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 98: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON  */
-#line 908 "MachineIndependent/glslang.y"
+#line 911 "MachineIndependent/glslang.y"
                                                              {
         parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
         // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope
@@ -6392,62 +6426,62 @@ yyreduce:
         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
         (yyval.interm.intermNode) = 0;
     }
-#line 6396 "MachineIndependent/glslang_tab.cpp"
+#line 6430 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 99: /* declaration: block_structure SEMICOLON  */
-#line 915 "MachineIndependent/glslang.y"
+#line 918 "MachineIndependent/glslang.y"
                                 {
         (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
     }
-#line 6404 "MachineIndependent/glslang_tab.cpp"
+#line 6438 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 100: /* declaration: block_structure IDENTIFIER SEMICOLON  */
-#line 918 "MachineIndependent/glslang.y"
+#line 921 "MachineIndependent/glslang.y"
                                            {
         (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
     }
-#line 6412 "MachineIndependent/glslang_tab.cpp"
+#line 6446 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 101: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON  */
-#line 921 "MachineIndependent/glslang.y"
+#line 924 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
     }
-#line 6420 "MachineIndependent/glslang_tab.cpp"
+#line 6454 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 102: /* declaration: type_qualifier SEMICOLON  */
-#line 924 "MachineIndependent/glslang.y"
+#line 927 "MachineIndependent/glslang.y"
                                {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
         parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
         (yyval.interm.intermNode) = 0;
     }
-#line 6430 "MachineIndependent/glslang_tab.cpp"
+#line 6464 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 103: /* declaration: type_qualifier identifier_list SEMICOLON  */
-#line 929 "MachineIndependent/glslang.y"
+#line 932 "MachineIndependent/glslang.y"
                                                {
         parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
         parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
         (yyval.interm.intermNode) = 0;
     }
-#line 6440 "MachineIndependent/glslang_tab.cpp"
+#line 6474 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 104: /* $@2: %empty  */
-#line 937 "MachineIndependent/glslang.y"
+#line 940 "MachineIndependent/glslang.y"
                                            { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
-#line 6446 "MachineIndependent/glslang_tab.cpp"
+#line 6480 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 105: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE  */
-#line 937 "MachineIndependent/glslang.y"
-                                                                                                                          {
+  case 105: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_without_heap RIGHT_BRACE  */
+#line 940 "MachineIndependent/glslang.y"
+                                                                                                                                  {
         --parseContext.blockNestingLevel;
         parseContext.blockName = (yyvsp[-4].lex).string;
         parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier);
@@ -6456,39 +6490,39 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
     }
-#line 6460 "MachineIndependent/glslang_tab.cpp"
+#line 6494 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 106: /* identifier_list: IDENTIFIER  */
-#line 948 "MachineIndependent/glslang.y"
+#line 952 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 6469 "MachineIndependent/glslang_tab.cpp"
+#line 6503 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 107: /* identifier_list: identifier_list COMMA IDENTIFIER  */
-#line 952 "MachineIndependent/glslang.y"
+#line 956 "MachineIndependent/glslang.y"
                                        {
         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 6478 "MachineIndependent/glslang_tab.cpp"
+#line 6512 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 108: /* function_prototype: function_declarator RIGHT_PAREN  */
-#line 959 "MachineIndependent/glslang.y"
+#line 963 "MachineIndependent/glslang.y"
                                        {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         if (parseContext.compileOnly) (yyval.interm).function->setExport();
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 6488 "MachineIndependent/glslang_tab.cpp"
+#line 6522 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 109: /* function_prototype: function_declarator RIGHT_PAREN attribute  */
-#line 964 "MachineIndependent/glslang.y"
+#line 968 "MachineIndependent/glslang.y"
                                                 {
         (yyval.interm).function = (yyvsp[-2].interm.function);
         if (parseContext.compileOnly) (yyval.interm).function->setExport();
@@ -6497,11 +6531,11 @@ yyreduce:
         parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute");
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes));
     }
-#line 6501 "MachineIndependent/glslang_tab.cpp"
+#line 6535 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 110: /* function_prototype: attribute function_declarator RIGHT_PAREN  */
-#line 972 "MachineIndependent/glslang.y"
+#line 976 "MachineIndependent/glslang.y"
                                                 {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         if (parseContext.compileOnly) (yyval.interm).function->setExport();
@@ -6510,11 +6544,11 @@ yyreduce:
         parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute");
         parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes));
     }
-#line 6514 "MachineIndependent/glslang_tab.cpp"
+#line 6548 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute  */
-#line 980 "MachineIndependent/glslang.y"
+#line 984 "MachineIndependent/glslang.y"
                                                           {
         (yyval.interm).function = (yyvsp[-2].interm.function);
         if (parseContext.compileOnly) (yyval.interm).function->setExport();
@@ -6524,27 +6558,27 @@ yyreduce:
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes));
         parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes));
     }
-#line 6528 "MachineIndependent/glslang_tab.cpp"
+#line 6562 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 112: /* function_declarator: function_header  */
-#line 992 "MachineIndependent/glslang.y"
+#line 996 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 6536 "MachineIndependent/glslang_tab.cpp"
+#line 6570 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 113: /* function_declarator: function_header_with_parameters  */
-#line 995 "MachineIndependent/glslang.y"
+#line 999 "MachineIndependent/glslang.y"
                                       {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 6544 "MachineIndependent/glslang_tab.cpp"
+#line 6578 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 114: /* function_header_with_parameters: function_header parameter_declaration  */
-#line 1002 "MachineIndependent/glslang.y"
+#line 1006 "MachineIndependent/glslang.y"
                                             {
         // Add the parameter
         (yyval.interm.function) = (yyvsp[-1].interm.function);
@@ -6558,11 +6592,11 @@ yyreduce:
         else
             delete (yyvsp[0].interm).param.type;
     }
-#line 6562 "MachineIndependent/glslang_tab.cpp"
+#line 6596 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 115: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration  */
-#line 1015 "MachineIndependent/glslang.y"
+#line 1019 "MachineIndependent/glslang.y"
                                                                   {
         //
         // Only first parameter of one-parameter functions can be void
@@ -6583,20 +6617,20 @@ yyreduce:
                 parseContext.vkRelaxedRemapFunctionParameter((yyvsp[-2].interm.function), (yyvsp[0].interm).param);
         }
     }
-#line 6587 "MachineIndependent/glslang_tab.cpp"
+#line 6621 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 116: /* function_header_with_parameters: function_header_with_parameters COMMA DOT DOT DOT  */
-#line 1035 "MachineIndependent/glslang.y"
+#line 1039 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm.function) = (yyvsp[-4].interm.function);
         parseContext.makeVariadic((yyvsp[-4].interm.function), (yyvsp[-2].lex).loc);
     }
-#line 6596 "MachineIndependent/glslang_tab.cpp"
+#line 6630 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 117: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN  */
-#line 1042 "MachineIndependent/glslang.y"
+#line 1046 "MachineIndependent/glslang.y"
                                                  {
         if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
             parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
@@ -6616,11 +6650,11 @@ yyreduce:
         function = new TFunction((yyvsp[-1].lex).string, type);
         (yyval.interm.function) = function;
     }
-#line 6620 "MachineIndependent/glslang_tab.cpp"
+#line 6654 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 118: /* parameter_declarator: type_specifier IDENTIFIER  */
-#line 1065 "MachineIndependent/glslang.y"
+#line 1069 "MachineIndependent/glslang.y"
                                 {
         if ((yyvsp[-1].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -6636,11 +6670,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).param = param;
     }
-#line 6640 "MachineIndependent/glslang_tab.cpp"
+#line 6674 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 119: /* parameter_declarator: type_specifier IDENTIFIER array_specifier  */
-#line 1080 "MachineIndependent/glslang.y"
+#line 1084 "MachineIndependent/glslang.y"
                                                 {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -6660,21 +6694,21 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).param = param;
     }
-#line 6664 "MachineIndependent/glslang_tab.cpp"
+#line 6698 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 120: /* parameter_declarator: type_specifier IDENTIFIER EQUAL initializer  */
-#line 1099 "MachineIndependent/glslang.y"
+#line 1103 "MachineIndependent/glslang.y"
                                                   {
         TParameter param = parseContext.getParamWithDefault((yyvsp[-3].interm.type), (yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
         (yyval.interm).loc = (yyvsp[-2].lex).loc;
         (yyval.interm).param = param;
     }
-#line 6674 "MachineIndependent/glslang_tab.cpp"
+#line 6708 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 121: /* parameter_declaration: type_qualifier parameter_declarator  */
-#line 1110 "MachineIndependent/glslang.y"
+#line 1114 "MachineIndependent/glslang.y"
                                           {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -6686,11 +6720,11 @@ yyreduce:
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
 
     }
-#line 6690 "MachineIndependent/glslang_tab.cpp"
+#line 6724 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 122: /* parameter_declaration: parameter_declarator  */
-#line 1121 "MachineIndependent/glslang.y"
+#line 1125 "MachineIndependent/glslang.y"
                            {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -6698,11 +6732,11 @@ yyreduce:
         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter());
     }
-#line 6702 "MachineIndependent/glslang_tab.cpp"
+#line 6736 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 123: /* parameter_declaration: type_qualifier parameter_type_specifier  */
-#line 1131 "MachineIndependent/glslang.y"
+#line 1135 "MachineIndependent/glslang.y"
                                               {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -6713,11 +6747,11 @@ yyreduce:
         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
     }
-#line 6717 "MachineIndependent/glslang_tab.cpp"
+#line 6751 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 124: /* parameter_declaration: parameter_type_specifier  */
-#line 1141 "MachineIndependent/glslang.y"
+#line 1145 "MachineIndependent/glslang.y"
                                {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -6725,121 +6759,121 @@ 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(), (yyval.interm).param.type->hasTypeParameter());
     }
-#line 6729 "MachineIndependent/glslang_tab.cpp"
+#line 6763 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 125: /* parameter_type_specifier: type_specifier  */
-#line 1151 "MachineIndependent/glslang.y"
+#line 1155 "MachineIndependent/glslang.y"
                      {
         TParameter param = { 0, new TType((yyvsp[0].interm.type)), {} };
         (yyval.interm).param = param;
         if ((yyvsp[0].interm.type).arraySizes)
             parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
     }
-#line 6740 "MachineIndependent/glslang_tab.cpp"
+#line 6774 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 126: /* init_declarator_list: single_declaration  */
-#line 1160 "MachineIndependent/glslang.y"
+#line 1164 "MachineIndependent/glslang.y"
                          {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 6748 "MachineIndependent/glslang_tab.cpp"
+#line 6782 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER  */
-#line 1163 "MachineIndependent/glslang.y"
+#line 1167 "MachineIndependent/glslang.y"
                                             {
         (yyval.interm) = (yyvsp[-2].interm);
         TIntermNode* declNode = parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, declNode, (yyvsp[0].lex).loc);
     }
-#line 6758 "MachineIndependent/glslang_tab.cpp"
+#line 6792 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier  */
-#line 1168 "MachineIndependent/glslang.y"
+#line 1172 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm) = (yyvsp[-3].interm);
         TIntermNode* declNode = parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-3].interm).intermNode, declNode, (yyvsp[-1].lex).loc);
     }
-#line 6768 "MachineIndependent/glslang_tab.cpp"
+#line 6802 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer  */
-#line 1173 "MachineIndependent/glslang.y"
+#line 1177 "MachineIndependent/glslang.y"
                                                                               {
         (yyval.interm).type = (yyvsp[-5].interm).type;
         TIntermNode* declNode = 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, declNode, (yyvsp[-1].lex).loc);
     }
-#line 6778 "MachineIndependent/glslang_tab.cpp"
+#line 6812 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 130: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer  */
-#line 1178 "MachineIndependent/glslang.y"
+#line 1182 "MachineIndependent/glslang.y"
                                                               {
         (yyval.interm).type = (yyvsp[-4].interm).type;
         TIntermNode* declNode = 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, declNode, (yyvsp[-1].lex).loc);
     }
-#line 6788 "MachineIndependent/glslang_tab.cpp"
+#line 6822 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 131: /* single_declaration: fully_specified_type  */
-#line 1186 "MachineIndependent/glslang.y"
+#line 1190 "MachineIndependent/glslang.y"
                            {
         (yyval.interm).type = (yyvsp[0].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
     }
-#line 6798 "MachineIndependent/glslang_tab.cpp"
+#line 6832 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 132: /* single_declaration: fully_specified_type IDENTIFIER  */
-#line 1191 "MachineIndependent/glslang.y"
+#line 1195 "MachineIndependent/glslang.y"
                                       {
         (yyval.interm).type = (yyvsp[-1].interm.type);
         TIntermNode* declNode = parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[0].lex).loc);
 
     }
-#line 6809 "MachineIndependent/glslang_tab.cpp"
+#line 6843 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier  */
-#line 1197 "MachineIndependent/glslang.y"
+#line 1201 "MachineIndependent/glslang.y"
                                                       {
         (yyval.interm).type = (yyvsp[-2].interm.type);
         TIntermNode* declNode = parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[-1].lex).loc);
     }
-#line 6819 "MachineIndependent/glslang_tab.cpp"
+#line 6853 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 134: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer  */
-#line 1202 "MachineIndependent/glslang.y"
+#line 1206 "MachineIndependent/glslang.y"
                                                                         {
         (yyval.interm).type = (yyvsp[-4].interm.type);
         TIntermNode* declNode = 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(nullptr, declNode, (yyvsp[-3].lex).loc);
     }
-#line 6829 "MachineIndependent/glslang_tab.cpp"
+#line 6863 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 135: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer  */
-#line 1207 "MachineIndependent/glslang.y"
+#line 1211 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm).type = (yyvsp[-3].interm.type);
         TIntermNode* declNode = 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(nullptr, declNode, (yyvsp[-2].lex).loc);
     }
-#line 6839 "MachineIndependent/glslang_tab.cpp"
+#line 6873 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 136: /* fully_specified_type: type_specifier  */
-#line 1216 "MachineIndependent/glslang.y"
+#line 1220 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type) = (yyvsp[0].interm.type);
 
@@ -6850,11 +6884,11 @@ yyreduce:
         }
         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).hasTypeParameter());
     }
-#line 6854 "MachineIndependent/glslang_tab.cpp"
+#line 6888 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 137: /* fully_specified_type: type_qualifier type_specifier  */
-#line 1226 "MachineIndependent/glslang.y"
+#line 1230 "MachineIndependent/glslang.y"
                                      {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, false, &(yyvsp[0].interm.type));
         parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
@@ -6879,22 +6913,22 @@ yyreduce:
              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
             (yyval.interm.type).qualifier.smooth = true;
     }
-#line 6883 "MachineIndependent/glslang_tab.cpp"
+#line 6917 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 138: /* invariant_qualifier: INVARIANT  */
-#line 1253 "MachineIndependent/glslang.y"
+#line 1257 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
         parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.invariant = true;
     }
-#line 6894 "MachineIndependent/glslang_tab.cpp"
+#line 6928 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 139: /* interpolation_qualifier: SMOOTH  */
-#line 1262 "MachineIndependent/glslang.y"
+#line 1266 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
@@ -6902,11 +6936,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.smooth = true;
     }
-#line 6906 "MachineIndependent/glslang_tab.cpp"
+#line 6940 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 140: /* interpolation_qualifier: FLAT  */
-#line 1269 "MachineIndependent/glslang.y"
+#line 1273 "MachineIndependent/glslang.y"
            {
         parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
@@ -6914,11 +6948,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.flat = true;
     }
-#line 6918 "MachineIndependent/glslang_tab.cpp"
+#line 6952 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 141: /* interpolation_qualifier: NOPERSPECTIVE  */
-#line 1276 "MachineIndependent/glslang.y"
+#line 1280 "MachineIndependent/glslang.y"
                     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
@@ -6926,11 +6960,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nopersp = true;
     }
-#line 6930 "MachineIndependent/glslang_tab.cpp"
+#line 6964 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 142: /* interpolation_qualifier: EXPLICITINTERPAMD  */
-#line 1283 "MachineIndependent/glslang.y"
+#line 1287 "MachineIndependent/glslang.y"
                         {
         parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
@@ -6938,11 +6972,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.explicitInterp = true;
     }
-#line 6942 "MachineIndependent/glslang_tab.cpp"
+#line 6976 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 143: /* interpolation_qualifier: PERVERTEXNV  */
-#line 1290 "MachineIndependent/glslang.y"
+#line 1294 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
@@ -6951,11 +6985,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.pervertexNV = true;
     }
-#line 6955 "MachineIndependent/glslang_tab.cpp"
+#line 6989 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 144: /* interpolation_qualifier: PERVERTEXEXT  */
-#line 1298 "MachineIndependent/glslang.y"
+#line 1302 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexEXT");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_EXT_fragment_shader_barycentric, "fragment shader barycentric");
@@ -6964,11 +6998,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.pervertexEXT = true;
     }
-#line 6968 "MachineIndependent/glslang_tab.cpp"
+#line 7002 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 145: /* interpolation_qualifier: PERPRIMITIVENV  */
-#line 1306 "MachineIndependent/glslang.y"
+#line 1310 "MachineIndependent/glslang.y"
                      {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
@@ -6979,11 +7013,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perPrimitiveNV = true;
     }
-#line 6983 "MachineIndependent/glslang_tab.cpp"
+#line 7017 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 146: /* interpolation_qualifier: PERPRIMITIVEEXT  */
-#line 1316 "MachineIndependent/glslang.y"
+#line 1320 "MachineIndependent/glslang.y"
                       {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveEXT");
@@ -6994,11 +7028,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perPrimitiveNV = true;
     }
-#line 6998 "MachineIndependent/glslang_tab.cpp"
+#line 7032 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 147: /* interpolation_qualifier: PERVIEWNV  */
-#line 1326 "MachineIndependent/glslang.y"
+#line 1330 "MachineIndependent/glslang.y"
                 {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
@@ -7006,11 +7040,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perViewNV = true;
     }
-#line 7010 "MachineIndependent/glslang_tab.cpp"
+#line 7044 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 148: /* interpolation_qualifier: PERTASKNV  */
-#line 1333 "MachineIndependent/glslang.y"
+#line 1337 "MachineIndependent/glslang.y"
                 {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
@@ -7018,84 +7052,84 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perTaskNV = true;
     }
-#line 7022 "MachineIndependent/glslang_tab.cpp"
+#line 7056 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 149: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN  */
-#line 1343 "MachineIndependent/glslang.y"
+#line 1347 "MachineIndependent/glslang.y"
                                                              {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
     }
-#line 7030 "MachineIndependent/glslang_tab.cpp"
+#line 7064 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 150: /* layout_qualifier_id_list: layout_qualifier_id  */
-#line 1349 "MachineIndependent/glslang.y"
+#line 1353 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7038 "MachineIndependent/glslang_tab.cpp"
+#line 7072 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 151: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id  */
-#line 1352 "MachineIndependent/glslang.y"
+#line 1356 "MachineIndependent/glslang.y"
                                                          {
         (yyval.interm.type) = (yyvsp[-2].interm.type);
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 7048 "MachineIndependent/glslang_tab.cpp"
+#line 7082 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 152: /* layout_qualifier_id: IDENTIFIER  */
-#line 1359 "MachineIndependent/glslang.y"
+#line 1363 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
     }
-#line 7057 "MachineIndependent/glslang_tab.cpp"
+#line 7091 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 153: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression  */
-#line 1363 "MachineIndependent/glslang.y"
+#line 1367 "MachineIndependent/glslang.y"
                                            {
         (yyval.interm.type).init((yyvsp[-2].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
     }
-#line 7066 "MachineIndependent/glslang_tab.cpp"
+#line 7100 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 154: /* layout_qualifier_id: SHARED  */
-#line 1367 "MachineIndependent/glslang.y"
+#line 1371 "MachineIndependent/glslang.y"
              { // because "shared" is both an identifier and a keyword
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         TString strShared("shared");
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
     }
-#line 7076 "MachineIndependent/glslang_tab.cpp"
+#line 7110 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 155: /* precise_qualifier: PRECISE  */
-#line 1375 "MachineIndependent/glslang.y"
+#line 1379 "MachineIndependent/glslang.y"
               {
         parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.noContraction = true;
     }
-#line 7087 "MachineIndependent/glslang_tab.cpp"
+#line 7121 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 156: /* type_qualifier: single_type_qualifier  */
-#line 1384 "MachineIndependent/glslang.y"
+#line 1388 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7095 "MachineIndependent/glslang_tab.cpp"
+#line 7129 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 157: /* type_qualifier: type_qualifier single_type_qualifier  */
-#line 1387 "MachineIndependent/glslang.y"
+#line 1391 "MachineIndependent/glslang.y"
                                            {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         if ((yyval.interm.type).basicType == EbtVoid)
@@ -7104,151 +7138,151 @@ yyreduce:
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 7108 "MachineIndependent/glslang_tab.cpp"
+#line 7142 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 158: /* single_type_qualifier: storage_qualifier  */
-#line 1398 "MachineIndependent/glslang.y"
+#line 1402 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7116 "MachineIndependent/glslang_tab.cpp"
+#line 7150 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 159: /* single_type_qualifier: layout_qualifier  */
-#line 1401 "MachineIndependent/glslang.y"
+#line 1405 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7124 "MachineIndependent/glslang_tab.cpp"
+#line 7158 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 160: /* single_type_qualifier: precision_qualifier  */
-#line 1404 "MachineIndependent/glslang.y"
+#line 1408 "MachineIndependent/glslang.y"
                           {
         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7133 "MachineIndependent/glslang_tab.cpp"
+#line 7167 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 161: /* single_type_qualifier: interpolation_qualifier  */
-#line 1408 "MachineIndependent/glslang.y"
+#line 1412 "MachineIndependent/glslang.y"
                               {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7142 "MachineIndependent/glslang_tab.cpp"
+#line 7176 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 162: /* single_type_qualifier: invariant_qualifier  */
-#line 1412 "MachineIndependent/glslang.y"
+#line 1416 "MachineIndependent/glslang.y"
                           {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7151 "MachineIndependent/glslang_tab.cpp"
+#line 7185 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 163: /* single_type_qualifier: precise_qualifier  */
-#line 1416 "MachineIndependent/glslang.y"
+#line 1420 "MachineIndependent/glslang.y"
                         {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7160 "MachineIndependent/glslang_tab.cpp"
+#line 7194 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 164: /* single_type_qualifier: non_uniform_qualifier  */
-#line 1420 "MachineIndependent/glslang.y"
+#line 1424 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7168 "MachineIndependent/glslang_tab.cpp"
+#line 7202 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 165: /* single_type_qualifier: spirv_storage_class_qualifier  */
-#line 1423 "MachineIndependent/glslang.y"
+#line 1427 "MachineIndependent/glslang.y"
                                     {
         parseContext.globalCheck((yyvsp[0].interm.type).loc, "spirv_storage_class");
         parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier");
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7178 "MachineIndependent/glslang_tab.cpp"
+#line 7212 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 166: /* single_type_qualifier: spirv_decorate_qualifier  */
-#line 1428 "MachineIndependent/glslang.y"
+#line 1432 "MachineIndependent/glslang.y"
                                {
         parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier");
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 7187 "MachineIndependent/glslang_tab.cpp"
+#line 7221 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 167: /* single_type_qualifier: SPIRV_BY_REFERENCE  */
-#line 1432 "MachineIndependent/glslang.y"
+#line 1436 "MachineIndependent/glslang.y"
                          {
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.setSpirvByReference();
     }
-#line 7197 "MachineIndependent/glslang_tab.cpp"
+#line 7231 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 168: /* single_type_qualifier: SPIRV_LITERAL  */
-#line 1437 "MachineIndependent/glslang.y"
+#line 1441 "MachineIndependent/glslang.y"
                     {
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.setSpirvLiteral();
     }
-#line 7207 "MachineIndependent/glslang_tab.cpp"
+#line 7241 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 169: /* storage_qualifier: CONST  */
-#line 1445 "MachineIndependent/glslang.y"
+#line 1449 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
     }
-#line 7216 "MachineIndependent/glslang_tab.cpp"
+#line 7250 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 170: /* storage_qualifier: INOUT  */
-#line 1449 "MachineIndependent/glslang.y"
+#line 1453 "MachineIndependent/glslang.y"
             {
         parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqInOut;
     }
-#line 7226 "MachineIndependent/glslang_tab.cpp"
+#line 7260 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 171: /* storage_qualifier: IN  */
-#line 1454 "MachineIndependent/glslang.y"
+#line 1458 "MachineIndependent/glslang.y"
          {
         parseContext.globalCheck((yyvsp[0].lex).loc, "in");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqIn;
     }
-#line 7237 "MachineIndependent/glslang_tab.cpp"
+#line 7271 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 172: /* storage_qualifier: OUT  */
-#line 1460 "MachineIndependent/glslang.y"
+#line 1464 "MachineIndependent/glslang.y"
           {
         parseContext.globalCheck((yyvsp[0].lex).loc, "out");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqOut;
     }
-#line 7248 "MachineIndependent/glslang_tab.cpp"
+#line 7282 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 173: /* storage_qualifier: CENTROID  */
-#line 1466 "MachineIndependent/glslang.y"
+#line 1470 "MachineIndependent/glslang.y"
                {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
@@ -7256,31 +7290,31 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.centroid = true;
     }
-#line 7260 "MachineIndependent/glslang_tab.cpp"
+#line 7294 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 174: /* storage_qualifier: UNIFORM  */
-#line 1473 "MachineIndependent/glslang.y"
+#line 1477 "MachineIndependent/glslang.y"
               {
         parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqUniform;
     }
-#line 7270 "MachineIndependent/glslang_tab.cpp"
+#line 7304 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 175: /* storage_qualifier: TILEIMAGEEXT  */
-#line 1478 "MachineIndependent/glslang.y"
+#line 1482 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "tileImageEXT");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqTileImageEXT;
     }
-#line 7280 "MachineIndependent/glslang_tab.cpp"
+#line 7314 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 176: /* storage_qualifier: SHARED  */
-#line 1483 "MachineIndependent/glslang.y"
+#line 1487 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
@@ -7289,21 +7323,21 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqShared;
     }
-#line 7293 "MachineIndependent/glslang_tab.cpp"
+#line 7327 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 177: /* storage_qualifier: BUFFER  */
-#line 1491 "MachineIndependent/glslang.y"
+#line 1495 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqBuffer;
     }
-#line 7303 "MachineIndependent/glslang_tab.cpp"
+#line 7337 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 178: /* storage_qualifier: ATTRIBUTE  */
-#line 1496 "MachineIndependent/glslang.y"
+#line 1500 "MachineIndependent/glslang.y"
                 {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
@@ -7316,11 +7350,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 7320 "MachineIndependent/glslang_tab.cpp"
+#line 7354 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 179: /* storage_qualifier: VARYING  */
-#line 1508 "MachineIndependent/glslang.y"
+#line 1512 "MachineIndependent/glslang.y"
               {
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
@@ -7335,32 +7369,52 @@ yyreduce:
         else
             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 7339 "MachineIndependent/glslang_tab.cpp"
+#line 7373 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 180: /* storage_qualifier: PATCH  */
-#line 1522 "MachineIndependent/glslang.y"
+#line 1526 "MachineIndependent/glslang.y"
             {
         parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.patch = true;
     }
-#line 7350 "MachineIndependent/glslang_tab.cpp"
+#line 7384 "MachineIndependent/glslang_tab.cpp"
     break;
 
   case 181: /* storage_qualifier: SAMPLE  */
-#line 1528 "MachineIndependent/glslang.y"
+#line 1532 "MachineIndependent/glslang.y"
              {
         parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.sample = true;
     }
-#line 7360 "MachineIndependent/glslang_tab.cpp"
+#line 7394 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 182: /* storage_qualifier: HITATTRNV  */
-#line 1533 "MachineIndependent/glslang.y"
+  case 182: /* storage_qualifier: RESOURCEHEAP  */
+#line 1537 "MachineIndependent/glslang.y"
+                   {
+        parseContext.globalCheck((yyvsp[0].lex).loc, "resourceHeap");
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.storage = EvqResourceHeap;
+    }
+#line 7404 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 183: /* storage_qualifier: SAMPLERHEAP  */
+#line 1542 "MachineIndependent/glslang.y"
+                  {
+        parseContext.globalCheck((yyvsp[0].lex).loc, "samplerHeap");
+        (yyval.interm.type).init((yyvsp[0].lex).loc);
+        (yyval.interm.type).qualifier.storage = EvqSamplerHeap;
+    }
+#line 7414 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 184: /* storage_qualifier: HITATTRNV  */
+#line 1547 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -7369,11 +7423,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 7373 "MachineIndependent/glslang_tab.cpp"
+#line 7427 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 183: /* storage_qualifier: HITOBJECTATTRNV  */
-#line 1541 "MachineIndependent/glslang.y"
+  case 185: /* storage_qualifier: HITOBJECTATTRNV  */
+#line 1555 "MachineIndependent/glslang.y"
                       {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask
@@ -7382,11 +7436,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitObjectAttrNV;
     }
-#line 7386 "MachineIndependent/glslang_tab.cpp"
+#line 7440 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 184: /* storage_qualifier: HITOBJECTATTREXT  */
-#line 1549 "MachineIndependent/glslang.y"
+  case 186: /* storage_qualifier: HITOBJECTATTREXT  */
+#line 1563 "MachineIndependent/glslang.y"
                        {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask
@@ -7395,11 +7449,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitObjectAttrEXT;
     }
-#line 7399 "MachineIndependent/glslang_tab.cpp"
+#line 7453 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 185: /* storage_qualifier: HITATTREXT  */
-#line 1557 "MachineIndependent/glslang.y"
+  case 187: /* storage_qualifier: HITATTREXT  */
+#line 1571 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -7408,11 +7462,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 7412 "MachineIndependent/glslang_tab.cpp"
+#line 7466 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 186: /* storage_qualifier: PAYLOADNV  */
-#line 1565 "MachineIndependent/glslang.y"
+  case 188: /* storage_qualifier: PAYLOADNV  */
+#line 1579 "MachineIndependent/glslang.y"
                 {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -7421,11 +7475,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 7425 "MachineIndependent/glslang_tab.cpp"
+#line 7479 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 187: /* storage_qualifier: PAYLOADEXT  */
-#line 1573 "MachineIndependent/glslang.y"
+  case 189: /* storage_qualifier: PAYLOADEXT  */
+#line 1587 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -7434,11 +7488,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 7438 "MachineIndependent/glslang_tab.cpp"
+#line 7492 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 188: /* storage_qualifier: PAYLOADINNV  */
-#line 1581 "MachineIndependent/glslang.y"
+  case 190: /* storage_qualifier: PAYLOADINNV  */
+#line 1595 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -7447,11 +7501,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 7451 "MachineIndependent/glslang_tab.cpp"
+#line 7505 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 189: /* storage_qualifier: PAYLOADINEXT  */
-#line 1589 "MachineIndependent/glslang.y"
+  case 191: /* storage_qualifier: PAYLOADINEXT  */
+#line 1603 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -7460,11 +7514,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 7464 "MachineIndependent/glslang_tab.cpp"
+#line 7518 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 190: /* storage_qualifier: CALLDATANV  */
-#line 1597 "MachineIndependent/glslang.y"
+  case 192: /* storage_qualifier: CALLDATANV  */
+#line 1611 "MachineIndependent/glslang.y"
                  {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -7473,11 +7527,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 7477 "MachineIndependent/glslang_tab.cpp"
+#line 7531 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 191: /* storage_qualifier: CALLDATAEXT  */
-#line 1605 "MachineIndependent/glslang.y"
+  case 193: /* storage_qualifier: CALLDATAEXT  */
+#line 1619 "MachineIndependent/glslang.y"
                   {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -7486,11 +7540,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 7490 "MachineIndependent/glslang_tab.cpp"
+#line 7544 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 192: /* storage_qualifier: CALLDATAINNV  */
-#line 1613 "MachineIndependent/glslang.y"
+  case 194: /* storage_qualifier: CALLDATAINNV  */
+#line 1627 "MachineIndependent/glslang.y"
                    {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV");
@@ -7498,11 +7552,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 7502 "MachineIndependent/glslang_tab.cpp"
+#line 7556 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 193: /* storage_qualifier: CALLDATAINEXT  */
-#line 1620 "MachineIndependent/glslang.y"
+  case 195: /* storage_qualifier: CALLDATAINEXT  */
+#line 1634 "MachineIndependent/glslang.y"
                     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT");
@@ -7510,147 +7564,147 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 7514 "MachineIndependent/glslang_tab.cpp"
+#line 7568 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 194: /* storage_qualifier: COHERENT  */
-#line 1627 "MachineIndependent/glslang.y"
+  case 196: /* storage_qualifier: COHERENT  */
+#line 1641 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
-#line 7523 "MachineIndependent/glslang_tab.cpp"
+#line 7577 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 195: /* storage_qualifier: DEVICECOHERENT  */
-#line 1631 "MachineIndependent/glslang.y"
+  case 197: /* storage_qualifier: DEVICECOHERENT  */
+#line 1645 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
         (yyval.interm.type).qualifier.devicecoherent = true;
     }
-#line 7533 "MachineIndependent/glslang_tab.cpp"
+#line 7587 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 196: /* storage_qualifier: QUEUEFAMILYCOHERENT  */
-#line 1636 "MachineIndependent/glslang.y"
+  case 198: /* storage_qualifier: QUEUEFAMILYCOHERENT  */
+#line 1650 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
         (yyval.interm.type).qualifier.queuefamilycoherent = true;
     }
-#line 7543 "MachineIndependent/glslang_tab.cpp"
+#line 7597 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 197: /* storage_qualifier: WORKGROUPCOHERENT  */
-#line 1641 "MachineIndependent/glslang.y"
+  case 199: /* storage_qualifier: WORKGROUPCOHERENT  */
+#line 1655 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
         (yyval.interm.type).qualifier.workgroupcoherent = true;
     }
-#line 7553 "MachineIndependent/glslang_tab.cpp"
+#line 7607 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 198: /* storage_qualifier: SUBGROUPCOHERENT  */
-#line 1646 "MachineIndependent/glslang.y"
+  case 200: /* storage_qualifier: SUBGROUPCOHERENT  */
+#line 1660 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
         (yyval.interm.type).qualifier.subgroupcoherent = true;
     }
-#line 7563 "MachineIndependent/glslang_tab.cpp"
+#line 7617 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 199: /* storage_qualifier: NONPRIVATE  */
-#line 1651 "MachineIndependent/glslang.y"
+  case 201: /* storage_qualifier: NONPRIVATE  */
+#line 1665 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
         (yyval.interm.type).qualifier.nonprivate = true;
     }
-#line 7573 "MachineIndependent/glslang_tab.cpp"
+#line 7627 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 200: /* storage_qualifier: SHADERCALLCOHERENT  */
-#line 1656 "MachineIndependent/glslang.y"
+  case 202: /* storage_qualifier: SHADERCALLCOHERENT  */
+#line 1670 "MachineIndependent/glslang.y"
                          {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent");
         (yyval.interm.type).qualifier.shadercallcoherent = true;
     }
-#line 7583 "MachineIndependent/glslang_tab.cpp"
+#line 7637 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 201: /* storage_qualifier: VOLATILE  */
-#line 1661 "MachineIndependent/glslang.y"
+  case 203: /* storage_qualifier: VOLATILE  */
+#line 1675 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.volatil = true;
     }
-#line 7592 "MachineIndependent/glslang_tab.cpp"
+#line 7646 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 202: /* storage_qualifier: RESTRICT  */
-#line 1665 "MachineIndependent/glslang.y"
+  case 204: /* storage_qualifier: RESTRICT  */
+#line 1679 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.restrict = true;
     }
-#line 7601 "MachineIndependent/glslang_tab.cpp"
+#line 7655 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 203: /* storage_qualifier: READONLY  */
-#line 1669 "MachineIndependent/glslang.y"
+  case 205: /* storage_qualifier: READONLY  */
+#line 1683 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.readonly = true;
     }
-#line 7610 "MachineIndependent/glslang_tab.cpp"
+#line 7664 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 204: /* storage_qualifier: WRITEONLY  */
-#line 1673 "MachineIndependent/glslang.y"
+  case 206: /* storage_qualifier: WRITEONLY  */
+#line 1687 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.writeonly = true;
     }
-#line 7619 "MachineIndependent/glslang_tab.cpp"
+#line 7673 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 205: /* storage_qualifier: NONTEMPORAL  */
-#line 1677 "MachineIndependent/glslang.y"
+  case 207: /* storage_qualifier: NONTEMPORAL  */
+#line 1691 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nontemporal  = true;
     }
-#line 7628 "MachineIndependent/glslang_tab.cpp"
+#line 7682 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 206: /* storage_qualifier: SUBROUTINE  */
-#line 1681 "MachineIndependent/glslang.y"
+  case 208: /* storage_qualifier: SUBROUTINE  */
+#line 1695 "MachineIndependent/glslang.y"
                  {
         parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
     }
-#line 7639 "MachineIndependent/glslang_tab.cpp"
+#line 7693 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 207: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN  */
-#line 1687 "MachineIndependent/glslang.y"
+  case 209: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN  */
+#line 1701 "MachineIndependent/glslang.y"
                                                        {
         parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[-3].lex).loc);
     }
-#line 7650 "MachineIndependent/glslang_tab.cpp"
+#line 7704 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 208: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT  */
-#line 1693 "MachineIndependent/glslang.y"
+  case 210: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT  */
+#line 1707 "MachineIndependent/glslang.y"
                               {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "taskPayloadSharedEXT");
@@ -7658,38 +7712,38 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqtaskPayloadSharedEXT;
     }
-#line 7662 "MachineIndependent/glslang_tab.cpp"
+#line 7716 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 209: /* non_uniform_qualifier: NONUNIFORM  */
-#line 1703 "MachineIndependent/glslang.y"
+  case 211: /* non_uniform_qualifier: NONUNIFORM  */
+#line 1717 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nonUniform = true;
     }
-#line 7671 "MachineIndependent/glslang_tab.cpp"
+#line 7725 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 210: /* type_name_list: IDENTIFIER  */
-#line 1710 "MachineIndependent/glslang.y"
+  case 212: /* type_name_list: IDENTIFIER  */
+#line 1724 "MachineIndependent/glslang.y"
                  {
         // TODO
     }
-#line 7679 "MachineIndependent/glslang_tab.cpp"
+#line 7733 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 211: /* type_name_list: type_name_list COMMA IDENTIFIER  */
-#line 1713 "MachineIndependent/glslang.y"
+  case 213: /* type_name_list: type_name_list COMMA IDENTIFIER  */
+#line 1727 "MachineIndependent/glslang.y"
                                       {
         // TODO: 4.0 semantics: subroutines
         // 1) make sure each identifier is a type declared earlier with SUBROUTINE
         // 2) save all of the identifiers for future comparison with the declared function
     }
-#line 7689 "MachineIndependent/glslang_tab.cpp"
+#line 7743 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 212: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt  */
-#line 1721 "MachineIndependent/glslang.y"
+  case 214: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt  */
+#line 1735 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
@@ -7697,11 +7751,11 @@ yyreduce:
         parseContext.typeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type));
 
     }
-#line 7701 "MachineIndependent/glslang_tab.cpp"
+#line 7755 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 213: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier  */
-#line 1728 "MachineIndependent/glslang.y"
+  case 215: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier  */
+#line 1742 "MachineIndependent/glslang.y"
                                                                            {
         parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
         (yyval.interm.type) = (yyvsp[-2].interm.type);
@@ -7710,21 +7764,21 @@ yyreduce:
         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
         parseContext.typeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type));
     }
-#line 7714 "MachineIndependent/glslang_tab.cpp"
+#line 7768 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 214: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET  */
-#line 1739 "MachineIndependent/glslang.y"
+  case 216: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET  */
+#line 1753 "MachineIndependent/glslang.y"
                                  {
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 7724 "MachineIndependent/glslang_tab.cpp"
+#line 7778 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 215: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
-#line 1744 "MachineIndependent/glslang.y"
+  case 217: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
+#line 1758 "MachineIndependent/glslang.y"
                                                         {
         (yyval.interm).loc = (yyvsp[-2].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -7733,20 +7787,20 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 7737 "MachineIndependent/glslang_tab.cpp"
+#line 7791 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 216: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET  */
-#line 1752 "MachineIndependent/glslang.y"
+  case 218: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET  */
+#line 1766 "MachineIndependent/glslang.y"
                                                  {
         (yyval.interm) = (yyvsp[-2].interm);
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 7746 "MachineIndependent/glslang_tab.cpp"
+#line 7800 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 217: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
-#line 1756 "MachineIndependent/glslang.y"
+  case 219: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET  */
+#line 1770 "MachineIndependent/glslang.y"
                                                                         {
         (yyval.interm) = (yyvsp[-3].interm);
 
@@ -7754,46 +7808,46 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 7758 "MachineIndependent/glslang_tab.cpp"
+#line 7812 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 218: /* type_parameter_specifier_opt: type_parameter_specifier  */
-#line 1766 "MachineIndependent/glslang.y"
+  case 220: /* type_parameter_specifier_opt: type_parameter_specifier  */
+#line 1780 "MachineIndependent/glslang.y"
                                {
         (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
     }
-#line 7766 "MachineIndependent/glslang_tab.cpp"
+#line 7820 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 219: /* type_parameter_specifier_opt: %empty  */
-#line 1769 "MachineIndependent/glslang.y"
+  case 221: /* type_parameter_specifier_opt: %empty  */
+#line 1783 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.typeParameters) = 0;
     }
-#line 7774 "MachineIndependent/glslang_tab.cpp"
+#line 7828 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 220: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE  */
-#line 1775 "MachineIndependent/glslang.y"
+  case 222: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE  */
+#line 1789 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
     }
-#line 7782 "MachineIndependent/glslang_tab.cpp"
+#line 7836 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 221: /* type_parameter_specifier_list: type_specifier  */
-#line 1781 "MachineIndependent/glslang.y"
+  case 223: /* type_parameter_specifier_list: type_specifier  */
+#line 1795 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.typeParameters) = new TTypeParameters;
         (yyval.interm.typeParameters)->arraySizes = new TArraySizes;
         (yyval.interm.typeParameters)->spirvType = (yyvsp[0].interm.type).spirvType;
         (yyval.interm.typeParameters)->basicType = (yyvsp[0].interm.type).basicType;
     }
-#line 7793 "MachineIndependent/glslang_tab.cpp"
+#line 7847 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 222: /* type_parameter_specifier_list: unary_expression  */
-#line 1787 "MachineIndependent/glslang.y"
+  case 224: /* type_parameter_specifier_list: unary_expression  */
+#line 1801 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.typeParameters) = new TTypeParameters;
         (yyval.interm.typeParameters)->arraySizes = new TArraySizes;
@@ -7802,11 +7856,11 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true);
         (yyval.interm.typeParameters)->arraySizes->addInnerSize(size);
     }
-#line 7806 "MachineIndependent/glslang_tab.cpp"
+#line 7860 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 223: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression  */
-#line 1795 "MachineIndependent/glslang.y"
+  case 225: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression  */
+#line 1809 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
 
@@ -7814,300 +7868,300 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true);
         (yyval.interm.typeParameters)->arraySizes->addInnerSize(size);
     }
-#line 7818 "MachineIndependent/glslang_tab.cpp"
+#line 7872 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 224: /* type_specifier_nonarray: VOID  */
-#line 1805 "MachineIndependent/glslang.y"
+  case 226: /* type_specifier_nonarray: VOID  */
+#line 1819 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
-#line 7827 "MachineIndependent/glslang_tab.cpp"
+#line 7881 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 225: /* type_specifier_nonarray: FLOAT  */
-#line 1809 "MachineIndependent/glslang.y"
+  case 227: /* type_specifier_nonarray: FLOAT  */
+#line 1823 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 7836 "MachineIndependent/glslang_tab.cpp"
+#line 7890 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 226: /* type_specifier_nonarray: INT  */
-#line 1813 "MachineIndependent/glslang.y"
+  case 228: /* type_specifier_nonarray: INT  */
+#line 1827 "MachineIndependent/glslang.y"
           {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 7845 "MachineIndependent/glslang_tab.cpp"
+#line 7899 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 227: /* type_specifier_nonarray: UINT  */
-#line 1817 "MachineIndependent/glslang.y"
+  case 229: /* type_specifier_nonarray: UINT  */
+#line 1831 "MachineIndependent/glslang.y"
            {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 7855 "MachineIndependent/glslang_tab.cpp"
+#line 7909 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 228: /* type_specifier_nonarray: BOOL  */
-#line 1822 "MachineIndependent/glslang.y"
-           {
-        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
-        (yyval.interm.type).basicType = EbtBool;
-    }
-#line 7864 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 229: /* type_specifier_nonarray: VEC2  */
-#line 1826 "MachineIndependent/glslang.y"
-           {
-        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
-        (yyval.interm.type).basicType = EbtFloat;
-        (yyval.interm.type).setVector(2);
-    }
-#line 7874 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 230: /* type_specifier_nonarray: VEC3  */
-#line 1831 "MachineIndependent/glslang.y"
-           {
-        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
-        (yyval.interm.type).basicType = EbtFloat;
-        (yyval.interm.type).setVector(3);
-    }
-#line 7884 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 231: /* type_specifier_nonarray: VEC4  */
+  case 230: /* type_specifier_nonarray: BOOL  */
 #line 1836 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtBool;
+    }
+#line 7918 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 231: /* type_specifier_nonarray: VEC2  */
+#line 1840 "MachineIndependent/glslang.y"
+           {
+        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtFloat;
+        (yyval.interm.type).setVector(2);
+    }
+#line 7928 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 232: /* type_specifier_nonarray: VEC3  */
+#line 1845 "MachineIndependent/glslang.y"
+           {
+        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtFloat;
+        (yyval.interm.type).setVector(3);
+    }
+#line 7938 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 233: /* type_specifier_nonarray: VEC4  */
+#line 1850 "MachineIndependent/glslang.y"
+           {
+        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 7894 "MachineIndependent/glslang_tab.cpp"
+#line 7948 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 232: /* type_specifier_nonarray: BVEC2  */
-#line 1841 "MachineIndependent/glslang.y"
+  case 234: /* type_specifier_nonarray: BVEC2  */
+#line 1855 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(2);
     }
-#line 7904 "MachineIndependent/glslang_tab.cpp"
+#line 7958 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 233: /* type_specifier_nonarray: BVEC3  */
-#line 1846 "MachineIndependent/glslang.y"
+  case 235: /* type_specifier_nonarray: BVEC3  */
+#line 1860 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(3);
     }
-#line 7914 "MachineIndependent/glslang_tab.cpp"
+#line 7968 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 234: /* type_specifier_nonarray: BVEC4  */
-#line 1851 "MachineIndependent/glslang.y"
+  case 236: /* type_specifier_nonarray: BVEC4  */
+#line 1865 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(4);
     }
-#line 7924 "MachineIndependent/glslang_tab.cpp"
+#line 7978 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 235: /* type_specifier_nonarray: IVEC2  */
-#line 1856 "MachineIndependent/glslang.y"
+  case 237: /* type_specifier_nonarray: IVEC2  */
+#line 1870 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 7934 "MachineIndependent/glslang_tab.cpp"
+#line 7988 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 236: /* type_specifier_nonarray: IVEC3  */
-#line 1861 "MachineIndependent/glslang.y"
+  case 238: /* type_specifier_nonarray: IVEC3  */
+#line 1875 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 7944 "MachineIndependent/glslang_tab.cpp"
+#line 7998 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 237: /* type_specifier_nonarray: IVEC4  */
-#line 1866 "MachineIndependent/glslang.y"
+  case 239: /* type_specifier_nonarray: IVEC4  */
+#line 1880 "MachineIndependent/glslang.y"
             {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 7954 "MachineIndependent/glslang_tab.cpp"
+#line 8008 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 238: /* type_specifier_nonarray: UVEC2  */
-#line 1871 "MachineIndependent/glslang.y"
+  case 240: /* type_specifier_nonarray: UVEC2  */
+#line 1885 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 7965 "MachineIndependent/glslang_tab.cpp"
+#line 8019 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 239: /* type_specifier_nonarray: UVEC3  */
-#line 1877 "MachineIndependent/glslang.y"
+  case 241: /* type_specifier_nonarray: UVEC3  */
+#line 1891 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 7976 "MachineIndependent/glslang_tab.cpp"
+#line 8030 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 240: /* type_specifier_nonarray: UVEC4  */
-#line 1883 "MachineIndependent/glslang.y"
+  case 242: /* type_specifier_nonarray: UVEC4  */
+#line 1897 "MachineIndependent/glslang.y"
             {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 7987 "MachineIndependent/glslang_tab.cpp"
+#line 8041 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 241: /* type_specifier_nonarray: MAT2  */
-#line 1889 "MachineIndependent/glslang.y"
+  case 243: /* type_specifier_nonarray: MAT2  */
+#line 1903 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7997 "MachineIndependent/glslang_tab.cpp"
+#line 8051 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 242: /* type_specifier_nonarray: MAT3  */
-#line 1894 "MachineIndependent/glslang.y"
+  case 244: /* type_specifier_nonarray: MAT3  */
+#line 1908 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8007 "MachineIndependent/glslang_tab.cpp"
+#line 8061 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 243: /* type_specifier_nonarray: MAT4  */
-#line 1899 "MachineIndependent/glslang.y"
+  case 245: /* type_specifier_nonarray: MAT4  */
+#line 1913 "MachineIndependent/glslang.y"
            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8017 "MachineIndependent/glslang_tab.cpp"
+#line 8071 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 244: /* type_specifier_nonarray: MAT2X2  */
-#line 1904 "MachineIndependent/glslang.y"
+  case 246: /* type_specifier_nonarray: MAT2X2  */
+#line 1918 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8027 "MachineIndependent/glslang_tab.cpp"
+#line 8081 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 245: /* type_specifier_nonarray: MAT2X3  */
-#line 1909 "MachineIndependent/glslang.y"
+  case 247: /* type_specifier_nonarray: MAT2X3  */
+#line 1923 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 8037 "MachineIndependent/glslang_tab.cpp"
+#line 8091 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 246: /* type_specifier_nonarray: MAT2X4  */
-#line 1914 "MachineIndependent/glslang.y"
+  case 248: /* type_specifier_nonarray: MAT2X4  */
+#line 1928 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 8047 "MachineIndependent/glslang_tab.cpp"
+#line 8101 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 247: /* type_specifier_nonarray: MAT3X2  */
-#line 1919 "MachineIndependent/glslang.y"
+  case 249: /* type_specifier_nonarray: MAT3X2  */
+#line 1933 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 8057 "MachineIndependent/glslang_tab.cpp"
+#line 8111 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 248: /* type_specifier_nonarray: MAT3X3  */
-#line 1924 "MachineIndependent/glslang.y"
+  case 250: /* type_specifier_nonarray: MAT3X3  */
+#line 1938 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8067 "MachineIndependent/glslang_tab.cpp"
+#line 8121 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 249: /* type_specifier_nonarray: MAT3X4  */
-#line 1929 "MachineIndependent/glslang.y"
+  case 251: /* type_specifier_nonarray: MAT3X4  */
+#line 1943 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 8077 "MachineIndependent/glslang_tab.cpp"
+#line 8131 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 250: /* type_specifier_nonarray: MAT4X2  */
-#line 1934 "MachineIndependent/glslang.y"
+  case 252: /* type_specifier_nonarray: MAT4X2  */
+#line 1948 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 8087 "MachineIndependent/glslang_tab.cpp"
+#line 8141 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 251: /* type_specifier_nonarray: MAT4X3  */
-#line 1939 "MachineIndependent/glslang.y"
+  case 253: /* type_specifier_nonarray: MAT4X3  */
+#line 1953 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 8097 "MachineIndependent/glslang_tab.cpp"
+#line 8151 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 252: /* type_specifier_nonarray: MAT4X4  */
-#line 1944 "MachineIndependent/glslang.y"
+  case 254: /* type_specifier_nonarray: MAT4X4  */
+#line 1958 "MachineIndependent/glslang.y"
              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8107 "MachineIndependent/glslang_tab.cpp"
+#line 8161 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 253: /* type_specifier_nonarray: DOUBLE  */
-#line 1949 "MachineIndependent/glslang.y"
+  case 255: /* type_specifier_nonarray: DOUBLE  */
+#line 1963 "MachineIndependent/glslang.y"
              {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8115,151 +8169,151 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 8119 "MachineIndependent/glslang_tab.cpp"
+#line 8173 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 254: /* type_specifier_nonarray: BFLOAT16_T  */
-#line 1956 "MachineIndependent/glslang.y"
+  case 256: /* type_specifier_nonarray: BFLOAT16_T  */
+#line 1970 "MachineIndependent/glslang.y"
                  {
         parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "bfloat16_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBFloat16;
     }
-#line 8129 "MachineIndependent/glslang_tab.cpp"
+#line 8183 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 255: /* type_specifier_nonarray: FLOATE5M2_T  */
-#line 1961 "MachineIndependent/glslang.y"
+  case 257: /* type_specifier_nonarray: FLOATE5M2_T  */
+#line 1975 "MachineIndependent/glslang.y"
                   {
         parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "floate5m2_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE5M2;
     }
-#line 8139 "MachineIndependent/glslang_tab.cpp"
+#line 8193 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 256: /* type_specifier_nonarray: FLOATE4M3_T  */
-#line 1966 "MachineIndependent/glslang.y"
+  case 258: /* type_specifier_nonarray: FLOATE4M3_T  */
+#line 1980 "MachineIndependent/glslang.y"
                   {
         parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "floate4m3_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE4M3;
     }
-#line 8149 "MachineIndependent/glslang_tab.cpp"
+#line 8203 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 257: /* type_specifier_nonarray: FLOAT16_T  */
-#line 1971 "MachineIndependent/glslang.y"
+  case 259: /* type_specifier_nonarray: FLOAT16_T  */
+#line 1985 "MachineIndependent/glslang.y"
                 {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
     }
-#line 8159 "MachineIndependent/glslang_tab.cpp"
+#line 8213 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 258: /* type_specifier_nonarray: FLOAT32_T  */
-#line 1976 "MachineIndependent/glslang.y"
+  case 260: /* type_specifier_nonarray: FLOAT32_T  */
+#line 1990 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 8169 "MachineIndependent/glslang_tab.cpp"
+#line 8223 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 259: /* type_specifier_nonarray: FLOAT64_T  */
-#line 1981 "MachineIndependent/glslang.y"
+  case 261: /* type_specifier_nonarray: FLOAT64_T  */
+#line 1995 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 8179 "MachineIndependent/glslang_tab.cpp"
+#line 8233 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 260: /* type_specifier_nonarray: INT8_T  */
-#line 1986 "MachineIndependent/glslang.y"
+  case 262: /* type_specifier_nonarray: INT8_T  */
+#line 2000 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
     }
-#line 8189 "MachineIndependent/glslang_tab.cpp"
+#line 8243 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 261: /* type_specifier_nonarray: UINT8_T  */
-#line 1991 "MachineIndependent/glslang.y"
+  case 263: /* type_specifier_nonarray: UINT8_T  */
+#line 2005 "MachineIndependent/glslang.y"
               {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
     }
-#line 8199 "MachineIndependent/glslang_tab.cpp"
+#line 8253 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 262: /* type_specifier_nonarray: INT16_T  */
-#line 1996 "MachineIndependent/glslang.y"
+  case 264: /* type_specifier_nonarray: INT16_T  */
+#line 2010 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
     }
-#line 8209 "MachineIndependent/glslang_tab.cpp"
+#line 8263 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 263: /* type_specifier_nonarray: UINT16_T  */
-#line 2001 "MachineIndependent/glslang.y"
+  case 265: /* type_specifier_nonarray: UINT16_T  */
+#line 2015 "MachineIndependent/glslang.y"
                {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
     }
-#line 8219 "MachineIndependent/glslang_tab.cpp"
+#line 8273 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 264: /* type_specifier_nonarray: INT32_T  */
-#line 2006 "MachineIndependent/glslang.y"
+  case 266: /* type_specifier_nonarray: INT32_T  */
+#line 2020 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 8229 "MachineIndependent/glslang_tab.cpp"
+#line 8283 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 265: /* type_specifier_nonarray: UINT32_T  */
-#line 2011 "MachineIndependent/glslang.y"
+  case 267: /* type_specifier_nonarray: UINT32_T  */
+#line 2025 "MachineIndependent/glslang.y"
                {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 8239 "MachineIndependent/glslang_tab.cpp"
+#line 8293 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 266: /* type_specifier_nonarray: INT64_T  */
-#line 2016 "MachineIndependent/glslang.y"
+  case 268: /* type_specifier_nonarray: INT64_T  */
+#line 2030 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
     }
-#line 8249 "MachineIndependent/glslang_tab.cpp"
+#line 8303 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 267: /* type_specifier_nonarray: UINT64_T  */
-#line 2021 "MachineIndependent/glslang.y"
+  case 269: /* type_specifier_nonarray: UINT64_T  */
+#line 2035 "MachineIndependent/glslang.y"
                {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
     }
-#line 8259 "MachineIndependent/glslang_tab.cpp"
+#line 8313 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 268: /* type_specifier_nonarray: DVEC2  */
-#line 2026 "MachineIndependent/glslang.y"
+  case 270: /* type_specifier_nonarray: DVEC2  */
+#line 2040 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8268,11 +8322,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 8272 "MachineIndependent/glslang_tab.cpp"
+#line 8326 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 269: /* type_specifier_nonarray: DVEC3  */
-#line 2034 "MachineIndependent/glslang.y"
+  case 271: /* type_specifier_nonarray: DVEC3  */
+#line 2048 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8281,486 +8335,486 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 8285 "MachineIndependent/glslang_tab.cpp"
+#line 8339 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 270: /* type_specifier_nonarray: DVEC4  */
-#line 2042 "MachineIndependent/glslang.y"
-            {
-        parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
-        if (! parseContext.symbolTable.atBuiltInLevel())
-            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 8298 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 271: /* type_specifier_nonarray: BF16VEC2  */
-#line 2050 "MachineIndependent/glslang.y"
-               {
-        parseContext.bfloat16ScalarVectorCheck((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 = EbtBFloat16;
-        (yyval.interm.type).setVector(2);
-    }
-#line 8309 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 272: /* type_specifier_nonarray: BF16VEC3  */
+  case 272: /* type_specifier_nonarray: DVEC4  */
 #line 2056 "MachineIndependent/glslang.y"
+            {
+        parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
+        if (! parseContext.symbolTable.atBuiltInLevel())
+            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 8352 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 273: /* type_specifier_nonarray: BF16VEC2  */
+#line 2064 "MachineIndependent/glslang.y"
+               {
+        parseContext.bfloat16ScalarVectorCheck((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 = EbtBFloat16;
+        (yyval.interm.type).setVector(2);
+    }
+#line 8363 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 274: /* type_specifier_nonarray: BF16VEC3  */
+#line 2070 "MachineIndependent/glslang.y"
                {
         parseContext.bfloat16ScalarVectorCheck((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 = EbtBFloat16;
         (yyval.interm.type).setVector(3);
     }
-#line 8320 "MachineIndependent/glslang_tab.cpp"
+#line 8374 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 273: /* type_specifier_nonarray: BF16VEC4  */
-#line 2062 "MachineIndependent/glslang.y"
+  case 275: /* type_specifier_nonarray: BF16VEC4  */
+#line 2076 "MachineIndependent/glslang.y"
                {
         parseContext.bfloat16ScalarVectorCheck((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 = EbtBFloat16;
         (yyval.interm.type).setVector(4);
     }
-#line 8331 "MachineIndependent/glslang_tab.cpp"
+#line 8385 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 274: /* type_specifier_nonarray: FE5M2VEC2  */
-#line 2068 "MachineIndependent/glslang.y"
+  case 276: /* type_specifier_nonarray: FE5M2VEC2  */
+#line 2082 "MachineIndependent/glslang.y"
                 {
         parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE5M2;
         (yyval.interm.type).setVector(2);
     }
-#line 8342 "MachineIndependent/glslang_tab.cpp"
+#line 8396 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 275: /* type_specifier_nonarray: FE5M2VEC3  */
-#line 2074 "MachineIndependent/glslang.y"
+  case 277: /* type_specifier_nonarray: FE5M2VEC3  */
+#line 2088 "MachineIndependent/glslang.y"
                 {
         parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE5M2;
         (yyval.interm.type).setVector(3);
     }
-#line 8353 "MachineIndependent/glslang_tab.cpp"
+#line 8407 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 276: /* type_specifier_nonarray: FE5M2VEC4  */
-#line 2080 "MachineIndependent/glslang.y"
+  case 278: /* type_specifier_nonarray: FE5M2VEC4  */
+#line 2094 "MachineIndependent/glslang.y"
                 {
         parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE5M2;
         (yyval.interm.type).setVector(4);
     }
-#line 8364 "MachineIndependent/glslang_tab.cpp"
+#line 8418 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 277: /* type_specifier_nonarray: FE4M3VEC2  */
-#line 2086 "MachineIndependent/glslang.y"
+  case 279: /* type_specifier_nonarray: FE4M3VEC2  */
+#line 2100 "MachineIndependent/glslang.y"
                 {
         parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE4M3;
         (yyval.interm.type).setVector(2);
     }
-#line 8375 "MachineIndependent/glslang_tab.cpp"
+#line 8429 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 278: /* type_specifier_nonarray: FE4M3VEC3  */
-#line 2092 "MachineIndependent/glslang.y"
+  case 280: /* type_specifier_nonarray: FE4M3VEC3  */
+#line 2106 "MachineIndependent/glslang.y"
                 {
         parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE4M3;
         (yyval.interm.type).setVector(3);
     }
-#line 8386 "MachineIndependent/glslang_tab.cpp"
+#line 8440 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 279: /* type_specifier_nonarray: FE4M3VEC4  */
-#line 2098 "MachineIndependent/glslang.y"
+  case 281: /* type_specifier_nonarray: FE4M3VEC4  */
+#line 2112 "MachineIndependent/glslang.y"
                 {
         parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloatE4M3;
         (yyval.interm.type).setVector(4);
     }
-#line 8397 "MachineIndependent/glslang_tab.cpp"
+#line 8451 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 280: /* type_specifier_nonarray: F16VEC2  */
-#line 2104 "MachineIndependent/glslang.y"
+  case 282: /* type_specifier_nonarray: F16VEC2  */
+#line 2118 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(2);
     }
-#line 8408 "MachineIndependent/glslang_tab.cpp"
+#line 8462 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 281: /* type_specifier_nonarray: F16VEC3  */
-#line 2110 "MachineIndependent/glslang.y"
+  case 283: /* type_specifier_nonarray: F16VEC3  */
+#line 2124 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(3);
     }
-#line 8419 "MachineIndependent/glslang_tab.cpp"
+#line 8473 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 282: /* type_specifier_nonarray: F16VEC4  */
-#line 2116 "MachineIndependent/glslang.y"
+  case 284: /* type_specifier_nonarray: F16VEC4  */
+#line 2130 "MachineIndependent/glslang.y"
               {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(4);
     }
-#line 8430 "MachineIndependent/glslang_tab.cpp"
+#line 8484 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 283: /* type_specifier_nonarray: F32VEC2  */
-#line 2122 "MachineIndependent/glslang.y"
+  case 285: /* type_specifier_nonarray: F32VEC2  */
+#line 2136 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 8441 "MachineIndependent/glslang_tab.cpp"
+#line 8495 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 284: /* type_specifier_nonarray: F32VEC3  */
-#line 2128 "MachineIndependent/glslang.y"
+  case 286: /* type_specifier_nonarray: F32VEC3  */
+#line 2142 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 8452 "MachineIndependent/glslang_tab.cpp"
+#line 8506 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 285: /* type_specifier_nonarray: F32VEC4  */
-#line 2134 "MachineIndependent/glslang.y"
+  case 287: /* type_specifier_nonarray: F32VEC4  */
+#line 2148 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 8463 "MachineIndependent/glslang_tab.cpp"
+#line 8517 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 286: /* type_specifier_nonarray: F64VEC2  */
-#line 2140 "MachineIndependent/glslang.y"
+  case 288: /* type_specifier_nonarray: F64VEC2  */
+#line 2154 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 8474 "MachineIndependent/glslang_tab.cpp"
+#line 8528 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 287: /* type_specifier_nonarray: F64VEC3  */
-#line 2146 "MachineIndependent/glslang.y"
+  case 289: /* type_specifier_nonarray: F64VEC3  */
+#line 2160 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 8485 "MachineIndependent/glslang_tab.cpp"
+#line 8539 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 288: /* type_specifier_nonarray: F64VEC4  */
-#line 2152 "MachineIndependent/glslang.y"
+  case 290: /* type_specifier_nonarray: F64VEC4  */
+#line 2166 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 8496 "MachineIndependent/glslang_tab.cpp"
+#line 8550 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 289: /* type_specifier_nonarray: I8VEC2  */
-#line 2158 "MachineIndependent/glslang.y"
+  case 291: /* type_specifier_nonarray: I8VEC2  */
+#line 2172 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(2);
     }
-#line 8507 "MachineIndependent/glslang_tab.cpp"
+#line 8561 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 290: /* type_specifier_nonarray: I8VEC3  */
-#line 2164 "MachineIndependent/glslang.y"
+  case 292: /* type_specifier_nonarray: I8VEC3  */
+#line 2178 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(3);
     }
-#line 8518 "MachineIndependent/glslang_tab.cpp"
+#line 8572 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 291: /* type_specifier_nonarray: I8VEC4  */
-#line 2170 "MachineIndependent/glslang.y"
+  case 293: /* type_specifier_nonarray: I8VEC4  */
+#line 2184 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(4);
     }
-#line 8529 "MachineIndependent/glslang_tab.cpp"
+#line 8583 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 292: /* type_specifier_nonarray: I16VEC2  */
-#line 2176 "MachineIndependent/glslang.y"
+  case 294: /* type_specifier_nonarray: I16VEC2  */
+#line 2190 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(2);
     }
-#line 8540 "MachineIndependent/glslang_tab.cpp"
+#line 8594 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 293: /* type_specifier_nonarray: I16VEC3  */
-#line 2182 "MachineIndependent/glslang.y"
+  case 295: /* type_specifier_nonarray: I16VEC3  */
+#line 2196 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(3);
     }
-#line 8551 "MachineIndependent/glslang_tab.cpp"
+#line 8605 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 294: /* type_specifier_nonarray: I16VEC4  */
-#line 2188 "MachineIndependent/glslang.y"
+  case 296: /* type_specifier_nonarray: I16VEC4  */
+#line 2202 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(4);
     }
-#line 8562 "MachineIndependent/glslang_tab.cpp"
+#line 8616 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 295: /* type_specifier_nonarray: I32VEC2  */
-#line 2194 "MachineIndependent/glslang.y"
+  case 297: /* type_specifier_nonarray: I32VEC2  */
+#line 2208 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 8573 "MachineIndependent/glslang_tab.cpp"
+#line 8627 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 296: /* type_specifier_nonarray: I32VEC3  */
-#line 2200 "MachineIndependent/glslang.y"
+  case 298: /* type_specifier_nonarray: I32VEC3  */
+#line 2214 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 8584 "MachineIndependent/glslang_tab.cpp"
+#line 8638 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 297: /* type_specifier_nonarray: I32VEC4  */
-#line 2206 "MachineIndependent/glslang.y"
+  case 299: /* type_specifier_nonarray: I32VEC4  */
+#line 2220 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 8595 "MachineIndependent/glslang_tab.cpp"
+#line 8649 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 298: /* type_specifier_nonarray: I64VEC2  */
-#line 2212 "MachineIndependent/glslang.y"
+  case 300: /* type_specifier_nonarray: I64VEC2  */
+#line 2226 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(2);
     }
-#line 8606 "MachineIndependent/glslang_tab.cpp"
+#line 8660 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 299: /* type_specifier_nonarray: I64VEC3  */
-#line 2218 "MachineIndependent/glslang.y"
+  case 301: /* type_specifier_nonarray: I64VEC3  */
+#line 2232 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(3);
     }
-#line 8617 "MachineIndependent/glslang_tab.cpp"
+#line 8671 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 300: /* type_specifier_nonarray: I64VEC4  */
-#line 2224 "MachineIndependent/glslang.y"
+  case 302: /* type_specifier_nonarray: I64VEC4  */
+#line 2238 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(4);
     }
-#line 8628 "MachineIndependent/glslang_tab.cpp"
+#line 8682 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 301: /* type_specifier_nonarray: U8VEC2  */
-#line 2230 "MachineIndependent/glslang.y"
+  case 303: /* type_specifier_nonarray: U8VEC2  */
+#line 2244 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(2);
     }
-#line 8639 "MachineIndependent/glslang_tab.cpp"
+#line 8693 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 302: /* type_specifier_nonarray: U8VEC3  */
-#line 2236 "MachineIndependent/glslang.y"
+  case 304: /* type_specifier_nonarray: U8VEC3  */
+#line 2250 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(3);
     }
-#line 8650 "MachineIndependent/glslang_tab.cpp"
+#line 8704 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 303: /* type_specifier_nonarray: U8VEC4  */
-#line 2242 "MachineIndependent/glslang.y"
+  case 305: /* type_specifier_nonarray: U8VEC4  */
+#line 2256 "MachineIndependent/glslang.y"
              {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(4);
     }
-#line 8661 "MachineIndependent/glslang_tab.cpp"
+#line 8715 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 304: /* type_specifier_nonarray: U16VEC2  */
-#line 2248 "MachineIndependent/glslang.y"
+  case 306: /* type_specifier_nonarray: U16VEC2  */
+#line 2262 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(2);
     }
-#line 8672 "MachineIndependent/glslang_tab.cpp"
+#line 8726 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 305: /* type_specifier_nonarray: U16VEC3  */
-#line 2254 "MachineIndependent/glslang.y"
+  case 307: /* type_specifier_nonarray: U16VEC3  */
+#line 2268 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(3);
     }
-#line 8683 "MachineIndependent/glslang_tab.cpp"
+#line 8737 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 306: /* type_specifier_nonarray: U16VEC4  */
-#line 2260 "MachineIndependent/glslang.y"
+  case 308: /* type_specifier_nonarray: U16VEC4  */
+#line 2274 "MachineIndependent/glslang.y"
               {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(4);
     }
-#line 8694 "MachineIndependent/glslang_tab.cpp"
+#line 8748 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 307: /* type_specifier_nonarray: U32VEC2  */
-#line 2266 "MachineIndependent/glslang.y"
+  case 309: /* type_specifier_nonarray: U32VEC2  */
+#line 2280 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 8705 "MachineIndependent/glslang_tab.cpp"
+#line 8759 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 308: /* type_specifier_nonarray: U32VEC3  */
-#line 2272 "MachineIndependent/glslang.y"
+  case 310: /* type_specifier_nonarray: U32VEC3  */
+#line 2286 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 8716 "MachineIndependent/glslang_tab.cpp"
+#line 8770 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 309: /* type_specifier_nonarray: U32VEC4  */
-#line 2278 "MachineIndependent/glslang.y"
+  case 311: /* type_specifier_nonarray: U32VEC4  */
+#line 2292 "MachineIndependent/glslang.y"
               {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 8727 "MachineIndependent/glslang_tab.cpp"
+#line 8781 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 310: /* type_specifier_nonarray: U64VEC2  */
-#line 2284 "MachineIndependent/glslang.y"
+  case 312: /* type_specifier_nonarray: U64VEC2  */
+#line 2298 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(2);
     }
-#line 8738 "MachineIndependent/glslang_tab.cpp"
+#line 8792 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 311: /* type_specifier_nonarray: U64VEC3  */
-#line 2290 "MachineIndependent/glslang.y"
+  case 313: /* type_specifier_nonarray: U64VEC3  */
+#line 2304 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(3);
     }
-#line 8749 "MachineIndependent/glslang_tab.cpp"
+#line 8803 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 312: /* type_specifier_nonarray: U64VEC4  */
-#line 2296 "MachineIndependent/glslang.y"
+  case 314: /* type_specifier_nonarray: U64VEC4  */
+#line 2310 "MachineIndependent/glslang.y"
               {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(4);
     }
-#line 8760 "MachineIndependent/glslang_tab.cpp"
+#line 8814 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 313: /* type_specifier_nonarray: DMAT2  */
-#line 2302 "MachineIndependent/glslang.y"
+  case 315: /* type_specifier_nonarray: DMAT2  */
+#line 2316 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8769,11 +8823,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8773 "MachineIndependent/glslang_tab.cpp"
+#line 8827 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 314: /* type_specifier_nonarray: DMAT3  */
-#line 2310 "MachineIndependent/glslang.y"
+  case 316: /* type_specifier_nonarray: DMAT3  */
+#line 2324 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8782,11 +8836,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8786 "MachineIndependent/glslang_tab.cpp"
+#line 8840 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 315: /* type_specifier_nonarray: DMAT4  */
-#line 2318 "MachineIndependent/glslang.y"
+  case 317: /* type_specifier_nonarray: DMAT4  */
+#line 2332 "MachineIndependent/glslang.y"
             {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8795,11 +8849,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8799 "MachineIndependent/glslang_tab.cpp"
+#line 8853 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 316: /* type_specifier_nonarray: DMAT2X2  */
-#line 2326 "MachineIndependent/glslang.y"
+  case 318: /* type_specifier_nonarray: DMAT2X2  */
+#line 2340 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8808,11 +8862,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8812 "MachineIndependent/glslang_tab.cpp"
+#line 8866 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 317: /* type_specifier_nonarray: DMAT2X3  */
-#line 2334 "MachineIndependent/glslang.y"
+  case 319: /* type_specifier_nonarray: DMAT2X3  */
+#line 2348 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8821,11 +8875,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 8825 "MachineIndependent/glslang_tab.cpp"
+#line 8879 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 318: /* type_specifier_nonarray: DMAT2X4  */
-#line 2342 "MachineIndependent/glslang.y"
+  case 320: /* type_specifier_nonarray: DMAT2X4  */
+#line 2356 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8834,11 +8888,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 8838 "MachineIndependent/glslang_tab.cpp"
+#line 8892 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 319: /* type_specifier_nonarray: DMAT3X2  */
-#line 2350 "MachineIndependent/glslang.y"
+  case 321: /* type_specifier_nonarray: DMAT3X2  */
+#line 2364 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8847,11 +8901,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 8851 "MachineIndependent/glslang_tab.cpp"
+#line 8905 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 320: /* type_specifier_nonarray: DMAT3X3  */
-#line 2358 "MachineIndependent/glslang.y"
+  case 322: /* type_specifier_nonarray: DMAT3X3  */
+#line 2372 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8860,11 +8914,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8864 "MachineIndependent/glslang_tab.cpp"
+#line 8918 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 321: /* type_specifier_nonarray: DMAT3X4  */
-#line 2366 "MachineIndependent/glslang.y"
+  case 323: /* type_specifier_nonarray: DMAT3X4  */
+#line 2380 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8873,11 +8927,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 8877 "MachineIndependent/glslang_tab.cpp"
+#line 8931 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 322: /* type_specifier_nonarray: DMAT4X2  */
-#line 2374 "MachineIndependent/glslang.y"
+  case 324: /* type_specifier_nonarray: DMAT4X2  */
+#line 2388 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8886,11 +8940,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 8890 "MachineIndependent/glslang_tab.cpp"
+#line 8944 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 323: /* type_specifier_nonarray: DMAT4X3  */
-#line 2382 "MachineIndependent/glslang.y"
+  case 325: /* type_specifier_nonarray: DMAT4X3  */
+#line 2396 "MachineIndependent/glslang.y"
               {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -8899,2274 +8953,2274 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 8903 "MachineIndependent/glslang_tab.cpp"
+#line 8957 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 324: /* type_specifier_nonarray: DMAT4X4  */
-#line 2390 "MachineIndependent/glslang.y"
-              {
-        parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
-        if (! parseContext.symbolTable.atBuiltInLevel())
-            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 8916 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 325: /* type_specifier_nonarray: F16MAT2  */
-#line 2398 "MachineIndependent/glslang.y"
-              {
-        parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
-        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
-        (yyval.interm.type).basicType = EbtFloat16;
-        (yyval.interm.type).setMatrix(2, 2);
-    }
-#line 8927 "MachineIndependent/glslang_tab.cpp"
-    break;
-
-  case 326: /* type_specifier_nonarray: F16MAT3  */
+  case 326: /* type_specifier_nonarray: DMAT4X4  */
 #line 2404 "MachineIndependent/glslang.y"
               {
+        parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
+        if (! parseContext.symbolTable.atBuiltInLevel())
+            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 8970 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 327: /* type_specifier_nonarray: F16MAT2  */
+#line 2412 "MachineIndependent/glslang.y"
+              {
+        parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtFloat16;
+        (yyval.interm.type).setMatrix(2, 2);
+    }
+#line 8981 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 328: /* type_specifier_nonarray: F16MAT3  */
+#line 2418 "MachineIndependent/glslang.y"
+              {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 8938 "MachineIndependent/glslang_tab.cpp"
+#line 8992 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 327: /* type_specifier_nonarray: F16MAT4  */
-#line 2410 "MachineIndependent/glslang.y"
+  case 329: /* type_specifier_nonarray: F16MAT4  */
+#line 2424 "MachineIndependent/glslang.y"
               {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 8949 "MachineIndependent/glslang_tab.cpp"
+#line 9003 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 328: /* type_specifier_nonarray: F16MAT2X2  */
-#line 2416 "MachineIndependent/glslang.y"
+  case 330: /* type_specifier_nonarray: F16MAT2X2  */
+#line 2430 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 8960 "MachineIndependent/glslang_tab.cpp"
+#line 9014 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 329: /* type_specifier_nonarray: F16MAT2X3  */
-#line 2422 "MachineIndependent/glslang.y"
+  case 331: /* type_specifier_nonarray: F16MAT2X3  */
+#line 2436 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 8971 "MachineIndependent/glslang_tab.cpp"
+#line 9025 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 330: /* type_specifier_nonarray: F16MAT2X4  */
-#line 2428 "MachineIndependent/glslang.y"
+  case 332: /* type_specifier_nonarray: F16MAT2X4  */
+#line 2442 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 8982 "MachineIndependent/glslang_tab.cpp"
+#line 9036 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 331: /* type_specifier_nonarray: F16MAT3X2  */
-#line 2434 "MachineIndependent/glslang.y"
+  case 333: /* type_specifier_nonarray: F16MAT3X2  */
+#line 2448 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 8993 "MachineIndependent/glslang_tab.cpp"
+#line 9047 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 332: /* type_specifier_nonarray: F16MAT3X3  */
-#line 2440 "MachineIndependent/glslang.y"
+  case 334: /* type_specifier_nonarray: F16MAT3X3  */
+#line 2454 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 9004 "MachineIndependent/glslang_tab.cpp"
+#line 9058 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 333: /* type_specifier_nonarray: F16MAT3X4  */
-#line 2446 "MachineIndependent/glslang.y"
+  case 335: /* type_specifier_nonarray: F16MAT3X4  */
+#line 2460 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 9015 "MachineIndependent/glslang_tab.cpp"
+#line 9069 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 334: /* type_specifier_nonarray: F16MAT4X2  */
-#line 2452 "MachineIndependent/glslang.y"
+  case 336: /* type_specifier_nonarray: F16MAT4X2  */
+#line 2466 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 9026 "MachineIndependent/glslang_tab.cpp"
+#line 9080 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 335: /* type_specifier_nonarray: F16MAT4X3  */
-#line 2458 "MachineIndependent/glslang.y"
+  case 337: /* type_specifier_nonarray: F16MAT4X3  */
+#line 2472 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 9037 "MachineIndependent/glslang_tab.cpp"
+#line 9091 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 336: /* type_specifier_nonarray: F16MAT4X4  */
-#line 2464 "MachineIndependent/glslang.y"
+  case 338: /* type_specifier_nonarray: F16MAT4X4  */
+#line 2478 "MachineIndependent/glslang.y"
                 {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 9048 "MachineIndependent/glslang_tab.cpp"
+#line 9102 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 337: /* type_specifier_nonarray: F32MAT2  */
-#line 2470 "MachineIndependent/glslang.y"
+  case 339: /* type_specifier_nonarray: F32MAT2  */
+#line 2484 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 9059 "MachineIndependent/glslang_tab.cpp"
+#line 9113 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 338: /* type_specifier_nonarray: F32MAT3  */
-#line 2476 "MachineIndependent/glslang.y"
+  case 340: /* type_specifier_nonarray: F32MAT3  */
+#line 2490 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 9070 "MachineIndependent/glslang_tab.cpp"
+#line 9124 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 339: /* type_specifier_nonarray: F32MAT4  */
-#line 2482 "MachineIndependent/glslang.y"
+  case 341: /* type_specifier_nonarray: F32MAT4  */
+#line 2496 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 9081 "MachineIndependent/glslang_tab.cpp"
+#line 9135 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 340: /* type_specifier_nonarray: F32MAT2X2  */
-#line 2488 "MachineIndependent/glslang.y"
+  case 342: /* type_specifier_nonarray: F32MAT2X2  */
+#line 2502 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 9092 "MachineIndependent/glslang_tab.cpp"
+#line 9146 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 341: /* type_specifier_nonarray: F32MAT2X3  */
-#line 2494 "MachineIndependent/glslang.y"
+  case 343: /* type_specifier_nonarray: F32MAT2X3  */
+#line 2508 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 9103 "MachineIndependent/glslang_tab.cpp"
+#line 9157 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 342: /* type_specifier_nonarray: F32MAT2X4  */
-#line 2500 "MachineIndependent/glslang.y"
+  case 344: /* type_specifier_nonarray: F32MAT2X4  */
+#line 2514 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 9114 "MachineIndependent/glslang_tab.cpp"
+#line 9168 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 343: /* type_specifier_nonarray: F32MAT3X2  */
-#line 2506 "MachineIndependent/glslang.y"
+  case 345: /* type_specifier_nonarray: F32MAT3X2  */
+#line 2520 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 9125 "MachineIndependent/glslang_tab.cpp"
+#line 9179 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 344: /* type_specifier_nonarray: F32MAT3X3  */
-#line 2512 "MachineIndependent/glslang.y"
+  case 346: /* type_specifier_nonarray: F32MAT3X3  */
+#line 2526 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 9136 "MachineIndependent/glslang_tab.cpp"
+#line 9190 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 345: /* type_specifier_nonarray: F32MAT3X4  */
-#line 2518 "MachineIndependent/glslang.y"
+  case 347: /* type_specifier_nonarray: F32MAT3X4  */
+#line 2532 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 9147 "MachineIndependent/glslang_tab.cpp"
+#line 9201 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 346: /* type_specifier_nonarray: F32MAT4X2  */
-#line 2524 "MachineIndependent/glslang.y"
+  case 348: /* type_specifier_nonarray: F32MAT4X2  */
+#line 2538 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 9158 "MachineIndependent/glslang_tab.cpp"
+#line 9212 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 347: /* type_specifier_nonarray: F32MAT4X3  */
-#line 2530 "MachineIndependent/glslang.y"
+  case 349: /* type_specifier_nonarray: F32MAT4X3  */
+#line 2544 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 9169 "MachineIndependent/glslang_tab.cpp"
+#line 9223 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 348: /* type_specifier_nonarray: F32MAT4X4  */
-#line 2536 "MachineIndependent/glslang.y"
+  case 350: /* type_specifier_nonarray: F32MAT4X4  */
+#line 2550 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 9180 "MachineIndependent/glslang_tab.cpp"
+#line 9234 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 349: /* type_specifier_nonarray: F64MAT2  */
-#line 2542 "MachineIndependent/glslang.y"
+  case 351: /* type_specifier_nonarray: F64MAT2  */
+#line 2556 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 9191 "MachineIndependent/glslang_tab.cpp"
+#line 9245 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 350: /* type_specifier_nonarray: F64MAT3  */
-#line 2548 "MachineIndependent/glslang.y"
+  case 352: /* type_specifier_nonarray: F64MAT3  */
+#line 2562 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 9202 "MachineIndependent/glslang_tab.cpp"
+#line 9256 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 351: /* type_specifier_nonarray: F64MAT4  */
-#line 2554 "MachineIndependent/glslang.y"
+  case 353: /* type_specifier_nonarray: F64MAT4  */
+#line 2568 "MachineIndependent/glslang.y"
               {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 9213 "MachineIndependent/glslang_tab.cpp"
+#line 9267 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 352: /* type_specifier_nonarray: F64MAT2X2  */
-#line 2560 "MachineIndependent/glslang.y"
+  case 354: /* type_specifier_nonarray: F64MAT2X2  */
+#line 2574 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 9224 "MachineIndependent/glslang_tab.cpp"
+#line 9278 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 353: /* type_specifier_nonarray: F64MAT2X3  */
-#line 2566 "MachineIndependent/glslang.y"
+  case 355: /* type_specifier_nonarray: F64MAT2X3  */
+#line 2580 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 9235 "MachineIndependent/glslang_tab.cpp"
+#line 9289 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 354: /* type_specifier_nonarray: F64MAT2X4  */
-#line 2572 "MachineIndependent/glslang.y"
+  case 356: /* type_specifier_nonarray: F64MAT2X4  */
+#line 2586 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 9246 "MachineIndependent/glslang_tab.cpp"
+#line 9300 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 355: /* type_specifier_nonarray: F64MAT3X2  */
-#line 2578 "MachineIndependent/glslang.y"
+  case 357: /* type_specifier_nonarray: F64MAT3X2  */
+#line 2592 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 9257 "MachineIndependent/glslang_tab.cpp"
+#line 9311 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 356: /* type_specifier_nonarray: F64MAT3X3  */
-#line 2584 "MachineIndependent/glslang.y"
+  case 358: /* type_specifier_nonarray: F64MAT3X3  */
+#line 2598 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 9268 "MachineIndependent/glslang_tab.cpp"
+#line 9322 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 357: /* type_specifier_nonarray: F64MAT3X4  */
-#line 2590 "MachineIndependent/glslang.y"
+  case 359: /* type_specifier_nonarray: F64MAT3X4  */
+#line 2604 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 9279 "MachineIndependent/glslang_tab.cpp"
+#line 9333 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 358: /* type_specifier_nonarray: F64MAT4X2  */
-#line 2596 "MachineIndependent/glslang.y"
+  case 360: /* type_specifier_nonarray: F64MAT4X2  */
+#line 2610 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 9290 "MachineIndependent/glslang_tab.cpp"
+#line 9344 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 359: /* type_specifier_nonarray: F64MAT4X3  */
-#line 2602 "MachineIndependent/glslang.y"
+  case 361: /* type_specifier_nonarray: F64MAT4X3  */
+#line 2616 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 9301 "MachineIndependent/glslang_tab.cpp"
+#line 9355 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 360: /* type_specifier_nonarray: F64MAT4X4  */
-#line 2608 "MachineIndependent/glslang.y"
+  case 362: /* type_specifier_nonarray: F64MAT4X4  */
+#line 2622 "MachineIndependent/glslang.y"
                 {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 9312 "MachineIndependent/glslang_tab.cpp"
+#line 9366 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 361: /* type_specifier_nonarray: ACCSTRUCTNV  */
-#line 2614 "MachineIndependent/glslang.y"
+  case 363: /* type_specifier_nonarray: ACCSTRUCTNV  */
+#line 2628 "MachineIndependent/glslang.y"
                   {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 9321 "MachineIndependent/glslang_tab.cpp"
+#line 9375 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 362: /* type_specifier_nonarray: ACCSTRUCTEXT  */
-#line 2618 "MachineIndependent/glslang.y"
+  case 364: /* type_specifier_nonarray: ACCSTRUCTEXT  */
+#line 2632 "MachineIndependent/glslang.y"
                    {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 9330 "MachineIndependent/glslang_tab.cpp"
+#line 9384 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 363: /* type_specifier_nonarray: RAYQUERYEXT  */
-#line 2622 "MachineIndependent/glslang.y"
+  case 365: /* type_specifier_nonarray: RAYQUERYEXT  */
+#line 2636 "MachineIndependent/glslang.y"
                   {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtRayQuery;
     }
-#line 9339 "MachineIndependent/glslang_tab.cpp"
+#line 9393 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 364: /* type_specifier_nonarray: ATOMIC_UINT  */
-#line 2626 "MachineIndependent/glslang.y"
+  case 366: /* type_specifier_nonarray: ATOMIC_UINT  */
+#line 2640 "MachineIndependent/glslang.y"
                   {
         parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtAtomicUint;
     }
-#line 9349 "MachineIndependent/glslang_tab.cpp"
+#line 9403 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 365: /* type_specifier_nonarray: SAMPLER1D  */
-#line 2631 "MachineIndependent/glslang.y"
+  case 367: /* type_specifier_nonarray: SAMPLER1D  */
+#line 2645 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
     }
-#line 9359 "MachineIndependent/glslang_tab.cpp"
+#line 9413 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 366: /* type_specifier_nonarray: SAMPLER2D  */
-#line 2636 "MachineIndependent/glslang.y"
+  case 368: /* type_specifier_nonarray: SAMPLER2D  */
+#line 2650 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
     }
-#line 9369 "MachineIndependent/glslang_tab.cpp"
+#line 9423 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 367: /* type_specifier_nonarray: SAMPLER3D  */
-#line 2641 "MachineIndependent/glslang.y"
+  case 369: /* type_specifier_nonarray: SAMPLER3D  */
+#line 2655 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
     }
-#line 9379 "MachineIndependent/glslang_tab.cpp"
+#line 9433 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 368: /* type_specifier_nonarray: SAMPLERCUBE  */
-#line 2646 "MachineIndependent/glslang.y"
+  case 370: /* type_specifier_nonarray: SAMPLERCUBE  */
+#line 2660 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
     }
-#line 9389 "MachineIndependent/glslang_tab.cpp"
+#line 9443 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 369: /* type_specifier_nonarray: SAMPLER2DSHADOW  */
-#line 2651 "MachineIndependent/glslang.y"
+  case 371: /* type_specifier_nonarray: SAMPLER2DSHADOW  */
+#line 2665 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
     }
-#line 9399 "MachineIndependent/glslang_tab.cpp"
+#line 9453 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 370: /* type_specifier_nonarray: SAMPLERCUBESHADOW  */
-#line 2656 "MachineIndependent/glslang.y"
+  case 372: /* type_specifier_nonarray: SAMPLERCUBESHADOW  */
+#line 2670 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
     }
-#line 9409 "MachineIndependent/glslang_tab.cpp"
+#line 9463 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 371: /* type_specifier_nonarray: SAMPLER2DARRAY  */
-#line 2661 "MachineIndependent/glslang.y"
+  case 373: /* type_specifier_nonarray: SAMPLER2DARRAY  */
+#line 2675 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
     }
-#line 9419 "MachineIndependent/glslang_tab.cpp"
+#line 9473 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 372: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW  */
-#line 2666 "MachineIndependent/glslang.y"
+  case 374: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW  */
+#line 2680 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
     }
-#line 9429 "MachineIndependent/glslang_tab.cpp"
+#line 9483 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 373: /* type_specifier_nonarray: SAMPLER1DSHADOW  */
-#line 2671 "MachineIndependent/glslang.y"
+  case 375: /* type_specifier_nonarray: SAMPLER1DSHADOW  */
+#line 2685 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
     }
-#line 9439 "MachineIndependent/glslang_tab.cpp"
+#line 9493 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 374: /* type_specifier_nonarray: SAMPLER1DARRAY  */
-#line 2676 "MachineIndependent/glslang.y"
+  case 376: /* type_specifier_nonarray: SAMPLER1DARRAY  */
+#line 2690 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
     }
-#line 9449 "MachineIndependent/glslang_tab.cpp"
+#line 9503 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 375: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW  */
-#line 2681 "MachineIndependent/glslang.y"
+  case 377: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW  */
+#line 2695 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
     }
-#line 9459 "MachineIndependent/glslang_tab.cpp"
+#line 9513 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 376: /* type_specifier_nonarray: SAMPLERCUBEARRAY  */
-#line 2686 "MachineIndependent/glslang.y"
+  case 378: /* type_specifier_nonarray: SAMPLERCUBEARRAY  */
+#line 2700 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
     }
-#line 9469 "MachineIndependent/glslang_tab.cpp"
+#line 9523 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 377: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW  */
-#line 2691 "MachineIndependent/glslang.y"
+  case 379: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW  */
+#line 2705 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
     }
-#line 9479 "MachineIndependent/glslang_tab.cpp"
+#line 9533 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 378: /* type_specifier_nonarray: F16SAMPLER1D  */
-#line 2696 "MachineIndependent/glslang.y"
+  case 380: /* type_specifier_nonarray: F16SAMPLER1D  */
+#line 2710 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
     }
-#line 9490 "MachineIndependent/glslang_tab.cpp"
+#line 9544 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 379: /* type_specifier_nonarray: F16SAMPLER2D  */
-#line 2702 "MachineIndependent/glslang.y"
+  case 381: /* type_specifier_nonarray: F16SAMPLER2D  */
+#line 2716 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
     }
-#line 9501 "MachineIndependent/glslang_tab.cpp"
+#line 9555 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 380: /* type_specifier_nonarray: F16SAMPLER3D  */
-#line 2708 "MachineIndependent/glslang.y"
+  case 382: /* type_specifier_nonarray: F16SAMPLER3D  */
+#line 2722 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
     }
-#line 9512 "MachineIndependent/glslang_tab.cpp"
+#line 9566 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 381: /* type_specifier_nonarray: F16SAMPLERCUBE  */
-#line 2714 "MachineIndependent/glslang.y"
+  case 383: /* type_specifier_nonarray: F16SAMPLERCUBE  */
+#line 2728 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
     }
-#line 9523 "MachineIndependent/glslang_tab.cpp"
+#line 9577 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 382: /* type_specifier_nonarray: F16SAMPLER1DSHADOW  */
-#line 2720 "MachineIndependent/glslang.y"
+  case 384: /* type_specifier_nonarray: F16SAMPLER1DSHADOW  */
+#line 2734 "MachineIndependent/glslang.y"
                          {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
     }
-#line 9534 "MachineIndependent/glslang_tab.cpp"
+#line 9588 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 383: /* type_specifier_nonarray: F16SAMPLER2DSHADOW  */
-#line 2726 "MachineIndependent/glslang.y"
+  case 385: /* type_specifier_nonarray: F16SAMPLER2DSHADOW  */
+#line 2740 "MachineIndependent/glslang.y"
                          {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
     }
-#line 9545 "MachineIndependent/glslang_tab.cpp"
+#line 9599 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 384: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW  */
-#line 2732 "MachineIndependent/glslang.y"
+  case 386: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW  */
+#line 2746 "MachineIndependent/glslang.y"
                            {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
     }
-#line 9556 "MachineIndependent/glslang_tab.cpp"
+#line 9610 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 385: /* type_specifier_nonarray: F16SAMPLER1DARRAY  */
-#line 2738 "MachineIndependent/glslang.y"
+  case 387: /* type_specifier_nonarray: F16SAMPLER1DARRAY  */
+#line 2752 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
     }
-#line 9567 "MachineIndependent/glslang_tab.cpp"
+#line 9621 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 386: /* type_specifier_nonarray: F16SAMPLER2DARRAY  */
-#line 2744 "MachineIndependent/glslang.y"
+  case 388: /* type_specifier_nonarray: F16SAMPLER2DARRAY  */
+#line 2758 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
     }
-#line 9578 "MachineIndependent/glslang_tab.cpp"
+#line 9632 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 387: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW  */
-#line 2750 "MachineIndependent/glslang.y"
+  case 389: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW  */
+#line 2764 "MachineIndependent/glslang.y"
                               {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
     }
-#line 9589 "MachineIndependent/glslang_tab.cpp"
+#line 9643 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 388: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW  */
-#line 2756 "MachineIndependent/glslang.y"
+  case 390: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW  */
+#line 2770 "MachineIndependent/glslang.y"
                               {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
     }
-#line 9600 "MachineIndependent/glslang_tab.cpp"
+#line 9654 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 389: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY  */
-#line 2762 "MachineIndependent/glslang.y"
+  case 391: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY  */
+#line 2776 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
     }
-#line 9611 "MachineIndependent/glslang_tab.cpp"
+#line 9665 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 390: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW  */
-#line 2768 "MachineIndependent/glslang.y"
+  case 392: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW  */
+#line 2782 "MachineIndependent/glslang.y"
                                 {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
     }
-#line 9622 "MachineIndependent/glslang_tab.cpp"
+#line 9676 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 391: /* type_specifier_nonarray: ISAMPLER1D  */
-#line 2774 "MachineIndependent/glslang.y"
+  case 393: /* type_specifier_nonarray: ISAMPLER1D  */
+#line 2788 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D);
     }
-#line 9632 "MachineIndependent/glslang_tab.cpp"
+#line 9686 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 392: /* type_specifier_nonarray: ISAMPLER2D  */
-#line 2779 "MachineIndependent/glslang.y"
+  case 394: /* type_specifier_nonarray: ISAMPLER2D  */
+#line 2793 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D);
     }
-#line 9642 "MachineIndependent/glslang_tab.cpp"
+#line 9696 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 393: /* type_specifier_nonarray: ISAMPLER3D  */
-#line 2784 "MachineIndependent/glslang.y"
+  case 395: /* type_specifier_nonarray: ISAMPLER3D  */
+#line 2798 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd3D);
     }
-#line 9652 "MachineIndependent/glslang_tab.cpp"
+#line 9706 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 394: /* type_specifier_nonarray: ISAMPLERCUBE  */
-#line 2789 "MachineIndependent/glslang.y"
+  case 396: /* type_specifier_nonarray: ISAMPLERCUBE  */
+#line 2803 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube);
     }
-#line 9662 "MachineIndependent/glslang_tab.cpp"
+#line 9716 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 395: /* type_specifier_nonarray: ISAMPLER2DARRAY  */
-#line 2794 "MachineIndependent/glslang.y"
+  case 397: /* type_specifier_nonarray: ISAMPLER2DARRAY  */
+#line 2808 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
     }
-#line 9672 "MachineIndependent/glslang_tab.cpp"
+#line 9726 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 396: /* type_specifier_nonarray: USAMPLER2D  */
-#line 2799 "MachineIndependent/glslang.y"
+  case 398: /* type_specifier_nonarray: USAMPLER2D  */
+#line 2813 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D);
     }
-#line 9682 "MachineIndependent/glslang_tab.cpp"
+#line 9736 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 397: /* type_specifier_nonarray: USAMPLER3D  */
-#line 2804 "MachineIndependent/glslang.y"
+  case 399: /* type_specifier_nonarray: USAMPLER3D  */
+#line 2818 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd3D);
     }
-#line 9692 "MachineIndependent/glslang_tab.cpp"
+#line 9746 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 398: /* type_specifier_nonarray: USAMPLERCUBE  */
-#line 2809 "MachineIndependent/glslang.y"
+  case 400: /* type_specifier_nonarray: USAMPLERCUBE  */
+#line 2823 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube);
     }
-#line 9702 "MachineIndependent/glslang_tab.cpp"
+#line 9756 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 399: /* type_specifier_nonarray: ISAMPLER1DARRAY  */
-#line 2814 "MachineIndependent/glslang.y"
+  case 401: /* type_specifier_nonarray: ISAMPLER1DARRAY  */
+#line 2828 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
     }
-#line 9712 "MachineIndependent/glslang_tab.cpp"
+#line 9766 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 400: /* type_specifier_nonarray: ISAMPLERCUBEARRAY  */
-#line 2819 "MachineIndependent/glslang.y"
+  case 402: /* type_specifier_nonarray: ISAMPLERCUBEARRAY  */
+#line 2833 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
     }
-#line 9722 "MachineIndependent/glslang_tab.cpp"
+#line 9776 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 401: /* type_specifier_nonarray: USAMPLER1D  */
-#line 2824 "MachineIndependent/glslang.y"
+  case 403: /* type_specifier_nonarray: USAMPLER1D  */
+#line 2838 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D);
     }
-#line 9732 "MachineIndependent/glslang_tab.cpp"
+#line 9786 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 402: /* type_specifier_nonarray: USAMPLER1DARRAY  */
-#line 2829 "MachineIndependent/glslang.y"
+  case 404: /* type_specifier_nonarray: USAMPLER1DARRAY  */
+#line 2843 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
     }
-#line 9742 "MachineIndependent/glslang_tab.cpp"
+#line 9796 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 403: /* type_specifier_nonarray: USAMPLERCUBEARRAY  */
-#line 2834 "MachineIndependent/glslang.y"
+  case 405: /* type_specifier_nonarray: USAMPLERCUBEARRAY  */
+#line 2848 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
     }
-#line 9752 "MachineIndependent/glslang_tab.cpp"
+#line 9806 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 404: /* type_specifier_nonarray: TEXTURECUBEARRAY  */
-#line 2839 "MachineIndependent/glslang.y"
+  case 406: /* type_specifier_nonarray: TEXTURECUBEARRAY  */
+#line 2853 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
     }
-#line 9762 "MachineIndependent/glslang_tab.cpp"
+#line 9816 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 405: /* type_specifier_nonarray: ITEXTURECUBEARRAY  */
-#line 2844 "MachineIndependent/glslang.y"
+  case 407: /* type_specifier_nonarray: ITEXTURECUBEARRAY  */
+#line 2858 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true);
     }
-#line 9772 "MachineIndependent/glslang_tab.cpp"
+#line 9826 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 406: /* type_specifier_nonarray: UTEXTURECUBEARRAY  */
-#line 2849 "MachineIndependent/glslang.y"
+  case 408: /* type_specifier_nonarray: UTEXTURECUBEARRAY  */
+#line 2863 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
     }
-#line 9782 "MachineIndependent/glslang_tab.cpp"
+#line 9836 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 407: /* type_specifier_nonarray: USAMPLER2DARRAY  */
-#line 2854 "MachineIndependent/glslang.y"
+  case 409: /* type_specifier_nonarray: USAMPLER2DARRAY  */
+#line 2868 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
     }
-#line 9792 "MachineIndependent/glslang_tab.cpp"
+#line 9846 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 408: /* type_specifier_nonarray: TEXTURE2D  */
-#line 2859 "MachineIndependent/glslang.y"
+  case 410: /* type_specifier_nonarray: TEXTURE2D  */
+#line 2873 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
     }
-#line 9802 "MachineIndependent/glslang_tab.cpp"
+#line 9856 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 409: /* type_specifier_nonarray: TEXTURE3D  */
-#line 2864 "MachineIndependent/glslang.y"
+  case 411: /* type_specifier_nonarray: TEXTURE3D  */
+#line 2878 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
     }
-#line 9812 "MachineIndependent/glslang_tab.cpp"
+#line 9866 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 410: /* type_specifier_nonarray: TEXTURE2DARRAY  */
-#line 2869 "MachineIndependent/glslang.y"
+  case 412: /* type_specifier_nonarray: TEXTURE2DARRAY  */
+#line 2883 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
     }
-#line 9822 "MachineIndependent/glslang_tab.cpp"
+#line 9876 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 411: /* type_specifier_nonarray: TEXTURECUBE  */
-#line 2874 "MachineIndependent/glslang.y"
+  case 413: /* type_specifier_nonarray: TEXTURECUBE  */
+#line 2888 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
     }
-#line 9832 "MachineIndependent/glslang_tab.cpp"
+#line 9886 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 412: /* type_specifier_nonarray: ITEXTURE2D  */
-#line 2879 "MachineIndependent/glslang.y"
+  case 414: /* type_specifier_nonarray: ITEXTURE2D  */
+#line 2893 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
     }
-#line 9842 "MachineIndependent/glslang_tab.cpp"
+#line 9896 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 413: /* type_specifier_nonarray: ITEXTURE3D  */
-#line 2884 "MachineIndependent/glslang.y"
+  case 415: /* type_specifier_nonarray: ITEXTURE3D  */
+#line 2898 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
     }
-#line 9852 "MachineIndependent/glslang_tab.cpp"
+#line 9906 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 414: /* type_specifier_nonarray: ITEXTURECUBE  */
-#line 2889 "MachineIndependent/glslang.y"
+  case 416: /* type_specifier_nonarray: ITEXTURECUBE  */
+#line 2903 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
     }
-#line 9862 "MachineIndependent/glslang_tab.cpp"
+#line 9916 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 415: /* type_specifier_nonarray: ITEXTURE2DARRAY  */
-#line 2894 "MachineIndependent/glslang.y"
+  case 417: /* type_specifier_nonarray: ITEXTURE2DARRAY  */
+#line 2908 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
     }
-#line 9872 "MachineIndependent/glslang_tab.cpp"
+#line 9926 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 416: /* type_specifier_nonarray: UTEXTURE2D  */
-#line 2899 "MachineIndependent/glslang.y"
+  case 418: /* type_specifier_nonarray: UTEXTURE2D  */
+#line 2913 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
     }
-#line 9882 "MachineIndependent/glslang_tab.cpp"
+#line 9936 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 417: /* type_specifier_nonarray: UTEXTURE3D  */
-#line 2904 "MachineIndependent/glslang.y"
+  case 419: /* type_specifier_nonarray: UTEXTURE3D  */
+#line 2918 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
     }
-#line 9892 "MachineIndependent/glslang_tab.cpp"
+#line 9946 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 418: /* type_specifier_nonarray: UTEXTURECUBE  */
-#line 2909 "MachineIndependent/glslang.y"
+  case 420: /* type_specifier_nonarray: UTEXTURECUBE  */
+#line 2923 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
     }
-#line 9902 "MachineIndependent/glslang_tab.cpp"
+#line 9956 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 419: /* type_specifier_nonarray: UTEXTURE2DARRAY  */
-#line 2914 "MachineIndependent/glslang.y"
+  case 421: /* type_specifier_nonarray: UTEXTURE2DARRAY  */
+#line 2928 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
     }
-#line 9912 "MachineIndependent/glslang_tab.cpp"
+#line 9966 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 420: /* type_specifier_nonarray: SAMPLER  */
-#line 2919 "MachineIndependent/glslang.y"
+  case 422: /* type_specifier_nonarray: SAMPLER  */
+#line 2933 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(false);
     }
-#line 9922 "MachineIndependent/glslang_tab.cpp"
+#line 9976 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 421: /* type_specifier_nonarray: SAMPLERSHADOW  */
-#line 2924 "MachineIndependent/glslang.y"
+  case 423: /* type_specifier_nonarray: SAMPLERSHADOW  */
+#line 2938 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(true);
     }
-#line 9932 "MachineIndependent/glslang_tab.cpp"
+#line 9986 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 422: /* type_specifier_nonarray: SAMPLER2DRECT  */
-#line 2929 "MachineIndependent/glslang.y"
+  case 424: /* type_specifier_nonarray: SAMPLER2DRECT  */
+#line 2943 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
     }
-#line 9942 "MachineIndependent/glslang_tab.cpp"
+#line 9996 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 423: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW  */
-#line 2934 "MachineIndependent/glslang.y"
+  case 425: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW  */
+#line 2948 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
     }
-#line 9952 "MachineIndependent/glslang_tab.cpp"
+#line 10006 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 424: /* type_specifier_nonarray: F16SAMPLER2DRECT  */
-#line 2939 "MachineIndependent/glslang.y"
+  case 426: /* type_specifier_nonarray: F16SAMPLER2DRECT  */
+#line 2953 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
     }
-#line 9963 "MachineIndependent/glslang_tab.cpp"
+#line 10017 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 425: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW  */
-#line 2945 "MachineIndependent/glslang.y"
+  case 427: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW  */
+#line 2959 "MachineIndependent/glslang.y"
                              {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
     }
-#line 9974 "MachineIndependent/glslang_tab.cpp"
+#line 10028 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 426: /* type_specifier_nonarray: ISAMPLER2DRECT  */
-#line 2951 "MachineIndependent/glslang.y"
+  case 428: /* type_specifier_nonarray: ISAMPLER2DRECT  */
+#line 2965 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdRect);
     }
-#line 9984 "MachineIndependent/glslang_tab.cpp"
+#line 10038 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 427: /* type_specifier_nonarray: USAMPLER2DRECT  */
-#line 2956 "MachineIndependent/glslang.y"
+  case 429: /* type_specifier_nonarray: USAMPLER2DRECT  */
+#line 2970 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdRect);
     }
-#line 9994 "MachineIndependent/glslang_tab.cpp"
+#line 10048 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 428: /* type_specifier_nonarray: SAMPLERBUFFER  */
-#line 2961 "MachineIndependent/glslang.y"
+  case 430: /* type_specifier_nonarray: SAMPLERBUFFER  */
+#line 2975 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
     }
-#line 10004 "MachineIndependent/glslang_tab.cpp"
+#line 10058 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 429: /* type_specifier_nonarray: F16SAMPLERBUFFER  */
-#line 2966 "MachineIndependent/glslang.y"
+  case 431: /* type_specifier_nonarray: F16SAMPLERBUFFER  */
+#line 2980 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
     }
-#line 10015 "MachineIndependent/glslang_tab.cpp"
+#line 10069 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 430: /* type_specifier_nonarray: ISAMPLERBUFFER  */
-#line 2972 "MachineIndependent/glslang.y"
+  case 432: /* type_specifier_nonarray: ISAMPLERBUFFER  */
+#line 2986 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
     }
-#line 10025 "MachineIndependent/glslang_tab.cpp"
+#line 10079 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 431: /* type_specifier_nonarray: USAMPLERBUFFER  */
-#line 2977 "MachineIndependent/glslang.y"
+  case 433: /* type_specifier_nonarray: USAMPLERBUFFER  */
+#line 2991 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
     }
-#line 10035 "MachineIndependent/glslang_tab.cpp"
+#line 10089 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 432: /* type_specifier_nonarray: SAMPLER2DMS  */
-#line 2982 "MachineIndependent/glslang.y"
+  case 434: /* type_specifier_nonarray: SAMPLER2DMS  */
+#line 2996 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
     }
-#line 10045 "MachineIndependent/glslang_tab.cpp"
+#line 10099 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 433: /* type_specifier_nonarray: F16SAMPLER2DMS  */
-#line 2987 "MachineIndependent/glslang.y"
+  case 435: /* type_specifier_nonarray: F16SAMPLER2DMS  */
+#line 3001 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
     }
-#line 10056 "MachineIndependent/glslang_tab.cpp"
+#line 10110 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 434: /* type_specifier_nonarray: ISAMPLER2DMS  */
-#line 2993 "MachineIndependent/glslang.y"
+  case 436: /* type_specifier_nonarray: ISAMPLER2DMS  */
+#line 3007 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
     }
-#line 10066 "MachineIndependent/glslang_tab.cpp"
+#line 10120 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 435: /* type_specifier_nonarray: USAMPLER2DMS  */
-#line 2998 "MachineIndependent/glslang.y"
+  case 437: /* type_specifier_nonarray: USAMPLER2DMS  */
+#line 3012 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
     }
-#line 10076 "MachineIndependent/glslang_tab.cpp"
+#line 10130 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 436: /* type_specifier_nonarray: SAMPLER2DMSARRAY  */
-#line 3003 "MachineIndependent/glslang.y"
+  case 438: /* type_specifier_nonarray: SAMPLER2DMSARRAY  */
+#line 3017 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
     }
-#line 10086 "MachineIndependent/glslang_tab.cpp"
+#line 10140 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 437: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY  */
-#line 3008 "MachineIndependent/glslang.y"
+  case 439: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY  */
+#line 3022 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
     }
-#line 10097 "MachineIndependent/glslang_tab.cpp"
+#line 10151 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 438: /* type_specifier_nonarray: ISAMPLER2DMSARRAY  */
-#line 3014 "MachineIndependent/glslang.y"
+  case 440: /* type_specifier_nonarray: ISAMPLER2DMSARRAY  */
+#line 3028 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
     }
-#line 10107 "MachineIndependent/glslang_tab.cpp"
+#line 10161 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 439: /* type_specifier_nonarray: USAMPLER2DMSARRAY  */
-#line 3019 "MachineIndependent/glslang.y"
+  case 441: /* type_specifier_nonarray: USAMPLER2DMSARRAY  */
+#line 3033 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
     }
-#line 10117 "MachineIndependent/glslang_tab.cpp"
+#line 10171 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 440: /* type_specifier_nonarray: TEXTURE1D  */
-#line 3024 "MachineIndependent/glslang.y"
+  case 442: /* type_specifier_nonarray: TEXTURE1D  */
+#line 3038 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
     }
-#line 10127 "MachineIndependent/glslang_tab.cpp"
+#line 10181 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 441: /* type_specifier_nonarray: F16TEXTURE1D  */
-#line 3029 "MachineIndependent/glslang.y"
+  case 443: /* type_specifier_nonarray: F16TEXTURE1D  */
+#line 3043 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
     }
-#line 10138 "MachineIndependent/glslang_tab.cpp"
+#line 10192 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 442: /* type_specifier_nonarray: F16TEXTURE2D  */
-#line 3035 "MachineIndependent/glslang.y"
+  case 444: /* type_specifier_nonarray: F16TEXTURE2D  */
+#line 3049 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
     }
-#line 10149 "MachineIndependent/glslang_tab.cpp"
+#line 10203 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 443: /* type_specifier_nonarray: F16TEXTURE3D  */
-#line 3041 "MachineIndependent/glslang.y"
+  case 445: /* type_specifier_nonarray: F16TEXTURE3D  */
+#line 3055 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
     }
-#line 10160 "MachineIndependent/glslang_tab.cpp"
+#line 10214 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 444: /* type_specifier_nonarray: F16TEXTURECUBE  */
-#line 3047 "MachineIndependent/glslang.y"
+  case 446: /* type_specifier_nonarray: F16TEXTURECUBE  */
+#line 3061 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
     }
-#line 10171 "MachineIndependent/glslang_tab.cpp"
+#line 10225 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 445: /* type_specifier_nonarray: TEXTURE1DARRAY  */
-#line 3053 "MachineIndependent/glslang.y"
+  case 447: /* type_specifier_nonarray: TEXTURE1DARRAY  */
+#line 3067 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
     }
-#line 10181 "MachineIndependent/glslang_tab.cpp"
+#line 10235 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 446: /* type_specifier_nonarray: F16TEXTURE1DARRAY  */
-#line 3058 "MachineIndependent/glslang.y"
+  case 448: /* type_specifier_nonarray: F16TEXTURE1DARRAY  */
+#line 3072 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
     }
-#line 10192 "MachineIndependent/glslang_tab.cpp"
+#line 10246 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 447: /* type_specifier_nonarray: F16TEXTURE2DARRAY  */
-#line 3064 "MachineIndependent/glslang.y"
+  case 449: /* type_specifier_nonarray: F16TEXTURE2DARRAY  */
+#line 3078 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
     }
-#line 10203 "MachineIndependent/glslang_tab.cpp"
+#line 10257 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 448: /* type_specifier_nonarray: F16TEXTURECUBEARRAY  */
-#line 3070 "MachineIndependent/glslang.y"
+  case 450: /* type_specifier_nonarray: F16TEXTURECUBEARRAY  */
+#line 3084 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
     }
-#line 10214 "MachineIndependent/glslang_tab.cpp"
+#line 10268 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 449: /* type_specifier_nonarray: ITEXTURE1D  */
-#line 3076 "MachineIndependent/glslang.y"
+  case 451: /* type_specifier_nonarray: ITEXTURE1D  */
+#line 3090 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
     }
-#line 10224 "MachineIndependent/glslang_tab.cpp"
+#line 10278 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 450: /* type_specifier_nonarray: ITEXTURE1DARRAY  */
-#line 3081 "MachineIndependent/glslang.y"
+  case 452: /* type_specifier_nonarray: ITEXTURE1DARRAY  */
+#line 3095 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
     }
-#line 10234 "MachineIndependent/glslang_tab.cpp"
+#line 10288 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 451: /* type_specifier_nonarray: UTEXTURE1D  */
-#line 3086 "MachineIndependent/glslang.y"
+  case 453: /* type_specifier_nonarray: UTEXTURE1D  */
+#line 3100 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
     }
-#line 10244 "MachineIndependent/glslang_tab.cpp"
+#line 10298 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 452: /* type_specifier_nonarray: UTEXTURE1DARRAY  */
-#line 3091 "MachineIndependent/glslang.y"
+  case 454: /* type_specifier_nonarray: UTEXTURE1DARRAY  */
+#line 3105 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
     }
-#line 10254 "MachineIndependent/glslang_tab.cpp"
+#line 10308 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 453: /* type_specifier_nonarray: TEXTURE2DRECT  */
-#line 3096 "MachineIndependent/glslang.y"
+  case 455: /* type_specifier_nonarray: TEXTURE2DRECT  */
+#line 3110 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
     }
-#line 10264 "MachineIndependent/glslang_tab.cpp"
+#line 10318 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 454: /* type_specifier_nonarray: F16TEXTURE2DRECT  */
-#line 3101 "MachineIndependent/glslang.y"
+  case 456: /* type_specifier_nonarray: F16TEXTURE2DRECT  */
+#line 3115 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
     }
-#line 10275 "MachineIndependent/glslang_tab.cpp"
+#line 10329 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 455: /* type_specifier_nonarray: ITEXTURE2DRECT  */
-#line 3107 "MachineIndependent/glslang.y"
+  case 457: /* type_specifier_nonarray: ITEXTURE2DRECT  */
+#line 3121 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
     }
-#line 10285 "MachineIndependent/glslang_tab.cpp"
+#line 10339 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 456: /* type_specifier_nonarray: UTEXTURE2DRECT  */
-#line 3112 "MachineIndependent/glslang.y"
+  case 458: /* type_specifier_nonarray: UTEXTURE2DRECT  */
+#line 3126 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
     }
-#line 10295 "MachineIndependent/glslang_tab.cpp"
+#line 10349 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 457: /* type_specifier_nonarray: TEXTUREBUFFER  */
-#line 3117 "MachineIndependent/glslang.y"
+  case 459: /* type_specifier_nonarray: TEXTUREBUFFER  */
+#line 3131 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
     }
-#line 10305 "MachineIndependent/glslang_tab.cpp"
+#line 10359 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 458: /* type_specifier_nonarray: F16TEXTUREBUFFER  */
-#line 3122 "MachineIndependent/glslang.y"
+  case 460: /* type_specifier_nonarray: F16TEXTUREBUFFER  */
+#line 3136 "MachineIndependent/glslang.y"
                        {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
     }
-#line 10316 "MachineIndependent/glslang_tab.cpp"
+#line 10370 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 459: /* type_specifier_nonarray: ITEXTUREBUFFER  */
-#line 3128 "MachineIndependent/glslang.y"
+  case 461: /* type_specifier_nonarray: ITEXTUREBUFFER  */
+#line 3142 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
     }
-#line 10326 "MachineIndependent/glslang_tab.cpp"
+#line 10380 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 460: /* type_specifier_nonarray: UTEXTUREBUFFER  */
-#line 3133 "MachineIndependent/glslang.y"
+  case 462: /* type_specifier_nonarray: UTEXTUREBUFFER  */
+#line 3147 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
     }
-#line 10336 "MachineIndependent/glslang_tab.cpp"
+#line 10390 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 461: /* type_specifier_nonarray: TEXTURE2DMS  */
-#line 3138 "MachineIndependent/glslang.y"
+  case 463: /* type_specifier_nonarray: TEXTURE2DMS  */
+#line 3152 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
     }
-#line 10346 "MachineIndependent/glslang_tab.cpp"
+#line 10400 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 462: /* type_specifier_nonarray: F16TEXTURE2DMS  */
-#line 3143 "MachineIndependent/glslang.y"
+  case 464: /* type_specifier_nonarray: F16TEXTURE2DMS  */
+#line 3157 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
     }
-#line 10357 "MachineIndependent/glslang_tab.cpp"
+#line 10411 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 463: /* type_specifier_nonarray: ITEXTURE2DMS  */
-#line 3149 "MachineIndependent/glslang.y"
+  case 465: /* type_specifier_nonarray: ITEXTURE2DMS  */
+#line 3163 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
     }
-#line 10367 "MachineIndependent/glslang_tab.cpp"
+#line 10421 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 464: /* type_specifier_nonarray: UTEXTURE2DMS  */
-#line 3154 "MachineIndependent/glslang.y"
+  case 466: /* type_specifier_nonarray: UTEXTURE2DMS  */
+#line 3168 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
     }
-#line 10377 "MachineIndependent/glslang_tab.cpp"
+#line 10431 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 465: /* type_specifier_nonarray: TEXTURE2DMSARRAY  */
-#line 3159 "MachineIndependent/glslang.y"
+  case 467: /* type_specifier_nonarray: TEXTURE2DMSARRAY  */
+#line 3173 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
     }
-#line 10387 "MachineIndependent/glslang_tab.cpp"
+#line 10441 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 466: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY  */
-#line 3164 "MachineIndependent/glslang.y"
+  case 468: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY  */
+#line 3178 "MachineIndependent/glslang.y"
                           {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
     }
-#line 10398 "MachineIndependent/glslang_tab.cpp"
+#line 10452 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 467: /* type_specifier_nonarray: ITEXTURE2DMSARRAY  */
-#line 3170 "MachineIndependent/glslang.y"
+  case 469: /* type_specifier_nonarray: ITEXTURE2DMSARRAY  */
+#line 3184 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
     }
-#line 10408 "MachineIndependent/glslang_tab.cpp"
+#line 10462 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 468: /* type_specifier_nonarray: UTEXTURE2DMSARRAY  */
-#line 3175 "MachineIndependent/glslang.y"
+  case 470: /* type_specifier_nonarray: UTEXTURE2DMSARRAY  */
+#line 3189 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
     }
-#line 10418 "MachineIndependent/glslang_tab.cpp"
+#line 10472 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 469: /* type_specifier_nonarray: IMAGE1D  */
-#line 3180 "MachineIndependent/glslang.y"
+  case 471: /* type_specifier_nonarray: IMAGE1D  */
+#line 3194 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
     }
-#line 10428 "MachineIndependent/glslang_tab.cpp"
+#line 10482 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 470: /* type_specifier_nonarray: F16IMAGE1D  */
-#line 3185 "MachineIndependent/glslang.y"
+  case 472: /* type_specifier_nonarray: F16IMAGE1D  */
+#line 3199 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
     }
-#line 10439 "MachineIndependent/glslang_tab.cpp"
+#line 10493 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 471: /* type_specifier_nonarray: IIMAGE1D  */
-#line 3191 "MachineIndependent/glslang.y"
+  case 473: /* type_specifier_nonarray: IIMAGE1D  */
+#line 3205 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
     }
-#line 10449 "MachineIndependent/glslang_tab.cpp"
+#line 10503 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 472: /* type_specifier_nonarray: UIMAGE1D  */
-#line 3196 "MachineIndependent/glslang.y"
+  case 474: /* type_specifier_nonarray: UIMAGE1D  */
+#line 3210 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
     }
-#line 10459 "MachineIndependent/glslang_tab.cpp"
+#line 10513 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 473: /* type_specifier_nonarray: IMAGE2D  */
-#line 3201 "MachineIndependent/glslang.y"
+  case 475: /* type_specifier_nonarray: IMAGE2D  */
+#line 3215 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
     }
-#line 10469 "MachineIndependent/glslang_tab.cpp"
+#line 10523 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 474: /* type_specifier_nonarray: F16IMAGE2D  */
-#line 3206 "MachineIndependent/glslang.y"
+  case 476: /* type_specifier_nonarray: F16IMAGE2D  */
+#line 3220 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
     }
-#line 10480 "MachineIndependent/glslang_tab.cpp"
+#line 10534 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 475: /* type_specifier_nonarray: IIMAGE2D  */
-#line 3212 "MachineIndependent/glslang.y"
+  case 477: /* type_specifier_nonarray: IIMAGE2D  */
+#line 3226 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
     }
-#line 10490 "MachineIndependent/glslang_tab.cpp"
+#line 10544 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 476: /* type_specifier_nonarray: UIMAGE2D  */
-#line 3217 "MachineIndependent/glslang.y"
+  case 478: /* type_specifier_nonarray: UIMAGE2D  */
+#line 3231 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
     }
-#line 10500 "MachineIndependent/glslang_tab.cpp"
+#line 10554 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 477: /* type_specifier_nonarray: IMAGE3D  */
-#line 3222 "MachineIndependent/glslang.y"
+  case 479: /* type_specifier_nonarray: IMAGE3D  */
+#line 3236 "MachineIndependent/glslang.y"
               {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
     }
-#line 10510 "MachineIndependent/glslang_tab.cpp"
+#line 10564 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 478: /* type_specifier_nonarray: F16IMAGE3D  */
-#line 3227 "MachineIndependent/glslang.y"
+  case 480: /* type_specifier_nonarray: F16IMAGE3D  */
+#line 3241 "MachineIndependent/glslang.y"
                  {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
     }
-#line 10521 "MachineIndependent/glslang_tab.cpp"
+#line 10575 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 479: /* type_specifier_nonarray: IIMAGE3D  */
-#line 3233 "MachineIndependent/glslang.y"
+  case 481: /* type_specifier_nonarray: IIMAGE3D  */
+#line 3247 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
     }
-#line 10531 "MachineIndependent/glslang_tab.cpp"
+#line 10585 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 480: /* type_specifier_nonarray: UIMAGE3D  */
-#line 3238 "MachineIndependent/glslang.y"
+  case 482: /* type_specifier_nonarray: UIMAGE3D  */
+#line 3252 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
     }
-#line 10541 "MachineIndependent/glslang_tab.cpp"
+#line 10595 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 481: /* type_specifier_nonarray: IMAGE2DRECT  */
-#line 3243 "MachineIndependent/glslang.y"
+  case 483: /* type_specifier_nonarray: IMAGE2DRECT  */
+#line 3257 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
     }
-#line 10551 "MachineIndependent/glslang_tab.cpp"
+#line 10605 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 482: /* type_specifier_nonarray: F16IMAGE2DRECT  */
-#line 3248 "MachineIndependent/glslang.y"
+  case 484: /* type_specifier_nonarray: F16IMAGE2DRECT  */
+#line 3262 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
     }
-#line 10562 "MachineIndependent/glslang_tab.cpp"
+#line 10616 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 483: /* type_specifier_nonarray: IIMAGE2DRECT  */
-#line 3254 "MachineIndependent/glslang.y"
+  case 485: /* type_specifier_nonarray: IIMAGE2DRECT  */
+#line 3268 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
     }
-#line 10572 "MachineIndependent/glslang_tab.cpp"
+#line 10626 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 484: /* type_specifier_nonarray: UIMAGE2DRECT  */
-#line 3259 "MachineIndependent/glslang.y"
+  case 486: /* type_specifier_nonarray: UIMAGE2DRECT  */
+#line 3273 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
     }
-#line 10582 "MachineIndependent/glslang_tab.cpp"
+#line 10636 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 485: /* type_specifier_nonarray: IMAGECUBE  */
-#line 3264 "MachineIndependent/glslang.y"
+  case 487: /* type_specifier_nonarray: IMAGECUBE  */
+#line 3278 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
     }
-#line 10592 "MachineIndependent/glslang_tab.cpp"
+#line 10646 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 486: /* type_specifier_nonarray: F16IMAGECUBE  */
-#line 3269 "MachineIndependent/glslang.y"
+  case 488: /* type_specifier_nonarray: F16IMAGECUBE  */
+#line 3283 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
     }
-#line 10603 "MachineIndependent/glslang_tab.cpp"
+#line 10657 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 487: /* type_specifier_nonarray: IIMAGECUBE  */
-#line 3275 "MachineIndependent/glslang.y"
+  case 489: /* type_specifier_nonarray: IIMAGECUBE  */
+#line 3289 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
     }
-#line 10613 "MachineIndependent/glslang_tab.cpp"
+#line 10667 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 488: /* type_specifier_nonarray: UIMAGECUBE  */
-#line 3280 "MachineIndependent/glslang.y"
+  case 490: /* type_specifier_nonarray: UIMAGECUBE  */
+#line 3294 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
     }
-#line 10623 "MachineIndependent/glslang_tab.cpp"
+#line 10677 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 489: /* type_specifier_nonarray: IMAGEBUFFER  */
-#line 3285 "MachineIndependent/glslang.y"
+  case 491: /* type_specifier_nonarray: IMAGEBUFFER  */
+#line 3299 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
     }
-#line 10633 "MachineIndependent/glslang_tab.cpp"
+#line 10687 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 490: /* type_specifier_nonarray: F16IMAGEBUFFER  */
-#line 3290 "MachineIndependent/glslang.y"
+  case 492: /* type_specifier_nonarray: F16IMAGEBUFFER  */
+#line 3304 "MachineIndependent/glslang.y"
                      {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
     }
-#line 10644 "MachineIndependent/glslang_tab.cpp"
+#line 10698 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 491: /* type_specifier_nonarray: IIMAGEBUFFER  */
-#line 3296 "MachineIndependent/glslang.y"
+  case 493: /* type_specifier_nonarray: IIMAGEBUFFER  */
+#line 3310 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
     }
-#line 10654 "MachineIndependent/glslang_tab.cpp"
+#line 10708 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 492: /* type_specifier_nonarray: UIMAGEBUFFER  */
-#line 3301 "MachineIndependent/glslang.y"
+  case 494: /* type_specifier_nonarray: UIMAGEBUFFER  */
+#line 3315 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
     }
-#line 10664 "MachineIndependent/glslang_tab.cpp"
+#line 10718 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 493: /* type_specifier_nonarray: IMAGE1DARRAY  */
-#line 3306 "MachineIndependent/glslang.y"
+  case 495: /* type_specifier_nonarray: IMAGE1DARRAY  */
+#line 3320 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
     }
-#line 10674 "MachineIndependent/glslang_tab.cpp"
+#line 10728 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 494: /* type_specifier_nonarray: F16IMAGE1DARRAY  */
-#line 3311 "MachineIndependent/glslang.y"
+  case 496: /* type_specifier_nonarray: F16IMAGE1DARRAY  */
+#line 3325 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
     }
-#line 10685 "MachineIndependent/glslang_tab.cpp"
+#line 10739 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 495: /* type_specifier_nonarray: IIMAGE1DARRAY  */
-#line 3317 "MachineIndependent/glslang.y"
+  case 497: /* type_specifier_nonarray: IIMAGE1DARRAY  */
+#line 3331 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
     }
-#line 10695 "MachineIndependent/glslang_tab.cpp"
+#line 10749 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 496: /* type_specifier_nonarray: UIMAGE1DARRAY  */
-#line 3322 "MachineIndependent/glslang.y"
+  case 498: /* type_specifier_nonarray: UIMAGE1DARRAY  */
+#line 3336 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
     }
-#line 10705 "MachineIndependent/glslang_tab.cpp"
+#line 10759 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 497: /* type_specifier_nonarray: IMAGE2DARRAY  */
-#line 3327 "MachineIndependent/glslang.y"
+  case 499: /* type_specifier_nonarray: IMAGE2DARRAY  */
+#line 3341 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
     }
-#line 10715 "MachineIndependent/glslang_tab.cpp"
+#line 10769 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 498: /* type_specifier_nonarray: F16IMAGE2DARRAY  */
-#line 3332 "MachineIndependent/glslang.y"
+  case 500: /* type_specifier_nonarray: F16IMAGE2DARRAY  */
+#line 3346 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
     }
-#line 10726 "MachineIndependent/glslang_tab.cpp"
+#line 10780 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 499: /* type_specifier_nonarray: IIMAGE2DARRAY  */
-#line 3338 "MachineIndependent/glslang.y"
+  case 501: /* type_specifier_nonarray: IIMAGE2DARRAY  */
+#line 3352 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
     }
-#line 10736 "MachineIndependent/glslang_tab.cpp"
+#line 10790 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 500: /* type_specifier_nonarray: UIMAGE2DARRAY  */
-#line 3343 "MachineIndependent/glslang.y"
+  case 502: /* type_specifier_nonarray: UIMAGE2DARRAY  */
+#line 3357 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
     }
-#line 10746 "MachineIndependent/glslang_tab.cpp"
+#line 10800 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 501: /* type_specifier_nonarray: IMAGECUBEARRAY  */
-#line 3348 "MachineIndependent/glslang.y"
+  case 503: /* type_specifier_nonarray: IMAGECUBEARRAY  */
+#line 3362 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true);
     }
-#line 10756 "MachineIndependent/glslang_tab.cpp"
+#line 10810 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 502: /* type_specifier_nonarray: F16IMAGECUBEARRAY  */
-#line 3353 "MachineIndependent/glslang.y"
+  case 504: /* type_specifier_nonarray: F16IMAGECUBEARRAY  */
+#line 3367 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
     }
-#line 10767 "MachineIndependent/glslang_tab.cpp"
+#line 10821 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 503: /* type_specifier_nonarray: IIMAGECUBEARRAY  */
-#line 3359 "MachineIndependent/glslang.y"
+  case 505: /* type_specifier_nonarray: IIMAGECUBEARRAY  */
+#line 3373 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
     }
-#line 10777 "MachineIndependent/glslang_tab.cpp"
+#line 10831 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 504: /* type_specifier_nonarray: UIMAGECUBEARRAY  */
-#line 3364 "MachineIndependent/glslang.y"
+  case 506: /* type_specifier_nonarray: UIMAGECUBEARRAY  */
+#line 3378 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
     }
-#line 10787 "MachineIndependent/glslang_tab.cpp"
+#line 10841 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 505: /* type_specifier_nonarray: IMAGE2DMS  */
-#line 3369 "MachineIndependent/glslang.y"
+  case 507: /* type_specifier_nonarray: IMAGE2DMS  */
+#line 3383 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
     }
-#line 10797 "MachineIndependent/glslang_tab.cpp"
+#line 10851 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 506: /* type_specifier_nonarray: F16IMAGE2DMS  */
-#line 3374 "MachineIndependent/glslang.y"
+  case 508: /* type_specifier_nonarray: F16IMAGE2DMS  */
+#line 3388 "MachineIndependent/glslang.y"
                    {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
     }
-#line 10808 "MachineIndependent/glslang_tab.cpp"
+#line 10862 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 507: /* type_specifier_nonarray: IIMAGE2DMS  */
-#line 3380 "MachineIndependent/glslang.y"
+  case 509: /* type_specifier_nonarray: IIMAGE2DMS  */
+#line 3394 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
     }
-#line 10818 "MachineIndependent/glslang_tab.cpp"
+#line 10872 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 508: /* type_specifier_nonarray: UIMAGE2DMS  */
-#line 3385 "MachineIndependent/glslang.y"
+  case 510: /* type_specifier_nonarray: UIMAGE2DMS  */
+#line 3399 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
     }
-#line 10828 "MachineIndependent/glslang_tab.cpp"
+#line 10882 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 509: /* type_specifier_nonarray: IMAGE2DMSARRAY  */
-#line 3390 "MachineIndependent/glslang.y"
+  case 511: /* type_specifier_nonarray: IMAGE2DMSARRAY  */
+#line 3404 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
     }
-#line 10838 "MachineIndependent/glslang_tab.cpp"
+#line 10892 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 510: /* type_specifier_nonarray: F16IMAGE2DMSARRAY  */
-#line 3395 "MachineIndependent/glslang.y"
+  case 512: /* type_specifier_nonarray: F16IMAGE2DMSARRAY  */
+#line 3409 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
     }
-#line 10849 "MachineIndependent/glslang_tab.cpp"
+#line 10903 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 511: /* type_specifier_nonarray: IIMAGE2DMSARRAY  */
-#line 3401 "MachineIndependent/glslang.y"
+  case 513: /* type_specifier_nonarray: IIMAGE2DMSARRAY  */
+#line 3415 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
     }
-#line 10859 "MachineIndependent/glslang_tab.cpp"
+#line 10913 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 512: /* type_specifier_nonarray: UIMAGE2DMSARRAY  */
-#line 3406 "MachineIndependent/glslang.y"
+  case 514: /* type_specifier_nonarray: UIMAGE2DMSARRAY  */
+#line 3420 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
     }
-#line 10869 "MachineIndependent/glslang_tab.cpp"
+#line 10923 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 513: /* type_specifier_nonarray: I64IMAGE1D  */
-#line 3411 "MachineIndependent/glslang.y"
+  case 515: /* type_specifier_nonarray: I64IMAGE1D  */
+#line 3425 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D);
     }
-#line 10879 "MachineIndependent/glslang_tab.cpp"
+#line 10933 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 514: /* type_specifier_nonarray: U64IMAGE1D  */
-#line 3416 "MachineIndependent/glslang.y"
+  case 516: /* type_specifier_nonarray: U64IMAGE1D  */
+#line 3430 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D);
     }
-#line 10889 "MachineIndependent/glslang_tab.cpp"
+#line 10943 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 515: /* type_specifier_nonarray: I64IMAGE2D  */
-#line 3421 "MachineIndependent/glslang.y"
+  case 517: /* type_specifier_nonarray: I64IMAGE2D  */
+#line 3435 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D);
     }
-#line 10899 "MachineIndependent/glslang_tab.cpp"
+#line 10953 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 516: /* type_specifier_nonarray: U64IMAGE2D  */
-#line 3426 "MachineIndependent/glslang.y"
+  case 518: /* type_specifier_nonarray: U64IMAGE2D  */
+#line 3440 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D);
     }
-#line 10909 "MachineIndependent/glslang_tab.cpp"
+#line 10963 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 517: /* type_specifier_nonarray: I64IMAGE3D  */
-#line 3431 "MachineIndependent/glslang.y"
+  case 519: /* type_specifier_nonarray: I64IMAGE3D  */
+#line 3445 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D);
     }
-#line 10919 "MachineIndependent/glslang_tab.cpp"
+#line 10973 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 518: /* type_specifier_nonarray: U64IMAGE3D  */
-#line 3436 "MachineIndependent/glslang.y"
+  case 520: /* type_specifier_nonarray: U64IMAGE3D  */
+#line 3450 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd3D);
     }
-#line 10929 "MachineIndependent/glslang_tab.cpp"
+#line 10983 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 519: /* type_specifier_nonarray: I64IMAGE2DRECT  */
-#line 3441 "MachineIndependent/glslang.y"
+  case 521: /* type_specifier_nonarray: I64IMAGE2DRECT  */
+#line 3455 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdRect);
     }
-#line 10939 "MachineIndependent/glslang_tab.cpp"
+#line 10993 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 520: /* type_specifier_nonarray: U64IMAGE2DRECT  */
-#line 3446 "MachineIndependent/glslang.y"
+  case 522: /* type_specifier_nonarray: U64IMAGE2DRECT  */
+#line 3460 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdRect);
     }
-#line 10949 "MachineIndependent/glslang_tab.cpp"
+#line 11003 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 521: /* type_specifier_nonarray: I64IMAGECUBE  */
-#line 3451 "MachineIndependent/glslang.y"
+  case 523: /* type_specifier_nonarray: I64IMAGECUBE  */
+#line 3465 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube);
     }
-#line 10959 "MachineIndependent/glslang_tab.cpp"
+#line 11013 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 522: /* type_specifier_nonarray: U64IMAGECUBE  */
-#line 3456 "MachineIndependent/glslang.y"
+  case 524: /* type_specifier_nonarray: U64IMAGECUBE  */
+#line 3470 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube);
     }
-#line 10969 "MachineIndependent/glslang_tab.cpp"
+#line 11023 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 523: /* type_specifier_nonarray: I64IMAGEBUFFER  */
-#line 3461 "MachineIndependent/glslang.y"
+  case 525: /* type_specifier_nonarray: I64IMAGEBUFFER  */
+#line 3475 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdBuffer);
     }
-#line 10979 "MachineIndependent/glslang_tab.cpp"
+#line 11033 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 524: /* type_specifier_nonarray: U64IMAGEBUFFER  */
-#line 3466 "MachineIndependent/glslang.y"
+  case 526: /* type_specifier_nonarray: U64IMAGEBUFFER  */
+#line 3480 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdBuffer);
     }
-#line 10989 "MachineIndependent/glslang_tab.cpp"
+#line 11043 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 525: /* type_specifier_nonarray: I64IMAGE1DARRAY  */
-#line 3471 "MachineIndependent/glslang.y"
+  case 527: /* type_specifier_nonarray: I64IMAGE1DARRAY  */
+#line 3485 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D, true);
     }
-#line 10999 "MachineIndependent/glslang_tab.cpp"
+#line 11053 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 526: /* type_specifier_nonarray: U64IMAGE1DARRAY  */
-#line 3476 "MachineIndependent/glslang.y"
+  case 528: /* type_specifier_nonarray: U64IMAGE1DARRAY  */
+#line 3490 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D, true);
     }
-#line 11009 "MachineIndependent/glslang_tab.cpp"
+#line 11063 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 527: /* type_specifier_nonarray: I64IMAGE2DARRAY  */
-#line 3481 "MachineIndependent/glslang.y"
+  case 529: /* type_specifier_nonarray: I64IMAGE2DARRAY  */
+#line 3495 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true);
     }
-#line 11019 "MachineIndependent/glslang_tab.cpp"
+#line 11073 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 528: /* type_specifier_nonarray: U64IMAGE2DARRAY  */
-#line 3486 "MachineIndependent/glslang.y"
+  case 530: /* type_specifier_nonarray: U64IMAGE2DARRAY  */
+#line 3500 "MachineIndependent/glslang.y"
                       {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true);
     }
-#line 11029 "MachineIndependent/glslang_tab.cpp"
+#line 11083 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 529: /* type_specifier_nonarray: I64IMAGECUBEARRAY  */
-#line 3491 "MachineIndependent/glslang.y"
+  case 531: /* type_specifier_nonarray: I64IMAGECUBEARRAY  */
+#line 3505 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube, true);
     }
-#line 11039 "MachineIndependent/glslang_tab.cpp"
+#line 11093 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 530: /* type_specifier_nonarray: U64IMAGECUBEARRAY  */
-#line 3496 "MachineIndependent/glslang.y"
+  case 532: /* type_specifier_nonarray: U64IMAGECUBEARRAY  */
+#line 3510 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube, true);
     }
-#line 11049 "MachineIndependent/glslang_tab.cpp"
+#line 11103 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 531: /* type_specifier_nonarray: I64IMAGE2DMS  */
-#line 3501 "MachineIndependent/glslang.y"
+  case 533: /* type_specifier_nonarray: I64IMAGE2DMS  */
+#line 3515 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, false, false, true);
     }
-#line 11059 "MachineIndependent/glslang_tab.cpp"
+#line 11113 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 532: /* type_specifier_nonarray: U64IMAGE2DMS  */
-#line 3506 "MachineIndependent/glslang.y"
+  case 534: /* type_specifier_nonarray: U64IMAGE2DMS  */
+#line 3520 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, false, false, true);
     }
-#line 11069 "MachineIndependent/glslang_tab.cpp"
+#line 11123 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 533: /* type_specifier_nonarray: I64IMAGE2DMSARRAY  */
-#line 3511 "MachineIndependent/glslang.y"
+  case 535: /* type_specifier_nonarray: I64IMAGE2DMSARRAY  */
+#line 3525 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true, false, true);
     }
-#line 11079 "MachineIndependent/glslang_tab.cpp"
+#line 11133 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 534: /* type_specifier_nonarray: U64IMAGE2DMSARRAY  */
-#line 3516 "MachineIndependent/glslang.y"
+  case 536: /* type_specifier_nonarray: U64IMAGE2DMSARRAY  */
+#line 3530 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true, false, true);
     }
-#line 11089 "MachineIndependent/glslang_tab.cpp"
+#line 11143 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 535: /* type_specifier_nonarray: SAMPLEREXTERNALOES  */
-#line 3521 "MachineIndependent/glslang.y"
+  case 537: /* type_specifier_nonarray: SAMPLEREXTERNALOES  */
+#line 3535 "MachineIndependent/glslang.y"
                          {  // GL_OES_EGL_image_external
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.external = true;
     }
-#line 11100 "MachineIndependent/glslang_tab.cpp"
+#line 11154 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 536: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT  */
-#line 3527 "MachineIndependent/glslang.y"
+  case 538: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT  */
+#line 3541 "MachineIndependent/glslang.y"
                               { // GL_EXT_YUV_target
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.yuv = true;
     }
-#line 11111 "MachineIndependent/glslang_tab.cpp"
+#line 11165 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 537: /* type_specifier_nonarray: ATTACHMENTEXT  */
-#line 3533 "MachineIndependent/glslang.y"
+  case 539: /* type_specifier_nonarray: ATTACHMENTEXT  */
+#line 3547 "MachineIndependent/glslang.y"
                     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setAttachmentEXT(EbtFloat);
     }
-#line 11122 "MachineIndependent/glslang_tab.cpp"
+#line 11176 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 538: /* type_specifier_nonarray: IATTACHMENTEXT  */
-#line 3539 "MachineIndependent/glslang.y"
+  case 540: /* type_specifier_nonarray: IATTACHMENTEXT  */
+#line 3553 "MachineIndependent/glslang.y"
                      {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setAttachmentEXT(EbtInt);
     }
-#line 11133 "MachineIndependent/glslang_tab.cpp"
+#line 11187 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 539: /* type_specifier_nonarray: UATTACHMENTEXT  */
-#line 3545 "MachineIndependent/glslang.y"
+  case 541: /* type_specifier_nonarray: UATTACHMENTEXT  */
+#line 3559 "MachineIndependent/glslang.y"
                      {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setAttachmentEXT(EbtUint);
     }
-#line 11144 "MachineIndependent/glslang_tab.cpp"
+#line 11198 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 540: /* type_specifier_nonarray: SUBPASSINPUT  */
-#line 3551 "MachineIndependent/glslang.y"
+  case 542: /* type_specifier_nonarray: SUBPASSINPUT  */
+#line 3565 "MachineIndependent/glslang.y"
                    {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat);
     }
-#line 11155 "MachineIndependent/glslang_tab.cpp"
+#line 11209 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 541: /* type_specifier_nonarray: SUBPASSINPUTMS  */
-#line 3557 "MachineIndependent/glslang.y"
+  case 543: /* type_specifier_nonarray: SUBPASSINPUTMS  */
+#line 3571 "MachineIndependent/glslang.y"
                      {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
     }
-#line 11166 "MachineIndependent/glslang_tab.cpp"
+#line 11220 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 542: /* type_specifier_nonarray: F16SUBPASSINPUT  */
-#line 3563 "MachineIndependent/glslang.y"
+  case 544: /* type_specifier_nonarray: F16SUBPASSINPUT  */
+#line 3577 "MachineIndependent/glslang.y"
                       {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -11174,11 +11228,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
     }
-#line 11178 "MachineIndependent/glslang_tab.cpp"
+#line 11232 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 543: /* type_specifier_nonarray: F16SUBPASSINPUTMS  */
-#line 3570 "MachineIndependent/glslang.y"
+  case 545: /* type_specifier_nonarray: F16SUBPASSINPUTMS  */
+#line 3584 "MachineIndependent/glslang.y"
                         {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -11186,55 +11240,55 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
     }
-#line 11190 "MachineIndependent/glslang_tab.cpp"
+#line 11244 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 544: /* type_specifier_nonarray: ISUBPASSINPUT  */
-#line 3577 "MachineIndependent/glslang.y"
+  case 546: /* type_specifier_nonarray: ISUBPASSINPUT  */
+#line 3591 "MachineIndependent/glslang.y"
                     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt);
     }
-#line 11201 "MachineIndependent/glslang_tab.cpp"
+#line 11255 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 545: /* type_specifier_nonarray: ISUBPASSINPUTMS  */
-#line 3583 "MachineIndependent/glslang.y"
+  case 547: /* type_specifier_nonarray: ISUBPASSINPUTMS  */
+#line 3597 "MachineIndependent/glslang.y"
                       {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt, true);
     }
-#line 11212 "MachineIndependent/glslang_tab.cpp"
+#line 11266 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 546: /* type_specifier_nonarray: USUBPASSINPUT  */
-#line 3589 "MachineIndependent/glslang.y"
+  case 548: /* type_specifier_nonarray: USUBPASSINPUT  */
+#line 3603 "MachineIndependent/glslang.y"
                     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint);
     }
-#line 11223 "MachineIndependent/glslang_tab.cpp"
+#line 11277 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 547: /* type_specifier_nonarray: USUBPASSINPUTMS  */
-#line 3595 "MachineIndependent/glslang.y"
+  case 549: /* type_specifier_nonarray: USUBPASSINPUTMS  */
+#line 3609 "MachineIndependent/glslang.y"
                       {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint, true);
     }
-#line 11234 "MachineIndependent/glslang_tab.cpp"
+#line 11288 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 548: /* type_specifier_nonarray: FCOOPMATNV  */
-#line 3601 "MachineIndependent/glslang.y"
+  case 550: /* type_specifier_nonarray: FCOOPMATNV  */
+#line 3615 "MachineIndependent/glslang.y"
                  {
         parseContext.fcoopmatCheckNV((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -11242,11 +11296,11 @@ yyreduce:
         (yyval.interm.type).coopmatNV = true;
         (yyval.interm.type).coopmatKHR = false;
     }
-#line 11246 "MachineIndependent/glslang_tab.cpp"
+#line 11300 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 549: /* type_specifier_nonarray: ICOOPMATNV  */
-#line 3608 "MachineIndependent/glslang.y"
+  case 551: /* type_specifier_nonarray: ICOOPMATNV  */
+#line 3622 "MachineIndependent/glslang.y"
                  {
         parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -11254,11 +11308,11 @@ yyreduce:
         (yyval.interm.type).coopmatNV = true;
         (yyval.interm.type).coopmatKHR = false;
     }
-#line 11258 "MachineIndependent/glslang_tab.cpp"
+#line 11312 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 550: /* type_specifier_nonarray: UCOOPMATNV  */
-#line 3615 "MachineIndependent/glslang.y"
+  case 552: /* type_specifier_nonarray: UCOOPMATNV  */
+#line 3629 "MachineIndependent/glslang.y"
                  {
         parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -11266,11 +11320,11 @@ yyreduce:
         (yyval.interm.type).coopmatNV = true;
         (yyval.interm.type).coopmatKHR = false;
     }
-#line 11270 "MachineIndependent/glslang_tab.cpp"
+#line 11324 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 551: /* type_specifier_nonarray: COOPMAT  */
-#line 3622 "MachineIndependent/glslang.y"
+  case 553: /* type_specifier_nonarray: COOPMAT  */
+#line 3636 "MachineIndependent/glslang.y"
               {
         parseContext.coopmatCheck((yyvsp[0].lex).loc, "coopmat", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -11278,99 +11332,110 @@ yyreduce:
         (yyval.interm.type).coopmatNV = false;
         (yyval.interm.type).coopmatKHR = true;
     }
-#line 11282 "MachineIndependent/glslang_tab.cpp"
+#line 11336 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 552: /* type_specifier_nonarray: TENSORLAYOUTNV  */
-#line 3629 "MachineIndependent/glslang.y"
+  case 554: /* type_specifier_nonarray: TENSORLAYOUTNV  */
+#line 3643 "MachineIndependent/glslang.y"
                      {
         parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorLayoutNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtTensorLayoutNV;
     }
-#line 11292 "MachineIndependent/glslang_tab.cpp"
+#line 11346 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 553: /* type_specifier_nonarray: TENSORVIEWNV  */
-#line 3634 "MachineIndependent/glslang.y"
+  case 555: /* type_specifier_nonarray: TENSORVIEWNV  */
+#line 3648 "MachineIndependent/glslang.y"
                    {
         parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorViewNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtTensorViewNV;
     }
-#line 11302 "MachineIndependent/glslang_tab.cpp"
+#line 11356 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 554: /* type_specifier_nonarray: FUNCTION  */
-#line 3639 "MachineIndependent/glslang.y"
+  case 556: /* type_specifier_nonarray: FUNCTION  */
+#line 3653 "MachineIndependent/glslang.y"
                {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).basicType = EbtFunction;
     }
-#line 11311 "MachineIndependent/glslang_tab.cpp"
+#line 11365 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 555: /* type_specifier_nonarray: COOPVECNV  */
-#line 3643 "MachineIndependent/glslang.y"
+  case 557: /* type_specifier_nonarray: COOPVECNV  */
+#line 3657 "MachineIndependent/glslang.y"
                 {
         parseContext.coopvecCheck((yyvsp[0].lex).loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtCoopvecNV;
         (yyval.interm.type).coopvecNV = true;
     }
-#line 11322 "MachineIndependent/glslang_tab.cpp"
+#line 11376 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 556: /* type_specifier_nonarray: TENSORARM  */
-#line 3649 "MachineIndependent/glslang.y"
+  case 558: /* type_specifier_nonarray: TENSORARM  */
+#line 3663 "MachineIndependent/glslang.y"
                 {
         parseContext.tensorCheckARM((yyvsp[0].lex).loc, "tensorARM", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).tensorRankARM = 1; // placeholder value
         (yyval.interm.type).basicType = EbtTensorARM;
     }
-#line 11333 "MachineIndependent/glslang_tab.cpp"
+#line 11387 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 557: /* type_specifier_nonarray: spirv_type_specifier  */
-#line 3655 "MachineIndependent/glslang.y"
+  case 559: /* type_specifier_nonarray: VECTOR  */
+#line 3669 "MachineIndependent/glslang.y"
+             {
+        parseContext.longVectorCheck((yyvsp[0].lex).loc, "vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtLongVector;
+        (yyval.interm.type).longVector = true;
+    }
+#line 11398 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 560: /* type_specifier_nonarray: spirv_type_specifier  */
+#line 3675 "MachineIndependent/glslang.y"
                            {
         parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 11342 "MachineIndependent/glslang_tab.cpp"
+#line 11407 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 558: /* type_specifier_nonarray: HITOBJECTNV  */
-#line 3659 "MachineIndependent/glslang.y"
+  case 561: /* type_specifier_nonarray: HITOBJECTNV  */
+#line 3679 "MachineIndependent/glslang.y"
                   {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtHitObjectNV;
     }
-#line 11351 "MachineIndependent/glslang_tab.cpp"
+#line 11416 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 559: /* type_specifier_nonarray: HITOBJECTEXT  */
-#line 3663 "MachineIndependent/glslang.y"
+  case 562: /* type_specifier_nonarray: HITOBJECTEXT  */
+#line 3683 "MachineIndependent/glslang.y"
                    {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtHitObjectEXT;
     }
-#line 11360 "MachineIndependent/glslang_tab.cpp"
+#line 11425 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 560: /* type_specifier_nonarray: struct_specifier  */
-#line 3667 "MachineIndependent/glslang.y"
+  case 563: /* type_specifier_nonarray: struct_specifier  */
+#line 3687 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.type) = (yyvsp[0].interm.type);
         (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
     }
-#line 11370 "MachineIndependent/glslang_tab.cpp"
+#line 11435 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 561: /* type_specifier_nonarray: TYPE_NAME  */
-#line 3672 "MachineIndependent/glslang.y"
+  case 564: /* type_specifier_nonarray: TYPE_NAME  */
+#line 3692 "MachineIndependent/glslang.y"
                 {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -11384,49 +11449,48 @@ yyreduce:
         } else
             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
     }
-#line 11388 "MachineIndependent/glslang_tab.cpp"
+#line 11453 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 562: /* precision_qualifier: HIGH_PRECISION  */
-#line 3688 "MachineIndependent/glslang.y"
+  case 565: /* precision_qualifier: HIGH_PRECISION  */
+#line 3708 "MachineIndependent/glslang.y"
                      {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
     }
-#line 11398 "MachineIndependent/glslang_tab.cpp"
+#line 11463 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 563: /* precision_qualifier: MEDIUM_PRECISION  */
-#line 3693 "MachineIndependent/glslang.y"
+  case 566: /* precision_qualifier: MEDIUM_PRECISION  */
+#line 3713 "MachineIndependent/glslang.y"
                        {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
     }
-#line 11408 "MachineIndependent/glslang_tab.cpp"
+#line 11473 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 564: /* precision_qualifier: LOW_PRECISION  */
-#line 3698 "MachineIndependent/glslang.y"
+  case 567: /* precision_qualifier: LOW_PRECISION  */
+#line 3718 "MachineIndependent/glslang.y"
                     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
     }
-#line 11418 "MachineIndependent/glslang_tab.cpp"
+#line 11483 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 565: /* $@3: %empty  */
-#line 3706 "MachineIndependent/glslang.y"
+  case 568: /* $@3: %empty  */
+#line 3726 "MachineIndependent/glslang.y"
                                    { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
-#line 11424 "MachineIndependent/glslang_tab.cpp"
+#line 11489 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 566: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE  */
-#line 3706 "MachineIndependent/glslang.y"
+  case 569: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE  */
+#line 3726 "MachineIndependent/glslang.y"
                                                                                                                    {
-
         TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
         parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
 
@@ -11442,17 +11506,17 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 11446 "MachineIndependent/glslang_tab.cpp"
+#line 11510 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 567: /* $@4: %empty  */
-#line 3723 "MachineIndependent/glslang.y"
+  case 570: /* $@4: %empty  */
+#line 3742 "MachineIndependent/glslang.y"
                         { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
-#line 11452 "MachineIndependent/glslang_tab.cpp"
+#line 11516 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 568: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE  */
-#line 3723 "MachineIndependent/glslang.y"
+  case 571: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE  */
+#line 3742 "MachineIndependent/glslang.y"
                                                                                                         {
         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[-4].lex).loc);
@@ -11460,20 +11524,28 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 11464 "MachineIndependent/glslang_tab.cpp"
+#line 11528 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 569: /* struct_declaration_list: struct_declaration  */
-#line 3733 "MachineIndependent/glslang.y"
-                         {
+  case 572: /* struct_declaration_list: struct_declaration_without_heap  */
+#line 3752 "MachineIndependent/glslang.y"
+                                      {
         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
     }
-#line 11472 "MachineIndependent/glslang_tab.cpp"
+#line 11536 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 570: /* struct_declaration_list: struct_declaration_list struct_declaration  */
-#line 3736 "MachineIndependent/glslang.y"
-                                                 {
+  case 573: /* struct_declaration_list: struct_declaration_with_heap  */
+#line 3755 "MachineIndependent/glslang.y"
+                                   {
+        (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
+    }
+#line 11544 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 574: /* struct_declaration_list: struct_declaration_with_heap struct_declaration_without_heap  */
+#line 3758 "MachineIndependent/glslang.y"
+                                                                   {
         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
         for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
             for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
@@ -11483,11 +11555,91 @@ yyreduce:
             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
         }
     }
-#line 11487 "MachineIndependent/glslang_tab.cpp"
+#line 11559 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 571: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON  */
-#line 3749 "MachineIndependent/glslang.y"
+  case 575: /* struct_declaration_list: struct_declaration_without_heap struct_declaration_with_heap  */
+#line 3768 "MachineIndependent/glslang.y"
+                                                                   {
+        (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
+        for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
+            for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
+                if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName())
+                    parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str());
+            }
+            (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
+        }
+    }
+#line 11574 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 576: /* struct_declaration_with_heap: block_heap_inner_structure struct_declarator_list SEMICOLON  */
+#line 3781 "MachineIndependent/glslang.y"
+                                                                  {
+        (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
+        parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
+        parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).hasTypeParameter());
+
+        for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
+            TType type((yyvsp[-2].interm.type));
+            type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
+            type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
+            type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
+            parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
+            (*(yyval.interm.typeList))[i].type->shallowCopy(type);
+        }
+    }
+#line 11593 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 577: /* $@5: %empty  */
+#line 3798 "MachineIndependent/glslang.y"
+                                { parseContext.nestedBlockCheck((yyvsp[-1].interm.type).loc, true); }
+#line 11599 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 578: /* block_heap_inner_structure: type_qualifier LEFT_BRACE $@5 struct_declaration_without_heap RIGHT_BRACE  */
+#line 3798 "MachineIndependent/glslang.y"
+                                                                                                                             {
+        --parseContext.blockNestingLevel;
+        parseContext.globalQualifierFixCheck((yyvsp[-4].interm.type).loc, (yyvsp[-4].interm.type).qualifier);
+        parseContext.checkNoShaderLayouts((yyvsp[-4].interm.type).loc, (yyvsp[-4].interm.type).shaderQualifiers);
+        (yyval.interm.type).init((yyvsp[-4].interm.type).loc);
+        TType* innerStructure = new TType((yyvsp[-1].interm.typeList), TString(""));
+        (yyval.interm.type).basicType = EbtBlock;
+        (yyval.interm.type).userDef = innerStructure;
+        (yyval.interm.type).qualifier = (yyvsp[-4].interm.type).qualifier;
+        (yyval.interm.type).qualifier.layoutDescriptorHeap = true;
+        (yyval.interm.type).qualifier.layoutDescriptorInnerBlock = true;
+    }
+#line 11616 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 579: /* struct_declaration_without_heap: struct_declaration  */
+#line 3813 "MachineIndependent/glslang.y"
+                         {
+        (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
+    }
+#line 11624 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 580: /* struct_declaration_without_heap: struct_declaration_without_heap struct_declaration  */
+#line 3816 "MachineIndependent/glslang.y"
+                                                         {
+        (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
+        for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
+            for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
+                if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName())
+                    parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str());
+            }
+            (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
+        }
+    }
+#line 11639 "MachineIndependent/glslang_tab.cpp"
+    break;
+
+  case 581: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON  */
+#line 3829 "MachineIndependent/glslang.y"
                                                       {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -11510,11 +11662,11 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 11514 "MachineIndependent/glslang_tab.cpp"
+#line 11666 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 572: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON  */
-#line 3771 "MachineIndependent/glslang.y"
+  case 582: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON  */
+#line 3851 "MachineIndependent/glslang.y"
                                                                      {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -11539,38 +11691,38 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 11543 "MachineIndependent/glslang_tab.cpp"
+#line 11695 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 573: /* struct_declarator_list: struct_declarator  */
-#line 3798 "MachineIndependent/glslang.y"
+  case 583: /* struct_declarator_list: struct_declarator  */
+#line 3878 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 11552 "MachineIndependent/glslang_tab.cpp"
+#line 11704 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 574: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator  */
-#line 3802 "MachineIndependent/glslang.y"
+  case 584: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator  */
+#line 3882 "MachineIndependent/glslang.y"
                                                      {
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 11560 "MachineIndependent/glslang_tab.cpp"
+#line 11712 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 575: /* struct_declarator: IDENTIFIER  */
-#line 3808 "MachineIndependent/glslang.y"
+  case 585: /* struct_declarator: IDENTIFIER  */
+#line 3888 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.typeLine).type = new TType(EbtVoid);
         (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
     }
-#line 11570 "MachineIndependent/glslang_tab.cpp"
+#line 11722 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 576: /* struct_declarator: IDENTIFIER array_specifier  */
-#line 3813 "MachineIndependent/glslang.y"
+  case 586: /* struct_declarator: IDENTIFIER array_specifier  */
+#line 3893 "MachineIndependent/glslang.y"
                                  {
         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
 
@@ -11579,168 +11731,168 @@ yyreduce:
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
     }
-#line 11583 "MachineIndependent/glslang_tab.cpp"
+#line 11735 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 577: /* initializer: assignment_expression  */
-#line 3824 "MachineIndependent/glslang.y"
+  case 587: /* initializer: assignment_expression  */
+#line 3904 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 11591 "MachineIndependent/glslang_tab.cpp"
+#line 11743 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 578: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE  */
-#line 3827 "MachineIndependent/glslang.y"
+  case 588: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE  */
+#line 3907 "MachineIndependent/glslang.y"
                                               {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
     }
-#line 11602 "MachineIndependent/glslang_tab.cpp"
+#line 11754 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 579: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE  */
-#line 3833 "MachineIndependent/glslang.y"
+  case 589: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE  */
+#line 3913 "MachineIndependent/glslang.y"
                                                     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 11613 "MachineIndependent/glslang_tab.cpp"
+#line 11765 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 580: /* initializer: LEFT_BRACE RIGHT_BRACE  */
-#line 3839 "MachineIndependent/glslang.y"
+  case 590: /* initializer: LEFT_BRACE RIGHT_BRACE  */
+#line 3919 "MachineIndependent/glslang.y"
                              {
         const char* initFeature = "empty { } initializer";
         parseContext.profileRequires((yyvsp[-1].lex).loc, EEsProfile, 0, E_GL_EXT_null_initializer, initFeature);
         parseContext.profileRequires((yyvsp[-1].lex).loc, ~EEsProfile, 0, E_GL_EXT_null_initializer, initFeature);
         (yyval.interm.intermTypedNode) = parseContext.intermediate.makeAggregate((yyvsp[-1].lex).loc);
     }
-#line 11624 "MachineIndependent/glslang_tab.cpp"
+#line 11776 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 581: /* initializer_list: initializer  */
-#line 3848 "MachineIndependent/glslang.y"
+  case 591: /* initializer_list: initializer  */
+#line 3928 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
     }
-#line 11632 "MachineIndependent/glslang_tab.cpp"
+#line 11784 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 582: /* initializer_list: initializer_list COMMA initializer  */
-#line 3851 "MachineIndependent/glslang.y"
+  case 592: /* initializer_list: initializer_list COMMA initializer  */
+#line 3931 "MachineIndependent/glslang.y"
                                          {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 11640 "MachineIndependent/glslang_tab.cpp"
+#line 11792 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 583: /* declaration_statement: declaration  */
-#line 3857 "MachineIndependent/glslang.y"
+  case 593: /* declaration_statement: declaration  */
+#line 3937 "MachineIndependent/glslang.y"
                   { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11646 "MachineIndependent/glslang_tab.cpp"
+#line 11798 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 584: /* statement: compound_statement  */
-#line 3861 "MachineIndependent/glslang.y"
+  case 594: /* statement: compound_statement  */
+#line 3941 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11652 "MachineIndependent/glslang_tab.cpp"
+#line 11804 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 585: /* statement: simple_statement  */
-#line 3862 "MachineIndependent/glslang.y"
+  case 595: /* statement: simple_statement  */
+#line 3942 "MachineIndependent/glslang.y"
                           { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11658 "MachineIndependent/glslang_tab.cpp"
+#line 11810 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 586: /* simple_statement: declaration_statement  */
-#line 3868 "MachineIndependent/glslang.y"
+  case 596: /* simple_statement: declaration_statement  */
+#line 3948 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11664 "MachineIndependent/glslang_tab.cpp"
+#line 11816 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 587: /* simple_statement: expression_statement  */
-#line 3869 "MachineIndependent/glslang.y"
+  case 597: /* simple_statement: expression_statement  */
+#line 3949 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11670 "MachineIndependent/glslang_tab.cpp"
+#line 11822 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 588: /* simple_statement: selection_statement  */
-#line 3870 "MachineIndependent/glslang.y"
+  case 598: /* simple_statement: selection_statement  */
+#line 3950 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11676 "MachineIndependent/glslang_tab.cpp"
+#line 11828 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 589: /* simple_statement: switch_statement  */
-#line 3871 "MachineIndependent/glslang.y"
+  case 599: /* simple_statement: switch_statement  */
+#line 3951 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11682 "MachineIndependent/glslang_tab.cpp"
+#line 11834 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 590: /* simple_statement: case_label  */
-#line 3872 "MachineIndependent/glslang.y"
+  case 600: /* simple_statement: case_label  */
+#line 3952 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11688 "MachineIndependent/glslang_tab.cpp"
+#line 11840 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 591: /* simple_statement: iteration_statement  */
-#line 3873 "MachineIndependent/glslang.y"
+  case 601: /* simple_statement: iteration_statement  */
+#line 3953 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11694 "MachineIndependent/glslang_tab.cpp"
+#line 11846 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 592: /* simple_statement: jump_statement  */
-#line 3874 "MachineIndependent/glslang.y"
+  case 602: /* simple_statement: jump_statement  */
+#line 3954 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11700 "MachineIndependent/glslang_tab.cpp"
+#line 11852 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 593: /* simple_statement: demote_statement  */
-#line 3875 "MachineIndependent/glslang.y"
+  case 603: /* simple_statement: demote_statement  */
+#line 3955 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11706 "MachineIndependent/glslang_tab.cpp"
+#line 11858 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 594: /* demote_statement: DEMOTE SEMICOLON  */
-#line 3879 "MachineIndependent/glslang.y"
+  case 604: /* demote_statement: DEMOTE SEMICOLON  */
+#line 3959 "MachineIndependent/glslang.y"
                        {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote");
         parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc);
     }
-#line 11716 "MachineIndependent/glslang_tab.cpp"
+#line 11868 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 595: /* compound_statement: LEFT_BRACE RIGHT_BRACE  */
-#line 3887 "MachineIndependent/glslang.y"
+  case 605: /* compound_statement: LEFT_BRACE RIGHT_BRACE  */
+#line 3967 "MachineIndependent/glslang.y"
                              { (yyval.interm.intermNode) = 0; }
-#line 11722 "MachineIndependent/glslang_tab.cpp"
+#line 11874 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 596: /* $@5: %empty  */
-#line 3888 "MachineIndependent/glslang.y"
+  case 606: /* $@6: %empty  */
+#line 3968 "MachineIndependent/glslang.y"
                  {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
-#line 11731 "MachineIndependent/glslang_tab.cpp"
+#line 11883 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 597: /* $@6: %empty  */
-#line 3892 "MachineIndependent/glslang.y"
+  case 607: /* $@7: %empty  */
+#line 3972 "MachineIndependent/glslang.y"
                      {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
-#line 11740 "MachineIndependent/glslang_tab.cpp"
+#line 11892 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 598: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE  */
-#line 3896 "MachineIndependent/glslang.y"
+  case 608: /* compound_statement: LEFT_BRACE $@6 statement_list $@7 RIGHT_BRACE  */
+#line 3976 "MachineIndependent/glslang.y"
                   {
         if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) {
             (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(parseContext.intermediate.getDebugInfo() ? EOpScope : EOpSequence);
@@ -11748,69 +11900,69 @@ yyreduce:
         }
         (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
     }
-#line 11752 "MachineIndependent/glslang_tab.cpp"
+#line 11904 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 599: /* statement_no_new_scope: compound_statement_no_new_scope  */
-#line 3906 "MachineIndependent/glslang.y"
+  case 609: /* statement_no_new_scope: compound_statement_no_new_scope  */
+#line 3986 "MachineIndependent/glslang.y"
                                       { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11758 "MachineIndependent/glslang_tab.cpp"
+#line 11910 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 600: /* statement_no_new_scope: simple_statement  */
-#line 3907 "MachineIndependent/glslang.y"
+  case 610: /* statement_no_new_scope: simple_statement  */
+#line 3987 "MachineIndependent/glslang.y"
                                       { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 11764 "MachineIndependent/glslang_tab.cpp"
+#line 11916 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 601: /* $@7: %empty  */
-#line 3911 "MachineIndependent/glslang.y"
+  case 611: /* $@8: %empty  */
+#line 3991 "MachineIndependent/glslang.y"
       {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 11772 "MachineIndependent/glslang_tab.cpp"
+#line 11924 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 602: /* statement_scoped: $@7 compound_statement  */
-#line 3914 "MachineIndependent/glslang.y"
+  case 612: /* statement_scoped: $@8 compound_statement  */
+#line 3994 "MachineIndependent/glslang.y"
                           {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11781 "MachineIndependent/glslang_tab.cpp"
+#line 11933 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 603: /* $@8: %empty  */
-#line 3918 "MachineIndependent/glslang.y"
+  case 613: /* $@9: %empty  */
+#line 3998 "MachineIndependent/glslang.y"
       {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 11791 "MachineIndependent/glslang_tab.cpp"
+#line 11943 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 604: /* statement_scoped: $@8 simple_statement  */
-#line 3923 "MachineIndependent/glslang.y"
+  case 614: /* statement_scoped: $@9 simple_statement  */
+#line 4003 "MachineIndependent/glslang.y"
                        {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11802 "MachineIndependent/glslang_tab.cpp"
+#line 11954 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 605: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE  */
-#line 3932 "MachineIndependent/glslang.y"
+  case 615: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE  */
+#line 4012 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.intermNode) = 0;
     }
-#line 11810 "MachineIndependent/glslang_tab.cpp"
+#line 11962 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 606: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE  */
-#line 3935 "MachineIndependent/glslang.y"
+  case 616: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE  */
+#line 4015 "MachineIndependent/glslang.y"
                                             {
         if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) {
             (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
@@ -11818,11 +11970,11 @@ yyreduce:
         }
         (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
     }
-#line 11822 "MachineIndependent/glslang_tab.cpp"
+#line 11974 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 607: /* statement_list: statement  */
-#line 3945 "MachineIndependent/glslang.y"
+  case 617: /* statement_list: statement  */
+#line 4025 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
@@ -11831,11 +11983,11 @@ yyreduce:
             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
         }
     }
-#line 11835 "MachineIndependent/glslang_tab.cpp"
+#line 11987 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 608: /* statement_list: statement_list statement  */
-#line 3953 "MachineIndependent/glslang.y"
+  case 618: /* statement_list: statement_list statement  */
+#line 4033 "MachineIndependent/glslang.y"
                                {
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
@@ -11844,106 +11996,106 @@ yyreduce:
         } else
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 11848 "MachineIndependent/glslang_tab.cpp"
+#line 12000 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 609: /* expression_statement: SEMICOLON  */
-#line 3964 "MachineIndependent/glslang.y"
+  case 619: /* expression_statement: SEMICOLON  */
+#line 4044 "MachineIndependent/glslang.y"
                  { (yyval.interm.intermNode) = 0; }
-#line 11854 "MachineIndependent/glslang_tab.cpp"
+#line 12006 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 610: /* expression_statement: expression SEMICOLON  */
-#line 3965 "MachineIndependent/glslang.y"
+  case 620: /* expression_statement: expression SEMICOLON  */
+#line 4045 "MachineIndependent/glslang.y"
                             { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
-#line 11860 "MachineIndependent/glslang_tab.cpp"
+#line 12012 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 611: /* selection_statement: selection_statement_nonattributed  */
-#line 3969 "MachineIndependent/glslang.y"
+  case 621: /* selection_statement: selection_statement_nonattributed  */
+#line 4049 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11868 "MachineIndependent/glslang_tab.cpp"
+#line 12020 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 612: /* selection_statement: attribute selection_statement_nonattributed  */
-#line 3972 "MachineIndependent/glslang.y"
+  case 622: /* selection_statement: attribute selection_statement_nonattributed  */
+#line 4052 "MachineIndependent/glslang.y"
                                                   {
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11878 "MachineIndependent/glslang_tab.cpp"
+#line 12030 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 613: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement  */
-#line 3979 "MachineIndependent/glslang.y"
+  case 623: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement  */
+#line 4059 "MachineIndependent/glslang.y"
                                                                     {
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
         (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
     }
-#line 11887 "MachineIndependent/glslang_tab.cpp"
+#line 12039 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 614: /* selection_rest_statement: statement_scoped ELSE statement_scoped  */
-#line 3986 "MachineIndependent/glslang.y"
+  case 624: /* selection_rest_statement: statement_scoped ELSE statement_scoped  */
+#line 4066 "MachineIndependent/glslang.y"
                                              {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
     }
-#line 11896 "MachineIndependent/glslang_tab.cpp"
+#line 12048 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 615: /* selection_rest_statement: statement_scoped  */
-#line 3990 "MachineIndependent/glslang.y"
+  case 625: /* selection_rest_statement: statement_scoped  */
+#line 4070 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 11905 "MachineIndependent/glslang_tab.cpp"
+#line 12057 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 616: /* condition: expression  */
-#line 3998 "MachineIndependent/glslang.y"
+  case 626: /* condition: expression  */
+#line 4078 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode);
         parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
     }
-#line 11914 "MachineIndependent/glslang_tab.cpp"
+#line 12066 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 617: /* condition: fully_specified_type IDENTIFIER EQUAL initializer  */
-#line 4002 "MachineIndependent/glslang.y"
+  case 627: /* condition: fully_specified_type IDENTIFIER EQUAL initializer  */
+#line 4082 "MachineIndependent/glslang.y"
                                                         {
         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
 
         TType type((yyvsp[-3].interm.type));
         (yyval.interm.intermNode) = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
     }
-#line 11925 "MachineIndependent/glslang_tab.cpp"
+#line 12077 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 618: /* switch_statement: switch_statement_nonattributed  */
-#line 4011 "MachineIndependent/glslang.y"
+  case 628: /* switch_statement: switch_statement_nonattributed  */
+#line 4091 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11933 "MachineIndependent/glslang_tab.cpp"
+#line 12085 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 619: /* switch_statement: attribute switch_statement_nonattributed  */
-#line 4014 "MachineIndependent/glslang.y"
+  case 629: /* switch_statement: attribute switch_statement_nonattributed  */
+#line 4094 "MachineIndependent/glslang.y"
                                                {
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute");
         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11943 "MachineIndependent/glslang_tab.cpp"
+#line 12095 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 620: /* $@9: %empty  */
-#line 4021 "MachineIndependent/glslang.y"
+  case 630: /* $@10: %empty  */
+#line 4101 "MachineIndependent/glslang.y"
                                                {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -11952,11 +12104,11 @@ yyreduce:
         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
         parseContext.symbolTable.push();
     }
-#line 11956 "MachineIndependent/glslang_tab.cpp"
+#line 12108 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 621: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE  */
-#line 4029 "MachineIndependent/glslang.y"
+  case 631: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@10 LEFT_BRACE switch_statement_list RIGHT_BRACE  */
+#line 4109 "MachineIndependent/glslang.y"
                                                  {
         (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
         delete parseContext.switchSequenceStack.back();
@@ -11966,27 +12118,27 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 11970 "MachineIndependent/glslang_tab.cpp"
+#line 12122 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 622: /* switch_statement_list: %empty  */
-#line 4041 "MachineIndependent/glslang.y"
+  case 632: /* switch_statement_list: %empty  */
+#line 4121 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = 0;
     }
-#line 11978 "MachineIndependent/glslang_tab.cpp"
+#line 12130 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 623: /* switch_statement_list: statement_list  */
-#line 4044 "MachineIndependent/glslang.y"
+  case 633: /* switch_statement_list: statement_list  */
+#line 4124 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 11986 "MachineIndependent/glslang_tab.cpp"
+#line 12138 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 624: /* case_label: CASE expression COLON  */
-#line 4050 "MachineIndependent/glslang.y"
+  case 634: /* case_label: CASE expression COLON  */
+#line 4130 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -11999,11 +12151,11 @@ yyreduce:
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
         }
     }
-#line 12003 "MachineIndependent/glslang_tab.cpp"
+#line 12155 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 625: /* case_label: DEFAULT COLON  */
-#line 4062 "MachineIndependent/glslang.y"
+  case 635: /* case_label: DEFAULT COLON  */
+#line 4142 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -12013,30 +12165,30 @@ yyreduce:
         else
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
     }
-#line 12017 "MachineIndependent/glslang_tab.cpp"
+#line 12169 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 626: /* iteration_statement: iteration_statement_nonattributed  */
-#line 4074 "MachineIndependent/glslang.y"
+  case 636: /* iteration_statement: iteration_statement_nonattributed  */
+#line 4154 "MachineIndependent/glslang.y"
                                         {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12025 "MachineIndependent/glslang_tab.cpp"
+#line 12177 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 627: /* iteration_statement: attribute iteration_statement_nonattributed  */
-#line 4077 "MachineIndependent/glslang.y"
+  case 637: /* iteration_statement: attribute iteration_statement_nonattributed  */
+#line 4157 "MachineIndependent/glslang.y"
                                                   {
         const char * extensions[2] = { E_GL_EXT_control_flow_attributes, E_GL_EXT_control_flow_attributes2 };
         parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 2, extensions, "attribute");
         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12036 "MachineIndependent/glslang_tab.cpp"
+#line 12188 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 628: /* $@10: %empty  */
-#line 4085 "MachineIndependent/glslang.y"
+  case 638: /* $@11: %empty  */
+#line 4165 "MachineIndependent/glslang.y"
                        {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
@@ -12045,11 +12197,11 @@ yyreduce:
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 12049 "MachineIndependent/glslang_tab.cpp"
+#line 12201 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 629: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope  */
-#line 4093 "MachineIndependent/glslang.y"
+  case 639: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@11 condition RIGHT_PAREN statement_no_new_scope  */
+#line 4173 "MachineIndependent/glslang.y"
                                                    {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermNode), 0, true, (yyvsp[-5].lex).loc);
@@ -12061,22 +12213,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 12065 "MachineIndependent/glslang_tab.cpp"
+#line 12217 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 630: /* $@11: %empty  */
-#line 4104 "MachineIndependent/glslang.y"
+  case 640: /* $@12: %empty  */
+#line 4184 "MachineIndependent/glslang.y"
          {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 12076 "MachineIndependent/glslang_tab.cpp"
+#line 12228 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 631: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON  */
-#line 4110 "MachineIndependent/glslang.y"
+  case 641: /* iteration_statement_nonattributed: DO $@12 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON  */
+#line 4190 "MachineIndependent/glslang.y"
                                                                   {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
@@ -12093,22 +12245,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 12097 "MachineIndependent/glslang_tab.cpp"
+#line 12249 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 632: /* $@12: %empty  */
-#line 4126 "MachineIndependent/glslang.y"
+  case 642: /* $@13: %empty  */
+#line 4206 "MachineIndependent/glslang.y"
                      {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 12108 "MachineIndependent/glslang_tab.cpp"
+#line 12260 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 633: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope  */
-#line 4132 "MachineIndependent/glslang.y"
+  case 643: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@13 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope  */
+#line 4212 "MachineIndependent/glslang.y"
                                                                                {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
@@ -12121,81 +12273,81 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 12125 "MachineIndependent/glslang_tab.cpp"
+#line 12277 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 634: /* for_init_statement: expression_statement  */
-#line 4147 "MachineIndependent/glslang.y"
+  case 644: /* for_init_statement: expression_statement  */
+#line 4227 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12133 "MachineIndependent/glslang_tab.cpp"
+#line 12285 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 635: /* for_init_statement: declaration_statement  */
-#line 4150 "MachineIndependent/glslang.y"
+  case 645: /* for_init_statement: declaration_statement  */
+#line 4230 "MachineIndependent/glslang.y"
                             {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12141 "MachineIndependent/glslang_tab.cpp"
+#line 12293 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 636: /* conditionopt: condition  */
-#line 4156 "MachineIndependent/glslang.y"
+  case 646: /* conditionopt: condition  */
+#line 4236 "MachineIndependent/glslang.y"
                 {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12149 "MachineIndependent/glslang_tab.cpp"
+#line 12301 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 637: /* conditionopt: %empty  */
-#line 4159 "MachineIndependent/glslang.y"
+  case 647: /* conditionopt: %empty  */
+#line 4239 "MachineIndependent/glslang.y"
                         {
         (yyval.interm.intermNode) = 0;
     }
-#line 12157 "MachineIndependent/glslang_tab.cpp"
+#line 12309 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 638: /* for_rest_statement: conditionopt SEMICOLON  */
-#line 4165 "MachineIndependent/glslang.y"
+  case 648: /* for_rest_statement: conditionopt SEMICOLON  */
+#line 4245 "MachineIndependent/glslang.y"
                              {
         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 12166 "MachineIndependent/glslang_tab.cpp"
+#line 12318 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 639: /* for_rest_statement: conditionopt SEMICOLON expression  */
-#line 4169 "MachineIndependent/glslang.y"
+  case 649: /* for_rest_statement: conditionopt SEMICOLON expression  */
+#line 4249 "MachineIndependent/glslang.y"
                                          {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
     }
-#line 12175 "MachineIndependent/glslang_tab.cpp"
+#line 12327 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 640: /* jump_statement: CONTINUE SEMICOLON  */
-#line 4176 "MachineIndependent/glslang.y"
+  case 650: /* jump_statement: CONTINUE SEMICOLON  */
+#line 4256 "MachineIndependent/glslang.y"
                          {
         if (parseContext.loopNestingLevel <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
     }
-#line 12185 "MachineIndependent/glslang_tab.cpp"
+#line 12337 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 641: /* jump_statement: BREAK SEMICOLON  */
-#line 4181 "MachineIndependent/glslang.y"
+  case 651: /* jump_statement: BREAK SEMICOLON  */
+#line 4261 "MachineIndependent/glslang.y"
                       {
         if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
     }
-#line 12195 "MachineIndependent/glslang_tab.cpp"
+#line 12347 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 642: /* jump_statement: RETURN SEMICOLON  */
-#line 4186 "MachineIndependent/glslang.y"
+  case 652: /* jump_statement: RETURN SEMICOLON  */
+#line 4266 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -12203,101 +12355,101 @@ yyreduce:
         if (parseContext.inMain)
             parseContext.postEntryPointReturn = true;
     }
-#line 12207 "MachineIndependent/glslang_tab.cpp"
+#line 12359 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 643: /* jump_statement: RETURN expression SEMICOLON  */
-#line 4193 "MachineIndependent/glslang.y"
+  case 653: /* jump_statement: RETURN expression SEMICOLON  */
+#line 4273 "MachineIndependent/glslang.y"
                                   {
         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 12215 "MachineIndependent/glslang_tab.cpp"
+#line 12367 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 644: /* jump_statement: DISCARD SEMICOLON  */
-#line 4196 "MachineIndependent/glslang.y"
+  case 654: /* jump_statement: DISCARD SEMICOLON  */
+#line 4276 "MachineIndependent/glslang.y"
                         {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
     }
-#line 12224 "MachineIndependent/glslang_tab.cpp"
+#line 12376 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 645: /* jump_statement: TERMINATE_INVOCATION SEMICOLON  */
-#line 4200 "MachineIndependent/glslang.y"
+  case 655: /* jump_statement: TERMINATE_INVOCATION SEMICOLON  */
+#line 4280 "MachineIndependent/glslang.y"
                                      {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc);
     }
-#line 12233 "MachineIndependent/glslang_tab.cpp"
+#line 12385 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 646: /* jump_statement: TERMINATE_RAY SEMICOLON  */
-#line 4204 "MachineIndependent/glslang.y"
+  case 656: /* jump_statement: TERMINATE_RAY SEMICOLON  */
+#line 4284 "MachineIndependent/glslang.y"
                               {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc);
     }
-#line 12242 "MachineIndependent/glslang_tab.cpp"
+#line 12394 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 647: /* jump_statement: IGNORE_INTERSECTION SEMICOLON  */
-#line 4208 "MachineIndependent/glslang.y"
+  case 657: /* jump_statement: IGNORE_INTERSECTION SEMICOLON  */
+#line 4288 "MachineIndependent/glslang.y"
                                     {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc);
     }
-#line 12251 "MachineIndependent/glslang_tab.cpp"
+#line 12403 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 648: /* translation_unit: external_declaration  */
-#line 4217 "MachineIndependent/glslang.y"
+  case 658: /* translation_unit: external_declaration  */
+#line 4297 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
-#line 12260 "MachineIndependent/glslang_tab.cpp"
+#line 12412 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 649: /* translation_unit: translation_unit external_declaration  */
-#line 4221 "MachineIndependent/glslang.y"
+  case 659: /* translation_unit: translation_unit external_declaration  */
+#line 4301 "MachineIndependent/glslang.y"
                                             {
         if ((yyvsp[0].interm.intermNode) != nullptr) {
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
             parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
         }
     }
-#line 12271 "MachineIndependent/glslang_tab.cpp"
+#line 12423 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 650: /* external_declaration: function_definition  */
-#line 4230 "MachineIndependent/glslang.y"
+  case 660: /* external_declaration: function_definition  */
+#line 4310 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12279 "MachineIndependent/glslang_tab.cpp"
+#line 12431 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 651: /* external_declaration: declaration  */
-#line 4233 "MachineIndependent/glslang.y"
+  case 661: /* external_declaration: declaration  */
+#line 4313 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 12287 "MachineIndependent/glslang_tab.cpp"
+#line 12439 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 652: /* external_declaration: SEMICOLON  */
-#line 4236 "MachineIndependent/glslang.y"
+  case 662: /* external_declaration: SEMICOLON  */
+#line 4316 "MachineIndependent/glslang.y"
                 {
         parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
         parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
         (yyval.interm.intermNode) = nullptr;
     }
-#line 12297 "MachineIndependent/glslang_tab.cpp"
+#line 12449 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 653: /* $@13: %empty  */
-#line 4244 "MachineIndependent/glslang.y"
+  case 663: /* $@14: %empty  */
+#line 4324 "MachineIndependent/glslang.y"
                          {
         (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
         (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
@@ -12310,11 +12462,11 @@ yyreduce:
             ++parseContext.statementNestingLevel;
         }
     }
-#line 12314 "MachineIndependent/glslang_tab.cpp"
+#line 12466 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 654: /* function_definition: function_prototype $@13 compound_statement_no_new_scope  */
-#line 4256 "MachineIndependent/glslang.y"
+  case 664: /* function_definition: function_prototype $@14 compound_statement_no_new_scope  */
+#line 4336 "MachineIndependent/glslang.y"
                                     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -12342,228 +12494,228 @@ yyreduce:
             --parseContext.statementNestingLevel;
         }
     }
-#line 12346 "MachineIndependent/glslang_tab.cpp"
+#line 12498 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 655: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET  */
-#line 4286 "MachineIndependent/glslang.y"
+  case 665: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET  */
+#line 4366 "MachineIndependent/glslang.y"
                                                                            {
         (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
     }
-#line 12354 "MachineIndependent/glslang_tab.cpp"
+#line 12506 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 656: /* attribute_list: single_attribute  */
-#line 4291 "MachineIndependent/glslang.y"
+  case 666: /* attribute_list: single_attribute  */
+#line 4371 "MachineIndependent/glslang.y"
                        {
         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
     }
-#line 12362 "MachineIndependent/glslang_tab.cpp"
+#line 12514 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 657: /* attribute_list: attribute_list COMMA single_attribute  */
-#line 4294 "MachineIndependent/glslang.y"
+  case 667: /* attribute_list: attribute_list COMMA single_attribute  */
+#line 4374 "MachineIndependent/glslang.y"
                                             {
         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
     }
-#line 12370 "MachineIndependent/glslang_tab.cpp"
+#line 12522 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 658: /* single_attribute: IDENTIFIER  */
-#line 4299 "MachineIndependent/glslang.y"
+  case 668: /* single_attribute: IDENTIFIER  */
+#line 4379 "MachineIndependent/glslang.y"
                  {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
     }
-#line 12378 "MachineIndependent/glslang_tab.cpp"
+#line 12530 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 659: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN  */
-#line 4302 "MachineIndependent/glslang.y"
+  case 669: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN  */
+#line 4382 "MachineIndependent/glslang.y"
                                                             {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 12386 "MachineIndependent/glslang_tab.cpp"
+#line 12538 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 660: /* spirv_requirements_list: spirv_requirements_parameter  */
-#line 4307 "MachineIndependent/glslang.y"
+  case 670: /* spirv_requirements_list: spirv_requirements_parameter  */
+#line 4387 "MachineIndependent/glslang.y"
                                    {
         (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq);
     }
-#line 12394 "MachineIndependent/glslang_tab.cpp"
+#line 12546 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 661: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter  */
-#line 4310 "MachineIndependent/glslang.y"
+  case 671: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter  */
+#line 4390 "MachineIndependent/glslang.y"
                                                                  {
         (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq));
     }
-#line 12402 "MachineIndependent/glslang_tab.cpp"
+#line 12554 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 662: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET  */
-#line 4315 "MachineIndependent/glslang.y"
+  case 672: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET  */
+#line 4395 "MachineIndependent/glslang.y"
                                                                        {
         (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr);
     }
-#line 12410 "MachineIndependent/glslang_tab.cpp"
+#line 12562 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 663: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET  */
-#line 4318 "MachineIndependent/glslang.y"
+  case 673: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET  */
+#line 4398 "MachineIndependent/glslang.y"
                                                                         {
         (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12418 "MachineIndependent/glslang_tab.cpp"
+#line 12570 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 664: /* spirv_extension_list: STRING_LITERAL  */
-#line 4323 "MachineIndependent/glslang.y"
+  case 674: /* spirv_extension_list: STRING_LITERAL  */
+#line 4403 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
     }
-#line 12426 "MachineIndependent/glslang_tab.cpp"
+#line 12578 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 665: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL  */
-#line 4326 "MachineIndependent/glslang.y"
+  case 675: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL  */
+#line 4406 "MachineIndependent/glslang.y"
                                                 {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
     }
-#line 12434 "MachineIndependent/glslang_tab.cpp"
+#line 12586 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 666: /* spirv_capability_list: INTCONSTANT  */
-#line 4331 "MachineIndependent/glslang.y"
+  case 676: /* spirv_capability_list: INTCONSTANT  */
+#line 4411 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true));
     }
-#line 12442 "MachineIndependent/glslang_tab.cpp"
+#line 12594 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 667: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT  */
-#line 4334 "MachineIndependent/glslang.y"
+  case 677: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT  */
+#line 4414 "MachineIndependent/glslang.y"
                                               {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true));
     }
-#line 12450 "MachineIndependent/glslang_tab.cpp"
+#line 12602 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 668: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
-#line 4339 "MachineIndependent/glslang.y"
+  case 678: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4419 "MachineIndependent/glslang.y"
                                                               {
         parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i);
         (yyval.interm.intermNode) = 0;
     }
-#line 12459 "MachineIndependent/glslang_tab.cpp"
+#line 12611 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 669: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
-#line 4343 "MachineIndependent/glslang.y"
+  case 679: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4423 "MachineIndependent/glslang.y"
                                                                                             {
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
         parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i);
         (yyval.interm.intermNode) = 0;
     }
-#line 12469 "MachineIndependent/glslang_tab.cpp"
+#line 12621 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 670: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
-#line 4348 "MachineIndependent/glslang.y"
+  case 680: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
+#line 4428 "MachineIndependent/glslang.y"
                                                                                                         {
         parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
         (yyval.interm.intermNode) = 0;
     }
-#line 12478 "MachineIndependent/glslang_tab.cpp"
+#line 12630 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 671: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
-#line 4352 "MachineIndependent/glslang.y"
+  case 681: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN  */
+#line 4432 "MachineIndependent/glslang.y"
                                                                                                                                       {
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
         (yyval.interm.intermNode) = 0;
     }
-#line 12488 "MachineIndependent/glslang_tab.cpp"
+#line 12640 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 672: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
-#line 4357 "MachineIndependent/glslang.y"
+  case 682: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
+#line 4437 "MachineIndependent/glslang.y"
                                                                                                               {
         parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
         (yyval.interm.intermNode) = 0;
     }
-#line 12497 "MachineIndependent/glslang_tab.cpp"
+#line 12649 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 673: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
-#line 4361 "MachineIndependent/glslang.y"
+  case 683: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN  */
+#line 4441 "MachineIndependent/glslang.y"
                                                                                                                                             {
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
         (yyval.interm.intermNode) = 0;
     }
-#line 12507 "MachineIndependent/glslang_tab.cpp"
+#line 12659 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 674: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter  */
-#line 4368 "MachineIndependent/glslang.y"
+  case 684: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter  */
+#line 4448 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
     }
-#line 12515 "MachineIndependent/glslang_tab.cpp"
+#line 12667 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 675: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter  */
-#line 4371 "MachineIndependent/glslang.y"
+  case 685: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter  */
+#line 4451 "MachineIndependent/glslang.y"
                                                                                {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 12523 "MachineIndependent/glslang_tab.cpp"
+#line 12675 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 676: /* spirv_execution_mode_parameter: FLOATCONSTANT  */
-#line 4376 "MachineIndependent/glslang.y"
+  case 686: /* spirv_execution_mode_parameter: FLOATCONSTANT  */
+#line 4456 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 12531 "MachineIndependent/glslang_tab.cpp"
+#line 12683 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 677: /* spirv_execution_mode_parameter: INTCONSTANT  */
-#line 4379 "MachineIndependent/glslang.y"
+  case 687: /* spirv_execution_mode_parameter: INTCONSTANT  */
+#line 4459 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 12539 "MachineIndependent/glslang_tab.cpp"
+#line 12691 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 678: /* spirv_execution_mode_parameter: UINTCONSTANT  */
-#line 4382 "MachineIndependent/glslang.y"
+  case 688: /* spirv_execution_mode_parameter: UINTCONSTANT  */
+#line 4462 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 12547 "MachineIndependent/glslang_tab.cpp"
+#line 12699 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 679: /* spirv_execution_mode_parameter: BOOLCONSTANT  */
-#line 4385 "MachineIndependent/glslang.y"
+  case 689: /* spirv_execution_mode_parameter: BOOLCONSTANT  */
+#line 4465 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 12555 "MachineIndependent/glslang_tab.cpp"
+#line 12707 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 680: /* spirv_execution_mode_parameter: STRING_LITERAL  */
-#line 4388 "MachineIndependent/glslang.y"
+  case 690: /* spirv_execution_mode_parameter: STRING_LITERAL  */
+#line 4468 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
     }
-#line 12563 "MachineIndependent/glslang_tab.cpp"
+#line 12715 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 681: /* spirv_execution_mode_id_parameter_list: constant_expression  */
-#line 4393 "MachineIndependent/glslang.y"
+  case 691: /* spirv_execution_mode_id_parameter_list: constant_expression  */
+#line 4473 "MachineIndependent/glslang.y"
                           {
         if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
             (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
@@ -12573,11 +12725,11 @@ yyreduce:
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode));
     }
-#line 12577 "MachineIndependent/glslang_tab.cpp"
+#line 12729 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 682: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression  */
-#line 4402 "MachineIndependent/glslang.y"
+  case 692: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression  */
+#line 4482 "MachineIndependent/glslang.y"
                                                                        {
         if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat &&
             (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt &&
@@ -12587,351 +12739,351 @@ yyreduce:
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), "");
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 12591 "MachineIndependent/glslang_tab.cpp"
+#line 12743 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 683: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
-#line 4413 "MachineIndependent/glslang.y"
+  case 693: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4493 "MachineIndependent/glslang.y"
                                                              {
         (yyval.interm.type).init((yyvsp[-3].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass;
         (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i;
     }
-#line 12601 "MachineIndependent/glslang_tab.cpp"
+#line 12753 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 684: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
-#line 4418 "MachineIndependent/glslang.y"
+  case 694: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4498 "MachineIndependent/glslang.y"
                                                                                            {
         (yyval.interm.type).init((yyvsp[-5].lex).loc);
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
         (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass;
         (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i;
     }
-#line 12612 "MachineIndependent/glslang_tab.cpp"
+#line 12764 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 685: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
-#line 4426 "MachineIndependent/glslang.y"
+  case 695: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN  */
+#line 4506 "MachineIndependent/glslang.y"
                                                        {
         (yyval.interm.type).init((yyvsp[-3].lex).loc);
         (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i);
     }
-#line 12621 "MachineIndependent/glslang_tab.cpp"
+#line 12773 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 686: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
-#line 4430 "MachineIndependent/glslang.y"
+  case 696: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN  */
+#line 4510 "MachineIndependent/glslang.y"
                                                                                      {
         (yyval.interm.type).init((yyvsp[-5].lex).loc);
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
         (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i);
     }
-#line 12631 "MachineIndependent/glslang_tab.cpp"
+#line 12783 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 687: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
-#line 4435 "MachineIndependent/glslang.y"
+  case 697: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
+#line 4515 "MachineIndependent/glslang.y"
                                                                                             {
         (yyval.interm.type).init((yyvsp[-5].lex).loc);
         (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12640 "MachineIndependent/glslang_tab.cpp"
+#line 12792 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 688: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
-#line 4439 "MachineIndependent/glslang.y"
+  case 698: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN  */
+#line 4519 "MachineIndependent/glslang.y"
                                                                                                                           {
         (yyval.interm.type).init((yyvsp[-7].lex).loc);
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12650 "MachineIndependent/glslang_tab.cpp"
+#line 12802 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 689: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
-#line 4444 "MachineIndependent/glslang.y"
+  case 699: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
+#line 4524 "MachineIndependent/glslang.y"
                                                                                                   {
         (yyval.interm.type).init((yyvsp[-5].lex).loc);
         (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12659 "MachineIndependent/glslang_tab.cpp"
+#line 12811 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 690: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
-#line 4448 "MachineIndependent/glslang.y"
+  case 700: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN  */
+#line 4528 "MachineIndependent/glslang.y"
                                                                                                                                 {
         (yyval.interm.type).init((yyvsp[-7].lex).loc);
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12669 "MachineIndependent/glslang_tab.cpp"
+#line 12821 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 691: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
-#line 4453 "MachineIndependent/glslang.y"
+  case 701: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
+#line 4533 "MachineIndependent/glslang.y"
                                                                                                           {
         (yyval.interm.type).init((yyvsp[-5].lex).loc);
         (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12678 "MachineIndependent/glslang_tab.cpp"
+#line 12830 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 692: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
-#line 4457 "MachineIndependent/glslang.y"
+  case 702: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN  */
+#line 4537 "MachineIndependent/glslang.y"
                                                                                                                                         {
         (yyval.interm.type).init((yyvsp[-7].lex).loc);
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate());
     }
-#line 12688 "MachineIndependent/glslang_tab.cpp"
+#line 12840 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 693: /* spirv_decorate_parameter_list: spirv_decorate_parameter  */
-#line 4464 "MachineIndependent/glslang.y"
+  case 703: /* spirv_decorate_parameter_list: spirv_decorate_parameter  */
+#line 4544 "MachineIndependent/glslang.y"
                                {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
     }
-#line 12696 "MachineIndependent/glslang_tab.cpp"
+#line 12848 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 694: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter  */
-#line 4467 "MachineIndependent/glslang.y"
+  case 704: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter  */
+#line 4547 "MachineIndependent/glslang.y"
                                                                    {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 12704 "MachineIndependent/glslang_tab.cpp"
+#line 12856 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 695: /* spirv_decorate_parameter: FLOATCONSTANT  */
-#line 4472 "MachineIndependent/glslang.y"
+  case 705: /* spirv_decorate_parameter: FLOATCONSTANT  */
+#line 4552 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 12712 "MachineIndependent/glslang_tab.cpp"
+#line 12864 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 696: /* spirv_decorate_parameter: INTCONSTANT  */
-#line 4475 "MachineIndependent/glslang.y"
+  case 706: /* spirv_decorate_parameter: INTCONSTANT  */
+#line 4555 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 12720 "MachineIndependent/glslang_tab.cpp"
+#line 12872 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 697: /* spirv_decorate_parameter: UINTCONSTANT  */
-#line 4478 "MachineIndependent/glslang.y"
+  case 707: /* spirv_decorate_parameter: UINTCONSTANT  */
+#line 4558 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 12728 "MachineIndependent/glslang_tab.cpp"
+#line 12880 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 698: /* spirv_decorate_parameter: BOOLCONSTANT  */
-#line 4481 "MachineIndependent/glslang.y"
+  case 708: /* spirv_decorate_parameter: BOOLCONSTANT  */
+#line 4561 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 12736 "MachineIndependent/glslang_tab.cpp"
+#line 12888 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 699: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter  */
-#line 4486 "MachineIndependent/glslang.y"
+  case 709: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter  */
+#line 4566 "MachineIndependent/glslang.y"
                                   {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
     }
-#line 12744 "MachineIndependent/glslang_tab.cpp"
+#line 12896 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 700: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter  */
-#line 4489 "MachineIndependent/glslang.y"
+  case 710: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter  */
+#line 4569 "MachineIndependent/glslang.y"
                                                                          {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 12752 "MachineIndependent/glslang_tab.cpp"
+#line 12904 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 701: /* spirv_decorate_id_parameter: variable_identifier  */
-#line 4494 "MachineIndependent/glslang.y"
+  case 711: /* spirv_decorate_id_parameter: variable_identifier  */
+#line 4574 "MachineIndependent/glslang.y"
                           {
         if ((yyvsp[0].interm.intermTypedNode)->getAsConstantUnion() || (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode())
             (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode);
         else
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "only allow constants or variables which are not elements of a composite", "", "");
     }
-#line 12763 "MachineIndependent/glslang_tab.cpp"
+#line 12915 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 702: /* spirv_decorate_id_parameter: FLOATCONSTANT  */
-#line 4500 "MachineIndependent/glslang.y"
+  case 712: /* spirv_decorate_id_parameter: FLOATCONSTANT  */
+#line 4580 "MachineIndependent/glslang.y"
                     {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 12771 "MachineIndependent/glslang_tab.cpp"
+#line 12923 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 703: /* spirv_decorate_id_parameter: INTCONSTANT  */
-#line 4503 "MachineIndependent/glslang.y"
+  case 713: /* spirv_decorate_id_parameter: INTCONSTANT  */
+#line 4583 "MachineIndependent/glslang.y"
                   {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 12779 "MachineIndependent/glslang_tab.cpp"
+#line 12931 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 704: /* spirv_decorate_id_parameter: UINTCONSTANT  */
-#line 4506 "MachineIndependent/glslang.y"
+  case 714: /* spirv_decorate_id_parameter: UINTCONSTANT  */
+#line 4586 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 12787 "MachineIndependent/glslang_tab.cpp"
+#line 12939 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 705: /* spirv_decorate_id_parameter: BOOLCONSTANT  */
-#line 4509 "MachineIndependent/glslang.y"
+  case 715: /* spirv_decorate_id_parameter: BOOLCONSTANT  */
+#line 4589 "MachineIndependent/glslang.y"
                    {
         (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 12795 "MachineIndependent/glslang_tab.cpp"
+#line 12947 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 706: /* spirv_decorate_string_parameter_list: STRING_LITERAL  */
-#line 4514 "MachineIndependent/glslang.y"
+  case 716: /* spirv_decorate_string_parameter_list: STRING_LITERAL  */
+#line 4594 "MachineIndependent/glslang.y"
                      {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(
             parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
     }
-#line 12804 "MachineIndependent/glslang_tab.cpp"
+#line 12956 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 707: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL  */
-#line 4518 "MachineIndependent/glslang.y"
+  case 717: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL  */
+#line 4598 "MachineIndependent/glslang.y"
                                                                 {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true));
     }
-#line 12812 "MachineIndependent/glslang_tab.cpp"
+#line 12964 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 708: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
-#line 4523 "MachineIndependent/glslang.y"
+  case 718: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
+#line 4603 "MachineIndependent/glslang.y"
                                                                                                          {
         (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams));
     }
-#line 12821 "MachineIndependent/glslang_tab.cpp"
+#line 12973 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 709: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
-#line 4527 "MachineIndependent/glslang.y"
+  case 719: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN  */
+#line 4607 "MachineIndependent/glslang.y"
                                                                                                                                        {
         (yyval.interm.type).init((yyvsp[-7].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq));
         (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams));
     }
-#line 12831 "MachineIndependent/glslang_tab.cpp"
+#line 12983 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 710: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
-#line 4532 "MachineIndependent/glslang.y"
+  case 720: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4612 "MachineIndependent/glslang.y"
                                                                          {
         (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst));
     }
-#line 12840 "MachineIndependent/glslang_tab.cpp"
+#line 12992 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 711: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
-#line 4536 "MachineIndependent/glslang.y"
+  case 721: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4616 "MachineIndependent/glslang.y"
                                                                                                        {
         (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
         (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst));
     }
-#line 12850 "MachineIndependent/glslang_tab.cpp"
+#line 13002 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 712: /* spirv_type_parameter_list: spirv_type_parameter  */
-#line 4543 "MachineIndependent/glslang.y"
+  case 722: /* spirv_type_parameter_list: spirv_type_parameter  */
+#line 4623 "MachineIndependent/glslang.y"
                            {
         (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams);
     }
-#line 12858 "MachineIndependent/glslang_tab.cpp"
+#line 13010 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 713: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter  */
-#line 4546 "MachineIndependent/glslang.y"
+  case 723: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter  */
+#line 4626 "MachineIndependent/glslang.y"
                                                            {
         (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams));
     }
-#line 12866 "MachineIndependent/glslang_tab.cpp"
+#line 13018 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 714: /* spirv_type_parameter: constant_expression  */
-#line 4551 "MachineIndependent/glslang.y"
+  case 724: /* spirv_type_parameter: constant_expression  */
+#line 4631 "MachineIndependent/glslang.y"
                           {
         (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion());
     }
-#line 12874 "MachineIndependent/glslang_tab.cpp"
+#line 13026 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 715: /* spirv_type_parameter: type_specifier_nonarray  */
-#line 4554 "MachineIndependent/glslang.y"
+  case 725: /* spirv_type_parameter: type_specifier_nonarray  */
+#line 4634 "MachineIndependent/glslang.y"
                               {
         (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 12882 "MachineIndependent/glslang_tab.cpp"
+#line 13034 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 716: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
-#line 4559 "MachineIndependent/glslang.y"
+  case 726: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4639 "MachineIndependent/glslang.y"
                                                                                 {
         (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst);
     }
-#line 12890 "MachineIndependent/glslang_tab.cpp"
+#line 13042 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 717: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
-#line 4562 "MachineIndependent/glslang.y"
+  case 727: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN  */
+#line 4642 "MachineIndependent/glslang.y"
                                                                                                               {
         parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq));
         (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst);
     }
-#line 12899 "MachineIndependent/glslang_tab.cpp"
+#line 13051 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 718: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id  */
-#line 4568 "MachineIndependent/glslang.y"
+  case 728: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id  */
+#line 4648 "MachineIndependent/glslang.y"
                                      {
         (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst);
     }
-#line 12907 "MachineIndependent/glslang_tab.cpp"
+#line 13059 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 719: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id  */
-#line 4571 "MachineIndependent/glslang.y"
+  case 729: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id  */
+#line 4651 "MachineIndependent/glslang.y"
                                                                             {
         (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst));
     }
-#line 12915 "MachineIndependent/glslang_tab.cpp"
+#line 13067 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 720: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL  */
-#line 4576 "MachineIndependent/glslang.y"
+  case 730: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL  */
+#line 4656 "MachineIndependent/glslang.y"
                                       {
         (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string);
     }
-#line 12923 "MachineIndependent/glslang_tab.cpp"
+#line 13075 "MachineIndependent/glslang_tab.cpp"
     break;
 
-  case 721: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT  */
-#line 4579 "MachineIndependent/glslang.y"
+  case 731: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT  */
+#line 4659 "MachineIndependent/glslang.y"
                                    {
         (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i);
     }
-#line 12931 "MachineIndependent/glslang_tab.cpp"
+#line 13083 "MachineIndependent/glslang_tab.cpp"
     break;
 
 
-#line 12935 "MachineIndependent/glslang_tab.cpp"
+#line 13087 "MachineIndependent/glslang_tab.cpp"
 
       default: break;
     }
@@ -13155,5 +13307,5 @@ yyreturnlab:
   return yyresult;
 }
 
-#line 4583 "MachineIndependent/glslang.y"
+#line 4663 "MachineIndependent/glslang.y"
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h
index f90f704d4..11932ead0 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -231,311 +231,314 @@ extern int yydebug;
     UCOOPMATNV = 432,              /* UCOOPMATNV  */
     COOPMAT = 433,                 /* COOPMAT  */
     COOPVECNV = 434,               /* COOPVECNV  */
-    HITOBJECTNV = 435,             /* HITOBJECTNV  */
-    HITOBJECTATTRNV = 436,         /* HITOBJECTATTRNV  */
-    HITOBJECTEXT = 437,            /* HITOBJECTEXT  */
-    HITOBJECTATTREXT = 438,        /* HITOBJECTATTREXT  */
-    TENSORLAYOUTNV = 439,          /* TENSORLAYOUTNV  */
-    TENSORVIEWNV = 440,            /* TENSORVIEWNV  */
-    TENSORARM = 441,               /* TENSORARM  */
-    SAMPLERCUBEARRAY = 442,        /* SAMPLERCUBEARRAY  */
-    SAMPLERCUBEARRAYSHADOW = 443,  /* SAMPLERCUBEARRAYSHADOW  */
-    ISAMPLERCUBEARRAY = 444,       /* ISAMPLERCUBEARRAY  */
-    USAMPLERCUBEARRAY = 445,       /* USAMPLERCUBEARRAY  */
-    SAMPLER1D = 446,               /* SAMPLER1D  */
-    SAMPLER1DARRAY = 447,          /* SAMPLER1DARRAY  */
-    SAMPLER1DARRAYSHADOW = 448,    /* SAMPLER1DARRAYSHADOW  */
-    ISAMPLER1D = 449,              /* ISAMPLER1D  */
-    SAMPLER1DSHADOW = 450,         /* SAMPLER1DSHADOW  */
-    SAMPLER2DRECT = 451,           /* SAMPLER2DRECT  */
-    SAMPLER2DRECTSHADOW = 452,     /* SAMPLER2DRECTSHADOW  */
-    ISAMPLER2DRECT = 453,          /* ISAMPLER2DRECT  */
-    USAMPLER2DRECT = 454,          /* USAMPLER2DRECT  */
-    SAMPLERBUFFER = 455,           /* SAMPLERBUFFER  */
-    ISAMPLERBUFFER = 456,          /* ISAMPLERBUFFER  */
-    USAMPLERBUFFER = 457,          /* USAMPLERBUFFER  */
-    SAMPLER2DMS = 458,             /* SAMPLER2DMS  */
-    ISAMPLER2DMS = 459,            /* ISAMPLER2DMS  */
-    USAMPLER2DMS = 460,            /* USAMPLER2DMS  */
-    SAMPLER2DMSARRAY = 461,        /* SAMPLER2DMSARRAY  */
-    ISAMPLER2DMSARRAY = 462,       /* ISAMPLER2DMSARRAY  */
-    USAMPLER2DMSARRAY = 463,       /* USAMPLER2DMSARRAY  */
-    SAMPLEREXTERNALOES = 464,      /* SAMPLEREXTERNALOES  */
-    SAMPLEREXTERNAL2DY2YEXT = 465, /* SAMPLEREXTERNAL2DY2YEXT  */
-    ISAMPLER1DARRAY = 466,         /* ISAMPLER1DARRAY  */
-    USAMPLER1D = 467,              /* USAMPLER1D  */
-    USAMPLER1DARRAY = 468,         /* USAMPLER1DARRAY  */
-    F16SAMPLER1D = 469,            /* F16SAMPLER1D  */
-    F16SAMPLER2D = 470,            /* F16SAMPLER2D  */
-    F16SAMPLER3D = 471,            /* F16SAMPLER3D  */
-    F16SAMPLER2DRECT = 472,        /* F16SAMPLER2DRECT  */
-    F16SAMPLERCUBE = 473,          /* F16SAMPLERCUBE  */
-    F16SAMPLER1DARRAY = 474,       /* F16SAMPLER1DARRAY  */
-    F16SAMPLER2DARRAY = 475,       /* F16SAMPLER2DARRAY  */
-    F16SAMPLERCUBEARRAY = 476,     /* F16SAMPLERCUBEARRAY  */
-    F16SAMPLERBUFFER = 477,        /* F16SAMPLERBUFFER  */
-    F16SAMPLER2DMS = 478,          /* F16SAMPLER2DMS  */
-    F16SAMPLER2DMSARRAY = 479,     /* F16SAMPLER2DMSARRAY  */
-    F16SAMPLER1DSHADOW = 480,      /* F16SAMPLER1DSHADOW  */
-    F16SAMPLER2DSHADOW = 481,      /* F16SAMPLER2DSHADOW  */
-    F16SAMPLER1DARRAYSHADOW = 482, /* F16SAMPLER1DARRAYSHADOW  */
-    F16SAMPLER2DARRAYSHADOW = 483, /* F16SAMPLER2DARRAYSHADOW  */
-    F16SAMPLER2DRECTSHADOW = 484,  /* F16SAMPLER2DRECTSHADOW  */
-    F16SAMPLERCUBESHADOW = 485,    /* F16SAMPLERCUBESHADOW  */
-    F16SAMPLERCUBEARRAYSHADOW = 486, /* F16SAMPLERCUBEARRAYSHADOW  */
-    IMAGE1D = 487,                 /* IMAGE1D  */
-    IIMAGE1D = 488,                /* IIMAGE1D  */
-    UIMAGE1D = 489,                /* UIMAGE1D  */
-    IMAGE2D = 490,                 /* IMAGE2D  */
-    IIMAGE2D = 491,                /* IIMAGE2D  */
-    UIMAGE2D = 492,                /* UIMAGE2D  */
-    IMAGE3D = 493,                 /* IMAGE3D  */
-    IIMAGE3D = 494,                /* IIMAGE3D  */
-    UIMAGE3D = 495,                /* UIMAGE3D  */
-    IMAGE2DRECT = 496,             /* IMAGE2DRECT  */
-    IIMAGE2DRECT = 497,            /* IIMAGE2DRECT  */
-    UIMAGE2DRECT = 498,            /* UIMAGE2DRECT  */
-    IMAGECUBE = 499,               /* IMAGECUBE  */
-    IIMAGECUBE = 500,              /* IIMAGECUBE  */
-    UIMAGECUBE = 501,              /* UIMAGECUBE  */
-    IMAGEBUFFER = 502,             /* IMAGEBUFFER  */
-    IIMAGEBUFFER = 503,            /* IIMAGEBUFFER  */
-    UIMAGEBUFFER = 504,            /* UIMAGEBUFFER  */
-    IMAGE1DARRAY = 505,            /* IMAGE1DARRAY  */
-    IIMAGE1DARRAY = 506,           /* IIMAGE1DARRAY  */
-    UIMAGE1DARRAY = 507,           /* UIMAGE1DARRAY  */
-    IMAGE2DARRAY = 508,            /* IMAGE2DARRAY  */
-    IIMAGE2DARRAY = 509,           /* IIMAGE2DARRAY  */
-    UIMAGE2DARRAY = 510,           /* UIMAGE2DARRAY  */
-    IMAGECUBEARRAY = 511,          /* IMAGECUBEARRAY  */
-    IIMAGECUBEARRAY = 512,         /* IIMAGECUBEARRAY  */
-    UIMAGECUBEARRAY = 513,         /* UIMAGECUBEARRAY  */
-    IMAGE2DMS = 514,               /* IMAGE2DMS  */
-    IIMAGE2DMS = 515,              /* IIMAGE2DMS  */
-    UIMAGE2DMS = 516,              /* UIMAGE2DMS  */
-    IMAGE2DMSARRAY = 517,          /* IMAGE2DMSARRAY  */
-    IIMAGE2DMSARRAY = 518,         /* IIMAGE2DMSARRAY  */
-    UIMAGE2DMSARRAY = 519,         /* UIMAGE2DMSARRAY  */
-    F16IMAGE1D = 520,              /* F16IMAGE1D  */
-    F16IMAGE2D = 521,              /* F16IMAGE2D  */
-    F16IMAGE3D = 522,              /* F16IMAGE3D  */
-    F16IMAGE2DRECT = 523,          /* F16IMAGE2DRECT  */
-    F16IMAGECUBE = 524,            /* F16IMAGECUBE  */
-    F16IMAGE1DARRAY = 525,         /* F16IMAGE1DARRAY  */
-    F16IMAGE2DARRAY = 526,         /* F16IMAGE2DARRAY  */
-    F16IMAGECUBEARRAY = 527,       /* F16IMAGECUBEARRAY  */
-    F16IMAGEBUFFER = 528,          /* F16IMAGEBUFFER  */
-    F16IMAGE2DMS = 529,            /* F16IMAGE2DMS  */
-    F16IMAGE2DMSARRAY = 530,       /* F16IMAGE2DMSARRAY  */
-    I64IMAGE1D = 531,              /* I64IMAGE1D  */
-    U64IMAGE1D = 532,              /* U64IMAGE1D  */
-    I64IMAGE2D = 533,              /* I64IMAGE2D  */
-    U64IMAGE2D = 534,              /* U64IMAGE2D  */
-    I64IMAGE3D = 535,              /* I64IMAGE3D  */
-    U64IMAGE3D = 536,              /* U64IMAGE3D  */
-    I64IMAGE2DRECT = 537,          /* I64IMAGE2DRECT  */
-    U64IMAGE2DRECT = 538,          /* U64IMAGE2DRECT  */
-    I64IMAGECUBE = 539,            /* I64IMAGECUBE  */
-    U64IMAGECUBE = 540,            /* U64IMAGECUBE  */
-    I64IMAGEBUFFER = 541,          /* I64IMAGEBUFFER  */
-    U64IMAGEBUFFER = 542,          /* U64IMAGEBUFFER  */
-    I64IMAGE1DARRAY = 543,         /* I64IMAGE1DARRAY  */
-    U64IMAGE1DARRAY = 544,         /* U64IMAGE1DARRAY  */
-    I64IMAGE2DARRAY = 545,         /* I64IMAGE2DARRAY  */
-    U64IMAGE2DARRAY = 546,         /* U64IMAGE2DARRAY  */
-    I64IMAGECUBEARRAY = 547,       /* I64IMAGECUBEARRAY  */
-    U64IMAGECUBEARRAY = 548,       /* U64IMAGECUBEARRAY  */
-    I64IMAGE2DMS = 549,            /* I64IMAGE2DMS  */
-    U64IMAGE2DMS = 550,            /* U64IMAGE2DMS  */
-    I64IMAGE2DMSARRAY = 551,       /* I64IMAGE2DMSARRAY  */
-    U64IMAGE2DMSARRAY = 552,       /* U64IMAGE2DMSARRAY  */
-    TEXTURECUBEARRAY = 553,        /* TEXTURECUBEARRAY  */
-    ITEXTURECUBEARRAY = 554,       /* ITEXTURECUBEARRAY  */
-    UTEXTURECUBEARRAY = 555,       /* UTEXTURECUBEARRAY  */
-    TEXTURE1D = 556,               /* TEXTURE1D  */
-    ITEXTURE1D = 557,              /* ITEXTURE1D  */
-    UTEXTURE1D = 558,              /* UTEXTURE1D  */
-    TEXTURE1DARRAY = 559,          /* TEXTURE1DARRAY  */
-    ITEXTURE1DARRAY = 560,         /* ITEXTURE1DARRAY  */
-    UTEXTURE1DARRAY = 561,         /* UTEXTURE1DARRAY  */
-    TEXTURE2DRECT = 562,           /* TEXTURE2DRECT  */
-    ITEXTURE2DRECT = 563,          /* ITEXTURE2DRECT  */
-    UTEXTURE2DRECT = 564,          /* UTEXTURE2DRECT  */
-    TEXTUREBUFFER = 565,           /* TEXTUREBUFFER  */
-    ITEXTUREBUFFER = 566,          /* ITEXTUREBUFFER  */
-    UTEXTUREBUFFER = 567,          /* UTEXTUREBUFFER  */
-    TEXTURE2DMS = 568,             /* TEXTURE2DMS  */
-    ITEXTURE2DMS = 569,            /* ITEXTURE2DMS  */
-    UTEXTURE2DMS = 570,            /* UTEXTURE2DMS  */
-    TEXTURE2DMSARRAY = 571,        /* TEXTURE2DMSARRAY  */
-    ITEXTURE2DMSARRAY = 572,       /* ITEXTURE2DMSARRAY  */
-    UTEXTURE2DMSARRAY = 573,       /* UTEXTURE2DMSARRAY  */
-    F16TEXTURE1D = 574,            /* F16TEXTURE1D  */
-    F16TEXTURE2D = 575,            /* F16TEXTURE2D  */
-    F16TEXTURE3D = 576,            /* F16TEXTURE3D  */
-    F16TEXTURE2DRECT = 577,        /* F16TEXTURE2DRECT  */
-    F16TEXTURECUBE = 578,          /* F16TEXTURECUBE  */
-    F16TEXTURE1DARRAY = 579,       /* F16TEXTURE1DARRAY  */
-    F16TEXTURE2DARRAY = 580,       /* F16TEXTURE2DARRAY  */
-    F16TEXTURECUBEARRAY = 581,     /* F16TEXTURECUBEARRAY  */
-    F16TEXTUREBUFFER = 582,        /* F16TEXTUREBUFFER  */
-    F16TEXTURE2DMS = 583,          /* F16TEXTURE2DMS  */
-    F16TEXTURE2DMSARRAY = 584,     /* F16TEXTURE2DMSARRAY  */
-    SUBPASSINPUT = 585,            /* SUBPASSINPUT  */
-    SUBPASSINPUTMS = 586,          /* SUBPASSINPUTMS  */
-    ISUBPASSINPUT = 587,           /* ISUBPASSINPUT  */
-    ISUBPASSINPUTMS = 588,         /* ISUBPASSINPUTMS  */
-    USUBPASSINPUT = 589,           /* USUBPASSINPUT  */
-    USUBPASSINPUTMS = 590,         /* USUBPASSINPUTMS  */
-    F16SUBPASSINPUT = 591,         /* F16SUBPASSINPUT  */
-    F16SUBPASSINPUTMS = 592,       /* F16SUBPASSINPUTMS  */
-    SPIRV_INSTRUCTION = 593,       /* SPIRV_INSTRUCTION  */
-    SPIRV_EXECUTION_MODE = 594,    /* SPIRV_EXECUTION_MODE  */
-    SPIRV_EXECUTION_MODE_ID = 595, /* SPIRV_EXECUTION_MODE_ID  */
-    SPIRV_DECORATE = 596,          /* SPIRV_DECORATE  */
-    SPIRV_DECORATE_ID = 597,       /* SPIRV_DECORATE_ID  */
-    SPIRV_DECORATE_STRING = 598,   /* SPIRV_DECORATE_STRING  */
-    SPIRV_TYPE = 599,              /* SPIRV_TYPE  */
-    SPIRV_STORAGE_CLASS = 600,     /* SPIRV_STORAGE_CLASS  */
-    SPIRV_BY_REFERENCE = 601,      /* SPIRV_BY_REFERENCE  */
-    SPIRV_LITERAL = 602,           /* SPIRV_LITERAL  */
-    ATTACHMENTEXT = 603,           /* ATTACHMENTEXT  */
-    IATTACHMENTEXT = 604,          /* IATTACHMENTEXT  */
-    UATTACHMENTEXT = 605,          /* UATTACHMENTEXT  */
-    LEFT_OP = 606,                 /* LEFT_OP  */
-    RIGHT_OP = 607,                /* RIGHT_OP  */
-    INC_OP = 608,                  /* INC_OP  */
-    DEC_OP = 609,                  /* DEC_OP  */
-    LE_OP = 610,                   /* LE_OP  */
-    GE_OP = 611,                   /* GE_OP  */
-    EQ_OP = 612,                   /* EQ_OP  */
-    NE_OP = 613,                   /* NE_OP  */
-    AND_OP = 614,                  /* AND_OP  */
-    OR_OP = 615,                   /* OR_OP  */
-    XOR_OP = 616,                  /* XOR_OP  */
-    MUL_ASSIGN = 617,              /* MUL_ASSIGN  */
-    DIV_ASSIGN = 618,              /* DIV_ASSIGN  */
-    ADD_ASSIGN = 619,              /* ADD_ASSIGN  */
-    MOD_ASSIGN = 620,              /* MOD_ASSIGN  */
-    LEFT_ASSIGN = 621,             /* LEFT_ASSIGN  */
-    RIGHT_ASSIGN = 622,            /* RIGHT_ASSIGN  */
-    AND_ASSIGN = 623,              /* AND_ASSIGN  */
-    XOR_ASSIGN = 624,              /* XOR_ASSIGN  */
-    OR_ASSIGN = 625,               /* OR_ASSIGN  */
-    SUB_ASSIGN = 626,              /* SUB_ASSIGN  */
-    STRING_LITERAL = 627,          /* STRING_LITERAL  */
-    LEFT_PAREN = 628,              /* LEFT_PAREN  */
-    RIGHT_PAREN = 629,             /* RIGHT_PAREN  */
-    LEFT_BRACKET = 630,            /* LEFT_BRACKET  */
-    RIGHT_BRACKET = 631,           /* RIGHT_BRACKET  */
-    LEFT_BRACE = 632,              /* LEFT_BRACE  */
-    RIGHT_BRACE = 633,             /* RIGHT_BRACE  */
-    DOT = 634,                     /* DOT  */
-    COMMA = 635,                   /* COMMA  */
-    COLON = 636,                   /* COLON  */
-    EQUAL = 637,                   /* EQUAL  */
-    SEMICOLON = 638,               /* SEMICOLON  */
-    BANG = 639,                    /* BANG  */
-    DASH = 640,                    /* DASH  */
-    TILDE = 641,                   /* TILDE  */
-    PLUS = 642,                    /* PLUS  */
-    STAR = 643,                    /* STAR  */
-    SLASH = 644,                   /* SLASH  */
-    PERCENT = 645,                 /* PERCENT  */
-    LEFT_ANGLE = 646,              /* LEFT_ANGLE  */
-    RIGHT_ANGLE = 647,             /* RIGHT_ANGLE  */
-    VERTICAL_BAR = 648,            /* VERTICAL_BAR  */
-    CARET = 649,                   /* CARET  */
-    AMPERSAND = 650,               /* AMPERSAND  */
-    QUESTION = 651,                /* QUESTION  */
-    INVARIANT = 652,               /* INVARIANT  */
-    HIGH_PRECISION = 653,          /* HIGH_PRECISION  */
-    MEDIUM_PRECISION = 654,        /* MEDIUM_PRECISION  */
-    LOW_PRECISION = 655,           /* LOW_PRECISION  */
-    PRECISION = 656,               /* PRECISION  */
-    PACKED = 657,                  /* PACKED  */
-    RESOURCE = 658,                /* RESOURCE  */
-    SUPERP = 659,                  /* SUPERP  */
-    FLOATCONSTANT = 660,           /* FLOATCONSTANT  */
-    INTCONSTANT = 661,             /* INTCONSTANT  */
-    UINTCONSTANT = 662,            /* UINTCONSTANT  */
-    BOOLCONSTANT = 663,            /* BOOLCONSTANT  */
-    IDENTIFIER = 664,              /* IDENTIFIER  */
-    TYPE_NAME = 665,               /* TYPE_NAME  */
-    CENTROID = 666,                /* CENTROID  */
-    IN = 667,                      /* IN  */
-    OUT = 668,                     /* OUT  */
-    INOUT = 669,                   /* INOUT  */
-    STRUCT = 670,                  /* STRUCT  */
-    VOID = 671,                    /* VOID  */
-    WHILE = 672,                   /* WHILE  */
-    BREAK = 673,                   /* BREAK  */
-    CONTINUE = 674,                /* CONTINUE  */
-    DO = 675,                      /* DO  */
-    ELSE = 676,                    /* ELSE  */
-    FOR = 677,                     /* FOR  */
-    IF = 678,                      /* IF  */
-    DISCARD = 679,                 /* DISCARD  */
-    RETURN = 680,                  /* RETURN  */
-    SWITCH = 681,                  /* SWITCH  */
-    CASE = 682,                    /* CASE  */
-    DEFAULT = 683,                 /* DEFAULT  */
-    TERMINATE_INVOCATION = 684,    /* TERMINATE_INVOCATION  */
-    TERMINATE_RAY = 685,           /* TERMINATE_RAY  */
-    IGNORE_INTERSECTION = 686,     /* IGNORE_INTERSECTION  */
-    UNIFORM = 687,                 /* UNIFORM  */
-    SHARED = 688,                  /* SHARED  */
-    BUFFER = 689,                  /* BUFFER  */
-    TILEIMAGEEXT = 690,            /* TILEIMAGEEXT  */
-    FLAT = 691,                    /* FLAT  */
-    SMOOTH = 692,                  /* SMOOTH  */
-    LAYOUT = 693,                  /* LAYOUT  */
-    DOUBLECONSTANT = 694,          /* DOUBLECONSTANT  */
-    INT16CONSTANT = 695,           /* INT16CONSTANT  */
-    UINT16CONSTANT = 696,          /* UINT16CONSTANT  */
-    FLOAT16CONSTANT = 697,         /* FLOAT16CONSTANT  */
-    INT32CONSTANT = 698,           /* INT32CONSTANT  */
-    UINT32CONSTANT = 699,          /* UINT32CONSTANT  */
-    INT64CONSTANT = 700,           /* INT64CONSTANT  */
-    UINT64CONSTANT = 701,          /* UINT64CONSTANT  */
-    SUBROUTINE = 702,              /* SUBROUTINE  */
-    DEMOTE = 703,                  /* DEMOTE  */
-    FUNCTION = 704,                /* FUNCTION  */
-    PAYLOADNV = 705,               /* PAYLOADNV  */
-    PAYLOADINNV = 706,             /* PAYLOADINNV  */
-    HITATTRNV = 707,               /* HITATTRNV  */
-    CALLDATANV = 708,              /* CALLDATANV  */
-    CALLDATAINNV = 709,            /* CALLDATAINNV  */
-    PAYLOADEXT = 710,              /* PAYLOADEXT  */
-    PAYLOADINEXT = 711,            /* PAYLOADINEXT  */
-    HITATTREXT = 712,              /* HITATTREXT  */
-    CALLDATAEXT = 713,             /* CALLDATAEXT  */
-    CALLDATAINEXT = 714,           /* CALLDATAINEXT  */
-    PATCH = 715,                   /* PATCH  */
-    SAMPLE = 716,                  /* SAMPLE  */
-    NONUNIFORM = 717,              /* NONUNIFORM  */
-    COHERENT = 718,                /* COHERENT  */
-    VOLATILE = 719,                /* VOLATILE  */
-    RESTRICT = 720,                /* RESTRICT  */
-    READONLY = 721,                /* READONLY  */
-    WRITEONLY = 722,               /* WRITEONLY  */
-    NONTEMPORAL = 723,             /* NONTEMPORAL  */
-    DEVICECOHERENT = 724,          /* DEVICECOHERENT  */
-    QUEUEFAMILYCOHERENT = 725,     /* QUEUEFAMILYCOHERENT  */
-    WORKGROUPCOHERENT = 726,       /* WORKGROUPCOHERENT  */
-    SUBGROUPCOHERENT = 727,        /* SUBGROUPCOHERENT  */
-    NONPRIVATE = 728,              /* NONPRIVATE  */
-    SHADERCALLCOHERENT = 729,      /* SHADERCALLCOHERENT  */
-    NOPERSPECTIVE = 730,           /* NOPERSPECTIVE  */
-    EXPLICITINTERPAMD = 731,       /* EXPLICITINTERPAMD  */
-    PERVERTEXEXT = 732,            /* PERVERTEXEXT  */
-    PERVERTEXNV = 733,             /* PERVERTEXNV  */
-    PERPRIMITIVENV = 734,          /* PERPRIMITIVENV  */
-    PERVIEWNV = 735,               /* PERVIEWNV  */
-    PERTASKNV = 736,               /* PERTASKNV  */
-    PERPRIMITIVEEXT = 737,         /* PERPRIMITIVEEXT  */
-    TASKPAYLOADWORKGROUPEXT = 738, /* TASKPAYLOADWORKGROUPEXT  */
-    PRECISE = 739                  /* PRECISE  */
+    VECTOR = 435,                  /* VECTOR  */
+    HITOBJECTNV = 436,             /* HITOBJECTNV  */
+    HITOBJECTATTRNV = 437,         /* HITOBJECTATTRNV  */
+    HITOBJECTEXT = 438,            /* HITOBJECTEXT  */
+    HITOBJECTATTREXT = 439,        /* HITOBJECTATTREXT  */
+    TENSORLAYOUTNV = 440,          /* TENSORLAYOUTNV  */
+    TENSORVIEWNV = 441,            /* TENSORVIEWNV  */
+    TENSORARM = 442,               /* TENSORARM  */
+    SAMPLERCUBEARRAY = 443,        /* SAMPLERCUBEARRAY  */
+    SAMPLERCUBEARRAYSHADOW = 444,  /* SAMPLERCUBEARRAYSHADOW  */
+    ISAMPLERCUBEARRAY = 445,       /* ISAMPLERCUBEARRAY  */
+    USAMPLERCUBEARRAY = 446,       /* USAMPLERCUBEARRAY  */
+    SAMPLER1D = 447,               /* SAMPLER1D  */
+    SAMPLER1DARRAY = 448,          /* SAMPLER1DARRAY  */
+    SAMPLER1DARRAYSHADOW = 449,    /* SAMPLER1DARRAYSHADOW  */
+    ISAMPLER1D = 450,              /* ISAMPLER1D  */
+    SAMPLER1DSHADOW = 451,         /* SAMPLER1DSHADOW  */
+    SAMPLER2DRECT = 452,           /* SAMPLER2DRECT  */
+    SAMPLER2DRECTSHADOW = 453,     /* SAMPLER2DRECTSHADOW  */
+    ISAMPLER2DRECT = 454,          /* ISAMPLER2DRECT  */
+    USAMPLER2DRECT = 455,          /* USAMPLER2DRECT  */
+    SAMPLERBUFFER = 456,           /* SAMPLERBUFFER  */
+    ISAMPLERBUFFER = 457,          /* ISAMPLERBUFFER  */
+    USAMPLERBUFFER = 458,          /* USAMPLERBUFFER  */
+    SAMPLER2DMS = 459,             /* SAMPLER2DMS  */
+    ISAMPLER2DMS = 460,            /* ISAMPLER2DMS  */
+    USAMPLER2DMS = 461,            /* USAMPLER2DMS  */
+    SAMPLER2DMSARRAY = 462,        /* SAMPLER2DMSARRAY  */
+    ISAMPLER2DMSARRAY = 463,       /* ISAMPLER2DMSARRAY  */
+    USAMPLER2DMSARRAY = 464,       /* USAMPLER2DMSARRAY  */
+    SAMPLEREXTERNALOES = 465,      /* SAMPLEREXTERNALOES  */
+    SAMPLEREXTERNAL2DY2YEXT = 466, /* SAMPLEREXTERNAL2DY2YEXT  */
+    ISAMPLER1DARRAY = 467,         /* ISAMPLER1DARRAY  */
+    USAMPLER1D = 468,              /* USAMPLER1D  */
+    USAMPLER1DARRAY = 469,         /* USAMPLER1DARRAY  */
+    F16SAMPLER1D = 470,            /* F16SAMPLER1D  */
+    F16SAMPLER2D = 471,            /* F16SAMPLER2D  */
+    F16SAMPLER3D = 472,            /* F16SAMPLER3D  */
+    F16SAMPLER2DRECT = 473,        /* F16SAMPLER2DRECT  */
+    F16SAMPLERCUBE = 474,          /* F16SAMPLERCUBE  */
+    F16SAMPLER1DARRAY = 475,       /* F16SAMPLER1DARRAY  */
+    F16SAMPLER2DARRAY = 476,       /* F16SAMPLER2DARRAY  */
+    F16SAMPLERCUBEARRAY = 477,     /* F16SAMPLERCUBEARRAY  */
+    F16SAMPLERBUFFER = 478,        /* F16SAMPLERBUFFER  */
+    F16SAMPLER2DMS = 479,          /* F16SAMPLER2DMS  */
+    F16SAMPLER2DMSARRAY = 480,     /* F16SAMPLER2DMSARRAY  */
+    F16SAMPLER1DSHADOW = 481,      /* F16SAMPLER1DSHADOW  */
+    F16SAMPLER2DSHADOW = 482,      /* F16SAMPLER2DSHADOW  */
+    F16SAMPLER1DARRAYSHADOW = 483, /* F16SAMPLER1DARRAYSHADOW  */
+    F16SAMPLER2DARRAYSHADOW = 484, /* F16SAMPLER2DARRAYSHADOW  */
+    F16SAMPLER2DRECTSHADOW = 485,  /* F16SAMPLER2DRECTSHADOW  */
+    F16SAMPLERCUBESHADOW = 486,    /* F16SAMPLERCUBESHADOW  */
+    F16SAMPLERCUBEARRAYSHADOW = 487, /* F16SAMPLERCUBEARRAYSHADOW  */
+    IMAGE1D = 488,                 /* IMAGE1D  */
+    IIMAGE1D = 489,                /* IIMAGE1D  */
+    UIMAGE1D = 490,                /* UIMAGE1D  */
+    IMAGE2D = 491,                 /* IMAGE2D  */
+    IIMAGE2D = 492,                /* IIMAGE2D  */
+    UIMAGE2D = 493,                /* UIMAGE2D  */
+    IMAGE3D = 494,                 /* IMAGE3D  */
+    IIMAGE3D = 495,                /* IIMAGE3D  */
+    UIMAGE3D = 496,                /* UIMAGE3D  */
+    IMAGE2DRECT = 497,             /* IMAGE2DRECT  */
+    IIMAGE2DRECT = 498,            /* IIMAGE2DRECT  */
+    UIMAGE2DRECT = 499,            /* UIMAGE2DRECT  */
+    IMAGECUBE = 500,               /* IMAGECUBE  */
+    IIMAGECUBE = 501,              /* IIMAGECUBE  */
+    UIMAGECUBE = 502,              /* UIMAGECUBE  */
+    IMAGEBUFFER = 503,             /* IMAGEBUFFER  */
+    IIMAGEBUFFER = 504,            /* IIMAGEBUFFER  */
+    UIMAGEBUFFER = 505,            /* UIMAGEBUFFER  */
+    IMAGE1DARRAY = 506,            /* IMAGE1DARRAY  */
+    IIMAGE1DARRAY = 507,           /* IIMAGE1DARRAY  */
+    UIMAGE1DARRAY = 508,           /* UIMAGE1DARRAY  */
+    IMAGE2DARRAY = 509,            /* IMAGE2DARRAY  */
+    IIMAGE2DARRAY = 510,           /* IIMAGE2DARRAY  */
+    UIMAGE2DARRAY = 511,           /* UIMAGE2DARRAY  */
+    IMAGECUBEARRAY = 512,          /* IMAGECUBEARRAY  */
+    IIMAGECUBEARRAY = 513,         /* IIMAGECUBEARRAY  */
+    UIMAGECUBEARRAY = 514,         /* UIMAGECUBEARRAY  */
+    IMAGE2DMS = 515,               /* IMAGE2DMS  */
+    IIMAGE2DMS = 516,              /* IIMAGE2DMS  */
+    UIMAGE2DMS = 517,              /* UIMAGE2DMS  */
+    IMAGE2DMSARRAY = 518,          /* IMAGE2DMSARRAY  */
+    IIMAGE2DMSARRAY = 519,         /* IIMAGE2DMSARRAY  */
+    UIMAGE2DMSARRAY = 520,         /* UIMAGE2DMSARRAY  */
+    F16IMAGE1D = 521,              /* F16IMAGE1D  */
+    F16IMAGE2D = 522,              /* F16IMAGE2D  */
+    F16IMAGE3D = 523,              /* F16IMAGE3D  */
+    F16IMAGE2DRECT = 524,          /* F16IMAGE2DRECT  */
+    F16IMAGECUBE = 525,            /* F16IMAGECUBE  */
+    F16IMAGE1DARRAY = 526,         /* F16IMAGE1DARRAY  */
+    F16IMAGE2DARRAY = 527,         /* F16IMAGE2DARRAY  */
+    F16IMAGECUBEARRAY = 528,       /* F16IMAGECUBEARRAY  */
+    F16IMAGEBUFFER = 529,          /* F16IMAGEBUFFER  */
+    F16IMAGE2DMS = 530,            /* F16IMAGE2DMS  */
+    F16IMAGE2DMSARRAY = 531,       /* F16IMAGE2DMSARRAY  */
+    I64IMAGE1D = 532,              /* I64IMAGE1D  */
+    U64IMAGE1D = 533,              /* U64IMAGE1D  */
+    I64IMAGE2D = 534,              /* I64IMAGE2D  */
+    U64IMAGE2D = 535,              /* U64IMAGE2D  */
+    I64IMAGE3D = 536,              /* I64IMAGE3D  */
+    U64IMAGE3D = 537,              /* U64IMAGE3D  */
+    I64IMAGE2DRECT = 538,          /* I64IMAGE2DRECT  */
+    U64IMAGE2DRECT = 539,          /* U64IMAGE2DRECT  */
+    I64IMAGECUBE = 540,            /* I64IMAGECUBE  */
+    U64IMAGECUBE = 541,            /* U64IMAGECUBE  */
+    I64IMAGEBUFFER = 542,          /* I64IMAGEBUFFER  */
+    U64IMAGEBUFFER = 543,          /* U64IMAGEBUFFER  */
+    I64IMAGE1DARRAY = 544,         /* I64IMAGE1DARRAY  */
+    U64IMAGE1DARRAY = 545,         /* U64IMAGE1DARRAY  */
+    I64IMAGE2DARRAY = 546,         /* I64IMAGE2DARRAY  */
+    U64IMAGE2DARRAY = 547,         /* U64IMAGE2DARRAY  */
+    I64IMAGECUBEARRAY = 548,       /* I64IMAGECUBEARRAY  */
+    U64IMAGECUBEARRAY = 549,       /* U64IMAGECUBEARRAY  */
+    I64IMAGE2DMS = 550,            /* I64IMAGE2DMS  */
+    U64IMAGE2DMS = 551,            /* U64IMAGE2DMS  */
+    I64IMAGE2DMSARRAY = 552,       /* I64IMAGE2DMSARRAY  */
+    U64IMAGE2DMSARRAY = 553,       /* U64IMAGE2DMSARRAY  */
+    TEXTURECUBEARRAY = 554,        /* TEXTURECUBEARRAY  */
+    ITEXTURECUBEARRAY = 555,       /* ITEXTURECUBEARRAY  */
+    UTEXTURECUBEARRAY = 556,       /* UTEXTURECUBEARRAY  */
+    TEXTURE1D = 557,               /* TEXTURE1D  */
+    ITEXTURE1D = 558,              /* ITEXTURE1D  */
+    UTEXTURE1D = 559,              /* UTEXTURE1D  */
+    TEXTURE1DARRAY = 560,          /* TEXTURE1DARRAY  */
+    ITEXTURE1DARRAY = 561,         /* ITEXTURE1DARRAY  */
+    UTEXTURE1DARRAY = 562,         /* UTEXTURE1DARRAY  */
+    TEXTURE2DRECT = 563,           /* TEXTURE2DRECT  */
+    ITEXTURE2DRECT = 564,          /* ITEXTURE2DRECT  */
+    UTEXTURE2DRECT = 565,          /* UTEXTURE2DRECT  */
+    TEXTUREBUFFER = 566,           /* TEXTUREBUFFER  */
+    ITEXTUREBUFFER = 567,          /* ITEXTUREBUFFER  */
+    UTEXTUREBUFFER = 568,          /* UTEXTUREBUFFER  */
+    TEXTURE2DMS = 569,             /* TEXTURE2DMS  */
+    ITEXTURE2DMS = 570,            /* ITEXTURE2DMS  */
+    UTEXTURE2DMS = 571,            /* UTEXTURE2DMS  */
+    TEXTURE2DMSARRAY = 572,        /* TEXTURE2DMSARRAY  */
+    ITEXTURE2DMSARRAY = 573,       /* ITEXTURE2DMSARRAY  */
+    UTEXTURE2DMSARRAY = 574,       /* UTEXTURE2DMSARRAY  */
+    F16TEXTURE1D = 575,            /* F16TEXTURE1D  */
+    F16TEXTURE2D = 576,            /* F16TEXTURE2D  */
+    F16TEXTURE3D = 577,            /* F16TEXTURE3D  */
+    F16TEXTURE2DRECT = 578,        /* F16TEXTURE2DRECT  */
+    F16TEXTURECUBE = 579,          /* F16TEXTURECUBE  */
+    F16TEXTURE1DARRAY = 580,       /* F16TEXTURE1DARRAY  */
+    F16TEXTURE2DARRAY = 581,       /* F16TEXTURE2DARRAY  */
+    F16TEXTURECUBEARRAY = 582,     /* F16TEXTURECUBEARRAY  */
+    F16TEXTUREBUFFER = 583,        /* F16TEXTUREBUFFER  */
+    F16TEXTURE2DMS = 584,          /* F16TEXTURE2DMS  */
+    F16TEXTURE2DMSARRAY = 585,     /* F16TEXTURE2DMSARRAY  */
+    SUBPASSINPUT = 586,            /* SUBPASSINPUT  */
+    SUBPASSINPUTMS = 587,          /* SUBPASSINPUTMS  */
+    ISUBPASSINPUT = 588,           /* ISUBPASSINPUT  */
+    ISUBPASSINPUTMS = 589,         /* ISUBPASSINPUTMS  */
+    USUBPASSINPUT = 590,           /* USUBPASSINPUT  */
+    USUBPASSINPUTMS = 591,         /* USUBPASSINPUTMS  */
+    F16SUBPASSINPUT = 592,         /* F16SUBPASSINPUT  */
+    F16SUBPASSINPUTMS = 593,       /* F16SUBPASSINPUTMS  */
+    SPIRV_INSTRUCTION = 594,       /* SPIRV_INSTRUCTION  */
+    SPIRV_EXECUTION_MODE = 595,    /* SPIRV_EXECUTION_MODE  */
+    SPIRV_EXECUTION_MODE_ID = 596, /* SPIRV_EXECUTION_MODE_ID  */
+    SPIRV_DECORATE = 597,          /* SPIRV_DECORATE  */
+    SPIRV_DECORATE_ID = 598,       /* SPIRV_DECORATE_ID  */
+    SPIRV_DECORATE_STRING = 599,   /* SPIRV_DECORATE_STRING  */
+    SPIRV_TYPE = 600,              /* SPIRV_TYPE  */
+    SPIRV_STORAGE_CLASS = 601,     /* SPIRV_STORAGE_CLASS  */
+    SPIRV_BY_REFERENCE = 602,      /* SPIRV_BY_REFERENCE  */
+    SPIRV_LITERAL = 603,           /* SPIRV_LITERAL  */
+    ATTACHMENTEXT = 604,           /* ATTACHMENTEXT  */
+    IATTACHMENTEXT = 605,          /* IATTACHMENTEXT  */
+    UATTACHMENTEXT = 606,          /* UATTACHMENTEXT  */
+    LEFT_OP = 607,                 /* LEFT_OP  */
+    RIGHT_OP = 608,                /* RIGHT_OP  */
+    INC_OP = 609,                  /* INC_OP  */
+    DEC_OP = 610,                  /* DEC_OP  */
+    LE_OP = 611,                   /* LE_OP  */
+    GE_OP = 612,                   /* GE_OP  */
+    EQ_OP = 613,                   /* EQ_OP  */
+    NE_OP = 614,                   /* NE_OP  */
+    AND_OP = 615,                  /* AND_OP  */
+    OR_OP = 616,                   /* OR_OP  */
+    XOR_OP = 617,                  /* XOR_OP  */
+    MUL_ASSIGN = 618,              /* MUL_ASSIGN  */
+    DIV_ASSIGN = 619,              /* DIV_ASSIGN  */
+    ADD_ASSIGN = 620,              /* ADD_ASSIGN  */
+    MOD_ASSIGN = 621,              /* MOD_ASSIGN  */
+    LEFT_ASSIGN = 622,             /* LEFT_ASSIGN  */
+    RIGHT_ASSIGN = 623,            /* RIGHT_ASSIGN  */
+    AND_ASSIGN = 624,              /* AND_ASSIGN  */
+    XOR_ASSIGN = 625,              /* XOR_ASSIGN  */
+    OR_ASSIGN = 626,               /* OR_ASSIGN  */
+    SUB_ASSIGN = 627,              /* SUB_ASSIGN  */
+    STRING_LITERAL = 628,          /* STRING_LITERAL  */
+    LEFT_PAREN = 629,              /* LEFT_PAREN  */
+    RIGHT_PAREN = 630,             /* RIGHT_PAREN  */
+    LEFT_BRACKET = 631,            /* LEFT_BRACKET  */
+    RIGHT_BRACKET = 632,           /* RIGHT_BRACKET  */
+    LEFT_BRACE = 633,              /* LEFT_BRACE  */
+    RIGHT_BRACE = 634,             /* RIGHT_BRACE  */
+    DOT = 635,                     /* DOT  */
+    COMMA = 636,                   /* COMMA  */
+    COLON = 637,                   /* COLON  */
+    EQUAL = 638,                   /* EQUAL  */
+    SEMICOLON = 639,               /* SEMICOLON  */
+    BANG = 640,                    /* BANG  */
+    DASH = 641,                    /* DASH  */
+    TILDE = 642,                   /* TILDE  */
+    PLUS = 643,                    /* PLUS  */
+    STAR = 644,                    /* STAR  */
+    SLASH = 645,                   /* SLASH  */
+    PERCENT = 646,                 /* PERCENT  */
+    LEFT_ANGLE = 647,              /* LEFT_ANGLE  */
+    RIGHT_ANGLE = 648,             /* RIGHT_ANGLE  */
+    VERTICAL_BAR = 649,            /* VERTICAL_BAR  */
+    CARET = 650,                   /* CARET  */
+    AMPERSAND = 651,               /* AMPERSAND  */
+    QUESTION = 652,                /* QUESTION  */
+    INVARIANT = 653,               /* INVARIANT  */
+    HIGH_PRECISION = 654,          /* HIGH_PRECISION  */
+    MEDIUM_PRECISION = 655,        /* MEDIUM_PRECISION  */
+    LOW_PRECISION = 656,           /* LOW_PRECISION  */
+    PRECISION = 657,               /* PRECISION  */
+    PACKED = 658,                  /* PACKED  */
+    RESOURCE = 659,                /* RESOURCE  */
+    SUPERP = 660,                  /* SUPERP  */
+    FLOATCONSTANT = 661,           /* FLOATCONSTANT  */
+    INTCONSTANT = 662,             /* INTCONSTANT  */
+    UINTCONSTANT = 663,            /* UINTCONSTANT  */
+    BOOLCONSTANT = 664,            /* BOOLCONSTANT  */
+    IDENTIFIER = 665,              /* IDENTIFIER  */
+    TYPE_NAME = 666,               /* TYPE_NAME  */
+    CENTROID = 667,                /* CENTROID  */
+    IN = 668,                      /* IN  */
+    OUT = 669,                     /* OUT  */
+    INOUT = 670,                   /* INOUT  */
+    STRUCT = 671,                  /* STRUCT  */
+    VOID = 672,                    /* VOID  */
+    WHILE = 673,                   /* WHILE  */
+    BREAK = 674,                   /* BREAK  */
+    CONTINUE = 675,                /* CONTINUE  */
+    DO = 676,                      /* DO  */
+    ELSE = 677,                    /* ELSE  */
+    FOR = 678,                     /* FOR  */
+    IF = 679,                      /* IF  */
+    DISCARD = 680,                 /* DISCARD  */
+    RETURN = 681,                  /* RETURN  */
+    SWITCH = 682,                  /* SWITCH  */
+    CASE = 683,                    /* CASE  */
+    DEFAULT = 684,                 /* DEFAULT  */
+    TERMINATE_INVOCATION = 685,    /* TERMINATE_INVOCATION  */
+    TERMINATE_RAY = 686,           /* TERMINATE_RAY  */
+    IGNORE_INTERSECTION = 687,     /* IGNORE_INTERSECTION  */
+    UNIFORM = 688,                 /* UNIFORM  */
+    SHARED = 689,                  /* SHARED  */
+    BUFFER = 690,                  /* BUFFER  */
+    TILEIMAGEEXT = 691,            /* TILEIMAGEEXT  */
+    FLAT = 692,                    /* FLAT  */
+    SMOOTH = 693,                  /* SMOOTH  */
+    LAYOUT = 694,                  /* LAYOUT  */
+    DOUBLECONSTANT = 695,          /* DOUBLECONSTANT  */
+    INT16CONSTANT = 696,           /* INT16CONSTANT  */
+    UINT16CONSTANT = 697,          /* UINT16CONSTANT  */
+    FLOAT16CONSTANT = 698,         /* FLOAT16CONSTANT  */
+    INT32CONSTANT = 699,           /* INT32CONSTANT  */
+    UINT32CONSTANT = 700,          /* UINT32CONSTANT  */
+    INT64CONSTANT = 701,           /* INT64CONSTANT  */
+    UINT64CONSTANT = 702,          /* UINT64CONSTANT  */
+    SUBROUTINE = 703,              /* SUBROUTINE  */
+    DEMOTE = 704,                  /* DEMOTE  */
+    FUNCTION = 705,                /* FUNCTION  */
+    PAYLOADNV = 706,               /* PAYLOADNV  */
+    PAYLOADINNV = 707,             /* PAYLOADINNV  */
+    HITATTRNV = 708,               /* HITATTRNV  */
+    CALLDATANV = 709,              /* CALLDATANV  */
+    CALLDATAINNV = 710,            /* CALLDATAINNV  */
+    PAYLOADEXT = 711,              /* PAYLOADEXT  */
+    PAYLOADINEXT = 712,            /* PAYLOADINEXT  */
+    HITATTREXT = 713,              /* HITATTREXT  */
+    CALLDATAEXT = 714,             /* CALLDATAEXT  */
+    CALLDATAINEXT = 715,           /* CALLDATAINEXT  */
+    PATCH = 716,                   /* PATCH  */
+    SAMPLE = 717,                  /* SAMPLE  */
+    NONUNIFORM = 718,              /* NONUNIFORM  */
+    RESOURCEHEAP = 719,            /* RESOURCEHEAP  */
+    SAMPLERHEAP = 720,             /* SAMPLERHEAP  */
+    COHERENT = 721,                /* COHERENT  */
+    VOLATILE = 722,                /* VOLATILE  */
+    RESTRICT = 723,                /* RESTRICT  */
+    READONLY = 724,                /* READONLY  */
+    WRITEONLY = 725,               /* WRITEONLY  */
+    NONTEMPORAL = 726,             /* NONTEMPORAL  */
+    DEVICECOHERENT = 727,          /* DEVICECOHERENT  */
+    QUEUEFAMILYCOHERENT = 728,     /* QUEUEFAMILYCOHERENT  */
+    WORKGROUPCOHERENT = 729,       /* WORKGROUPCOHERENT  */
+    SUBGROUPCOHERENT = 730,        /* SUBGROUPCOHERENT  */
+    NONPRIVATE = 731,              /* NONPRIVATE  */
+    SHADERCALLCOHERENT = 732,      /* SHADERCALLCOHERENT  */
+    NOPERSPECTIVE = 733,           /* NOPERSPECTIVE  */
+    EXPLICITINTERPAMD = 734,       /* EXPLICITINTERPAMD  */
+    PERVERTEXEXT = 735,            /* PERVERTEXEXT  */
+    PERVERTEXNV = 736,             /* PERVERTEXNV  */
+    PERPRIMITIVENV = 737,          /* PERPRIMITIVENV  */
+    PERVIEWNV = 738,               /* PERVIEWNV  */
+    PERTASKNV = 739,               /* PERTASKNV  */
+    PERPRIMITIVEEXT = 740,         /* PERPRIMITIVEEXT  */
+    TASKPAYLOADWORKGROUPEXT = 741, /* TASKPAYLOADWORKGROUPEXT  */
+    PRECISE = 742                  /* PRECISE  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -583,7 +586,7 @@ union YYSTYPE
         glslang::TTypeParameters* typeParameters;
     } interm;
 
-#line 587 "MachineIndependent/glslang_tab.cpp.h"
+#line 590 "MachineIndependent/glslang_tab.cpp.h"
 
 };
 typedef union YYSTYPE YYSTYPE;
diff --git a/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp b/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp
index 00acd83a7..f7ab245dd 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp
@@ -888,38 +888,38 @@ bool TDefaultIoResolverBase::doAutoBindingMapping() const { return referenceInte
 
 bool TDefaultIoResolverBase::doAutoLocationMapping() const { return referenceIntermediate.getAutoMapLocations(); }
 
-TDefaultIoResolverBase::TSlotSet::iterator TDefaultIoResolverBase::findSlot(int set, int slot) {
-    return std::lower_bound(slots[set].begin(), slots[set].end(), slot);
+TDefaultIoResolverBase::TSlotSet::iterator TDefaultIoResolverBase::findSlot(int resource, int set, int slot) {
+    return std::lower_bound(slots[resource][set].begin(), slots[resource][set].end(), slot);
 }
 
-bool TDefaultIoResolverBase::checkEmpty(int set, int slot) {
-    TSlotSet::iterator at = findSlot(set, slot);
-    return ! (at != slots[set].end() && *at == slot);
+bool TDefaultIoResolverBase::checkEmpty(int resource, int set, int slot) {
+    TSlotSet::iterator at = findSlot(resource, set, slot);
+    return ! (at != slots[resource][set].end() && *at == slot);
 }
 
-int TDefaultIoResolverBase::reserveSlot(int set, int slot, int size) {
-    TSlotSet::iterator at = findSlot(set, slot);
+int TDefaultIoResolverBase::reserveSlot(int resource, int set, int slot, int size) {
+    TSlotSet::iterator at = findSlot(resource, set, slot);
     // tolerate aliasing, by not double-recording aliases
     // (policy about appropriateness of the alias is higher up)
     for (int i = 0; i < size; i++) {
-        if (at == slots[set].end() || *at != slot + i)
-            at = slots[set].insert(at, slot + i);
+        if (at == slots[resource][set].end() || *at != slot + i)
+            at = slots[resource][set].insert(at, slot + i);
         ++at;
     }
     return slot;
 }
 
-int TDefaultIoResolverBase::getFreeSlot(int set, int base, int size) {
-    TSlotSet::iterator at = findSlot(set, base);
-    if (at == slots[set].end())
-        return reserveSlot(set, base, size);
+int TDefaultIoResolverBase::getFreeSlot(int resource, int set, int base, int size) {
+    TSlotSet::iterator at = findSlot(resource, set, base);
+    if (at == slots[resource][set].end())
+        return reserveSlot(resource, set, base, size);
     // look for a big enough gap
-    for (; at != slots[set].end(); ++at) {
+    for (; at != slots[resource][set].end(); ++at) {
         if (*at - base >= size)
             break;
         base = *at + 1;
     }
-    return reserveSlot(set, base, size);
+    return reserveSlot(resource, set, base, size);
 }
 
 int TDefaultIoResolverBase::resolveSet(EShLanguage stage, TVarEntryInfo& ent) {
@@ -1123,13 +1123,13 @@ int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInf
             //
             // vs: out vec4 a;
             // fs: in vec4 a;
-            location = getFreeSlot(resourceKey, 0, typeLocationSize);
+            location = getFreeSlot(0, resourceKey, 0, typeLocationSize);
             storageSlotMap[resourceKey][name] = location;
         }
     } else {
         // the first interface declarated in a program.
         TVarSlotMap varSlotMap;
-        location = getFreeSlot(resourceKey, 0, typeLocationSize);
+        location = getFreeSlot(0, resourceKey, 0, typeLocationSize);
         varSlotMap[name] = location;
         storageSlotMap[resourceKey] = varSlotMap;
     }
@@ -1196,13 +1196,13 @@ int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEn
             //
             // vs:    uniform vec4 a;
             // fs:    uniform vec4 a;
-            location = getFreeSlot(resourceKey, 0, computeTypeLocationSize(type, currentStage));
+            location = getFreeSlot(0, resourceKey, 0, computeTypeLocationSize(type, currentStage));
             storageSlotMap[resourceKey][name] = location;
         }
     } else {
         // the first uniform declaration in a program.
         TVarSlotMap varSlotMap;
-        location = getFreeSlot(resourceKey, 0, size);
+        location = getFreeSlot(0, resourceKey, 0, size);
         varSlotMap[name] = location;
         storageSlotMap[resourceKey] = varSlotMap;
     }
@@ -1222,13 +1222,12 @@ int TDefaultGlslIoResolver::resolveBinding(EShLanguage stage, TVarEntryInfo& ent
     // There is no 'set' qualifier in OpenGL shading language, each resource has its own
     // binding name space, so remap the 'set' to resource type which make each resource
     // binding is valid from 0 to MAX_XXRESOURCE_BINDINGS
-    int set = referenceIntermediate.getSpv().openGl != 0 ? resource : ent.newSet;
-    int resourceKey = set;
+    int set = referenceIntermediate.getSpv().openGl != 0 ? 0 : ent.newSet;
+    int resourceKey = referenceIntermediate.getSpv().openGl != 0 || referenceIntermediate.getBindingsPerResourceType() ? resource : 0;
     if (resource < EResCount) {
         if (type.getQualifier().hasBinding()) {
-            int newBinding = reserveSlot(resourceKey, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding, numBindings);
+            int newBinding = reserveSlot(resourceKey, set, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding, numBindings);
             return ent.newBinding = newBinding;
-
         } else {
             // The resource in current stage is not declared with binding, but it is possible declared
             // with explicit binding in other stages, find the resourceSlotMap firstly to check whether
@@ -1236,9 +1235,9 @@ int TDefaultGlslIoResolver::resolveBinding(EShLanguage stage, TVarEntryInfo& ent
             bool hasBinding = false;
             ent.newBinding = -1; // leave as -1 if it isn't set below
 
-            if (! resourceSlotMap[resourceKey].empty()) {
-                TVarSlotMap::iterator iter = resourceSlotMap[resourceKey].find(name);
-                if (iter != resourceSlotMap[resourceKey].end()) {
+            if (! resourceSlotMap[resourceKey][set].empty()) {
+                TVarSlotMap::iterator iter = resourceSlotMap[resourceKey][set].find(name);
+                if (iter != resourceSlotMap[resourceKey][set].end()) {
                     hasBinding = true;
                     ent.newBinding = iter->second;
                 }
@@ -1246,8 +1245,8 @@ int TDefaultGlslIoResolver::resolveBinding(EShLanguage stage, TVarEntryInfo& ent
             if (!hasBinding && (ent.live && doAutoBindingMapping())) {
                 // find free slot, the caller did make sure it passes all vars with binding
                 // first and now all are passed that do not have a binding and needs one
-                int binding = getFreeSlot(resourceKey, getBaseBinding(stage, resource, set), numBindings);
-                resourceSlotMap[resourceKey][name] = binding;
+                int binding = getFreeSlot(resourceKey, set, getBaseBinding(stage, resource, set), numBindings);
+                resourceSlotMap[resourceKey][set][name] = binding;
                 ent.newBinding = binding;
             }
             return ent.newBinding;
@@ -1302,7 +1301,7 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
             TVarSlotMap::iterator iter = varSlotMap.find(name);
             if (iter == varSlotMap.end()) {
                 int numLocations = TIntermediate::computeTypeUniformLocationSize(type);
-                reserveSlot(storageKey, location, numLocations);
+                reserveSlot(0, storageKey, location, numLocations);
                 varSlotMap[name] = location;
             } else {
                 // Allocate location by name for OpenGL driver, so the uniform in different
@@ -1328,7 +1327,7 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
             TVarSlotMap::iterator iter = varSlotMap.find(name);
             if (iter == varSlotMap.end()) {
                 int numLocations = TIntermediate::computeTypeUniformLocationSize(type);
-                reserveSlot(storageKey, location, numLocations);
+                reserveSlot(0, storageKey, location, numLocations);
                 varSlotMap[name] = location;
             } else {
                 // Allocate location by name for OpenGL driver, so the uniform in different
@@ -1350,19 +1349,18 @@ void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink&
     const TType& type = ent.symbol->getType();
     const TString& name = ent.symbol->getAccessName();
     TResourceType resource = getResourceType(type);
-    int set = referenceIntermediate.getSpv().openGl != 0 ? resource : resolveSet(ent.stage, ent);
-    int resourceKey = set;
+    int set = referenceIntermediate.getSpv().openGl != 0 ? 0 : resolveSet(ent.stage, ent);
+    int resourceKey = referenceIntermediate.getSpv().openGl != 0 || referenceIntermediate.getBindingsPerResourceType() ? resource : 0;
 
     if (type.getQualifier().hasBinding()) {
-        TVarSlotMap& varSlotMap = resourceSlotMap[resourceKey];
+        TVarSlotMap& varSlotMap = resourceSlotMap[resourceKey][set];
         TVarSlotMap::iterator iter = varSlotMap.find(name);
         int binding = type.getQualifier().layoutBinding + getBaseBinding(ent.stage, resource, set);
-
         if (iter == varSlotMap.end()) {
             // Reserve the slots for the ubo, ssbo and opaques who has explicit binding
             int numBindings = referenceIntermediate.getSpv().openGl != 0 && type.isSizedArray() ? type.getCumulativeArraySize() : 1;
             varSlotMap[name] = binding;
-            reserveSlot(resourceKey, binding, numBindings);
+            reserveSlot(resourceKey, set, binding, numBindings);
         } else {
             // Allocate binding by name for OpenGL driver, so the resource in different
             // stages should be declared with the same binding
@@ -1427,14 +1425,15 @@ struct TDefaultIoResolver : public TDefaultIoResolverBase {
         // On OpenGL arrays of opaque types take a seperate binding for each element
         int numBindings = referenceIntermediate.getSpv().openGl != 0 && type.isSizedArray() ? type.getCumulativeArraySize() : 1;
         TResourceType resource = getResourceType(type);
+        int resourceKey = referenceIntermediate.getBindingsPerResourceType() ? resource : 0;
         if (resource < EResCount) {
             if (type.getQualifier().hasBinding()) {
                 return ent.newBinding = reserveSlot(
-                           set, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding, numBindings);
+                           resourceKey, set, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding, numBindings);
             } else if (ent.live && doAutoBindingMapping()) {
                 // find free slot, the caller did make sure it passes all vars with binding
                 // first and now all are passed that do not have a binding and needs one
-                return ent.newBinding = getFreeSlot(set, getBaseBinding(stage, resource, set), numBindings);
+                return ent.newBinding = getFreeSlot(resourceKey, set, getBaseBinding(stage, resource, set), numBindings);
             }
         }
         return ent.newBinding = -1;
@@ -1515,13 +1514,14 @@ struct TDefaultHlslIoResolver : public TDefaultIoResolverBase {
         const TType& type = ent.symbol->getType();
         const int set = getLayoutSet(type);
         TResourceType resource = getResourceType(type);
+        int resourceKey = referenceIntermediate.getBindingsPerResourceType() ? resource : 0;
         if (resource < EResCount) {
             if (type.getQualifier().hasBinding()) {
-                return ent.newBinding = reserveSlot(set, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding);
+                return ent.newBinding = reserveSlot(resourceKey, set, getBaseBinding(stage, resource, set) + type.getQualifier().layoutBinding);
             } else if (ent.live && doAutoBindingMapping()) {
                 // find free slot, the caller did make sure it passes all vars with binding
                 // first and now all are passed that do not have a binding and needs one
-                return ent.newBinding = getFreeSlot(set, getBaseBinding(stage, resource, set));
+                return ent.newBinding = getFreeSlot(resourceKey, set, getBaseBinding(stage, resource, set));
             }
         }
         return ent.newBinding = -1;
diff --git a/3rdparty/glslang/glslang/MachineIndependent/iomapper.h b/3rdparty/glslang/glslang/MachineIndependent/iomapper.h
index de0a0d7dc..d8c290733 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/iomapper.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/iomapper.h
@@ -37,6 +37,7 @@
 #define _IOMAPPER_INCLUDED
 
 #include <cstdint>
+#include <array>
 #include <unordered_map>
 #include <unordered_set>
 //
@@ -55,6 +56,7 @@ public:
     TDefaultIoResolverBase(const TIntermediate& intermediate);
     typedef std::vector<int> TSlotSet;
     typedef std::unordered_map<int, TSlotSet> TSlotSetMap;
+    typedef std::array<TSlotSetMap, EResCount> TSlotSetMapResourceArray;
 
     // grow the reflection stage by stage
     void notifyBinding(EShLanguage, TVarEntryInfo& /*ent*/) override {}
@@ -72,11 +74,11 @@ public:
     virtual TResourceType getResourceType(const glslang::TType& type) = 0;
     bool doAutoBindingMapping() const;
     bool doAutoLocationMapping() const;
-    TSlotSet::iterator findSlot(int set, int slot);
-    bool checkEmpty(int set, int slot);
+    TSlotSet::iterator findSlot(int resource, int set, int slot);
+    bool checkEmpty(int resource, int set, int slot);
     bool validateInOut(EShLanguage /*stage*/, TVarEntryInfo& /*ent*/) override { return true; }
-    int reserveSlot(int set, int slot, int size = 1);
-    int getFreeSlot(int set, int base, int size = 1);
+    int reserveSlot(int resource, int set, int slot, int size = 1);
+    int getFreeSlot(int resource, int set, int base, int size = 1);
     int resolveSet(EShLanguage /*stage*/, TVarEntryInfo& ent) override;
     int resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) override;
     int resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) override;
@@ -90,7 +92,7 @@ public:
     }
     uint32_t computeTypeLocationSize(const TType& type, EShLanguage stage);
 
-    TSlotSetMap slots;
+    TSlotSetMapResourceArray slots;
     bool hasError = false;
 
 protected:
@@ -173,6 +175,7 @@ struct TDefaultGlslIoResolver : public TDefaultIoResolverBase {
 public:
     typedef std::map<TString, int> TVarSlotMap;  // <resourceName, location/binding>
     typedef std::map<int, TVarSlotMap> TSlotMap; // <resourceKey, TVarSlotMap>
+    typedef std::array<TSlotMap, EResCount> TResourceSlotMap;
     TDefaultGlslIoResolver(const TIntermediate& intermediate);
     bool validateBinding(EShLanguage /*stage*/, TVarEntryInfo& /*ent*/) override { return true; }
     TResourceType getResourceType(const glslang::TType& type) override;
@@ -200,7 +203,7 @@ protected:
     // Use for mark current shader stage for resolver
     EShLanguage currentStage;
     // Slot map for storage resource(location of uniform and interface symbol) It's a program share slot
-    TSlotMap resourceSlotMap;
+    TResourceSlotMap resourceSlotMap;
     // Slot map for other resource(image, ubo, ssbo), It's a program share slot.
     TSlotMap storageSlotMap;
 };
diff --git a/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp b/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp
index f4983c7af..0879fa79a 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp
+++ b/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp
@@ -524,7 +524,8 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit)
     numErrors += unit.getNumErrors();
     // Only one push_constant is allowed, mergeLinkerObjects() will ensure the push_constant
     // is the same for all units.
-    if (numPushConstants > 1 || unit.numPushConstants > 1)
+    if (!IsRequestedExtension(glslang::E_GL_NV_push_constant_bank) &&
+        (numPushConstants > 1 || unit.numPushConstants > 1))
         error(infoSink, "Only one push_constant block is allowed per stage");
     numPushConstants = std::min(numPushConstants + unit.numPushConstants, 1);
 
@@ -1125,7 +1126,8 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
                 mergeErrorCheck(infoSink, *symbol, *unitSymbol);
             }
             // If different symbols, verify they arn't push_constant since there can only be one per stage
-            else if (symbol->getQualifier().isPushConstant() && unitSymbol->getQualifier().isPushConstant() && getStage() == unitStage)
+            else if (!IsRequestedExtension(glslang::E_GL_NV_push_constant_bank) &&
+                (symbol->getQualifier().isPushConstant() && unitSymbol->getQualifier().isPushConstant() && getStage() == unitStage))
                 error(infoSink, "Only one push_constant block is allowed per stage");
         }
 
@@ -1590,7 +1592,7 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
     // overlap/alias/missing I/O, etc.
     inOutLocationCheck(infoSink);
 
-    if (getNumPushConstants() > 1)
+    if (!IsRequestedExtension(glslang::E_GL_NV_push_constant_bank) && (getNumPushConstants() > 1))
         error(infoSink, "Only one push_constant block is allowed per stage");
 
     // invocations
@@ -2573,6 +2575,22 @@ int TIntermediate::getBaseAlignment(const TType& type, int& size, int& stride, T
         }
     }
 
+    // rules 2 and 3
+    if (type.isLongVector()) {
+        int scalarAlign = getBaseAlignmentScalar(type, size);
+        uint32_t vectorSize = type.getTypeParameters()->arraySizes->getDimSize(0);
+        switch (vectorSize) {
+        case 1: // HLSL has this, GLSL does not
+            return scalarAlign;
+        case 2:
+            size *= 2;
+            return 2 * scalarAlign;
+        default:
+            size *= vectorSize;
+            return 4 * scalarAlign;
+        }
+    }
+
     // rules 5 and 7
     if (type.isMatrix()) {
         // rule 5: deref to row, not to column, meaning the size of vector is num columns instead of num rows
@@ -2653,6 +2671,14 @@ int TIntermediate::getScalarAlignment(const TType& type, int& size, int& stride,
         return scalarAlign;
     }
 
+    if (type.isLongVector()) {
+        int scalarAlign = getBaseAlignmentScalar(type, size);
+
+        uint32_t vectorSize = type.getTypeParameters()->arraySizes->getDimSize(0);
+        size *= vectorSize;
+        return scalarAlign;
+    }
+
     if (type.isMatrix()) {
         TType derefType(type, 0, rowMajor);
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h b/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h
index ce57ce4ca..209a72458 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h
@@ -352,6 +352,7 @@ public:
         hlslOffsets(false),
         hlslIoMapping(false),
         useVariablePointers(false),
+        bindingsPerResourceType(false),
         textureSamplerTransformMode(EShTexSampTransKeep),
         needToLegalize(false),
         binaryDoubleOutput(false),
@@ -840,6 +841,13 @@ public:
 
     bool usingVariablePointers() const { return useVariablePointers; }
 
+    void setBindingsPerResourceType()
+    {
+        bindingsPerResourceType = true;
+        processes.addProcess("bindings-per-resource-type");
+    }
+    bool getBindingsPerResourceType() const { return bindingsPerResourceType; }
+
 #ifdef ENABLE_HLSL
     template<class T> T addCounterBufferName(const T& name) const { return name + implicitCounterName; }
     bool hasCounterBufferName(const TString& name) const {
@@ -1302,6 +1310,7 @@ protected:
     bool hlslOffsets;
     bool hlslIoMapping;
     bool useVariablePointers;
+    bool bindingsPerResourceType;
 
     std::set<TString> semanticNameSet;
 
diff --git a/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h b/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h
index 81f5f59b8..df1fa5701 100644
--- a/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h
+++ b/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h
@@ -127,6 +127,7 @@ public:
     virtual void coopmatConverisonCheckQCOM(const TSourceLoc& loc, const char* op, bool builtIn = false);
     virtual void tensorLayoutViewCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void coopvecCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void longVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void intattachmentCheck(const TSourceLoc&, const char *op, bool builtIn = false);
     virtual void tensorCheckARM(const TSourceLoc&, const char *op, bool builtIn = false);
     bool relaxedErrors()    const { return (messages & EShMsgRelaxedErrors) != 0; }
diff --git a/3rdparty/glslang/glslang/Public/ShaderLang.h b/3rdparty/glslang/glslang/Public/ShaderLang.h
index 8ca4ed9ce..07e4ca5c7 100644
--- a/3rdparty/glslang/glslang/Public/ShaderLang.h
+++ b/3rdparty/glslang/glslang/Public/ShaderLang.h
@@ -496,6 +496,7 @@ public:
     void setResourceSetBinding(const std::vector<std::string>& base);
     void setAutoMapBindings(bool map);
     void setAutoMapLocations(bool map);
+    void setBindingsPerResourceType();
     void addUniformLocationOverride(const char* name, int loc);
     void setUniformLocationBase(int base);
     void setInvertY(bool invert);