GL_EXT_ray_query updates

diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h
index b8cf04ff48a1619d7cb76edb89fb27ff5d79fbca..d783a8f299ec1b895c60f6672dba32975468c609 100644 (file)
--- a/SPIRV/GLSL.ext.KHR.h
+++ b/SPIRV/GLSL.ext.KHR.h
@@ -1,5 +1,6 @@
 /*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
+** Copyright (c) 2014-2020 The Khronos Group Inc.
+** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a copy
 ** of this software and/or associated documentation files (the "Materials"),
@@ -46,4 +47,5 @@ static const char* const E_SPV_EXT_fragment_shader_interlock    = "SPV_EXT_fragm
 static const char* const E_SPV_KHR_shader_clock                 = "SPV_KHR_shader_clock";
 static const char* const E_SPV_KHR_non_semantic_info            = "SPV_KHR_non_semantic_info";
 static const char* const E_SPV_KHR_ray_tracing                  = "SPV_KHR_ray_tracing";
+static const char* const E_SPV_KHR_ray_query                    = "SPV_KHR_ray_query";
 #endif  // #ifndef GLSLextKHR_H

diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index 565f60d5e9761ce3ed32913fe531748130431d81..c3808c487cfc01cdfebda518231993790f298077 100644 (file)
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -2,6 +2,7 @@
 // Copyright (C) 2014-2016 LunarG, Inc.
 // Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -1181,6 +1182,8 @@ spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang:
 // Translate glslang type to SPIR-V storage class.
 spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
 {
+    if (type.getBasicType() == glslang::EbtRayQuery)
+        return spv::StorageClassFunction;
     if (type.getQualifier().isPipeInput())
         return spv::StorageClassInput;
     if (type.getQualifier().isPipeOutput())
@@ -2703,6 +2706,13 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
         noReturnValue = true;
         break;
+    case glslang::EOpRayQueryInitialize:
+    case glslang::EOpRayQueryTerminate:
+    case glslang::EOpRayQueryGenerateIntersection:
+    case glslang::EOpRayQueryConfirmIntersection:
+        noReturnValue = true;
+        break;
+
     case glslang::EOpCooperativeMatrixLoad:
     case glslang::EOpCooperativeMatrixStore:
         noReturnValue = true;
@@ -2769,6 +2779,25 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                 lvalue = true;
             break;
 
+        case glslang::EOpRayQueryInitialize:
+        case glslang::EOpRayQueryGenerateIntersection:
+        case glslang::EOpRayQueryGetIntersectionType:
+        case glslang::EOpRayQueryGetIntersectionT:
+        case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex:
+        case glslang::EOpRayQueryGetIntersectionInstanceId:
+        case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
+        case glslang::EOpRayQueryGetIntersectionGeometryIndex:
+        case glslang::EOpRayQueryGetIntersectionPrimitiveIndex:
+        case glslang::EOpRayQueryGetIntersectionBarycentrics:
+        case glslang::EOpRayQueryGetIntersectionFrontFace:
+        case glslang::EOpRayQueryGetIntersectionObjectRayDirection:
+        case glslang::EOpRayQueryGetIntersectionObjectRayOrigin:
+        case glslang::EOpRayQueryGetIntersectionObjectToWorld:
+        case glslang::EOpRayQueryGetIntersectionWorldToObject:
+            if (arg == 0)
+                lvalue = true;
+            break;
+
         case glslang::EOpAtomicAdd:
         case glslang::EOpAtomicMin:
         case glslang::EOpAtomicMax:
@@ -2913,7 +2942,29 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             lvalueCoherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType());
         } else {
             builder.setLine(node->getLoc().line, node->getLoc().getFilename());
-            operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType()));
+             glslang::TOperator glslangOp = node->getOp();
+             if (arg == 1 &&
+                (glslangOp == glslang::EOpRayQueryGetIntersectionType ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionT ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionInstanceCustomIndex ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionInstanceId ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionGeometryIndex ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionPrimitiveIndex ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionBarycentrics ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionFrontFace ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayDirection ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject
+                    )) {
+                bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst();
+                operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
+            }
+            else {
+                operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType()));
+            }
+
         }
     }
 
@@ -3549,6 +3600,9 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
     case glslang::EbtAccStruct:
         spvType = builder.makeAccelerationStructureType();
         break;
+    case glslang::EbtRayQuery:
+        spvType = builder.makeRayQueryType();
+        break;
     case glslang::EbtReference:
         {
             // Make the forward pointer, then recurse to convert the structure type, then
@@ -7615,6 +7669,103 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         return 0;
     }
     break;
+    case glslang::EOpRayQueryInitialize: {
+        builder.createNoResultOp(spv::OpRayQueryInitializeKHR, operands);
+        return 0;
+    } break;
+    case glslang::EOpRayQueryTerminate: {
+        builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operands);
+        return 0;
+    } break;
+    case glslang::EOpRayQueryGenerateIntersection: {
+        builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR, operands);
+        return 0;
+    } break;
+    case glslang::EOpRayQueryConfirmIntersection: {
+        builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operands);
+        return 0;
+    } break;
+    case glslang::EOpRayQueryProceed: {
+        typeId = builder.makeBoolType();
+        opCode = spv::OpRayQueryProceedKHR;
+    }
+    break;
+    case glslang::EOpRayQueryGetIntersectionType: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionTypeKHR;
+    } break;
+    case glslang::EOpRayQueryGetRayTMin: {
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpRayQueryGetRayTMinKHR;
+    } break;
+    case glslang::EOpRayQueryGetRayFlags: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetRayFlagsKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionT: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionTKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionInstanceCustomIndexKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionInstanceId: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionInstanceIdKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionGeometryIndex: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionGeometryIndexKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionPrimitiveIndex: {
+        typeId = builder.makeIntType(32);
+        opCode = spv::OpRayQueryGetIntersectionPrimitiveIndexKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionBarycentrics: {
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
+        opCode = spv::OpRayQueryGetIntersectionBarycentricsKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionFrontFace: {
+        typeId = builder.makeBoolType();
+        opCode = spv::OpRayQueryGetIntersectionFrontFaceKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque: {
+        typeId = builder.makeBoolType();
+        opCode = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionObjectRayDirection: {
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpRayQueryGetIntersectionObjectRayDirectionKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionObjectRayOrigin: {
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpRayQueryGetIntersectionObjectRayOriginKHR;
+    } break;
+    case glslang::EOpRayQueryGetWorldRayDirection: {
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpRayQueryGetWorldRayDirectionKHR;
+    } break;
+    case glslang::EOpRayQueryGetWorldRayOrigin: {
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpRayQueryGetWorldRayOriginKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionObjectToWorld: {
+        typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+        // https://gitlab.khronos.org/spirv/spirv-extensions/blob/cdf44fd4b854a5297bf2191d4f57f9bccbc49098/SPV_KHR_ray_query.asciidoc#ray_query_candidate_intersection_type
+        // or per description is it typeId = builder.makeVectorType(builder.makeVectorType(builder.makeFloatType(32), 3), 4);
+        opCode = spv::OpRayQueryGetIntersectionObjectToWorldKHR;
+    } break;
+    case glslang::EOpRayQueryGetIntersectionWorldToObject: {
+        typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+        // https://gitlab.khronos.org/spirv/spirv-extensions/blob/cdf44fd4b854a5297bf2191d4f57f9bccbc49098/SPV_KHR_ray_query.asciidoc#ray_query_candidate_intersection_type
+        // or per description is it typeId = builder.makeVectorType(builder.makeVectorType(builder.makeFloatType(32), 3), 4);
+        opCode = spv::OpRayQueryGetIntersectionWorldToObjectKHR;
+    } break;
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
         builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
         return 0;
@@ -7817,7 +7968,18 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv:
     case glslang::EOpTerminateRay:
         builder.createNoResultOp(spv::OpTerminateRayKHR);
         return 0;
-
+    case glslang::EOpRayQueryInitialize:
+        builder.createNoResultOp(spv::OpRayQueryInitializeKHR);
+        return 0;
+    case glslang::EOpRayQueryTerminate:
+        builder.createNoResultOp(spv::OpRayQueryTerminateKHR);
+        return 0;
+    case glslang::EOpRayQueryGenerateIntersection:
+        builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR);
+        return 0;
+    case glslang::EOpRayQueryConfirmIntersection:
+        builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR);
+        return 0;
     case glslang::EOpBeginInvocationInterlock:
         builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT);
         return 0;

diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index 075cc98540b02c21ad3975e9b5a3119b3f6620ff..6cf70a12d1229ba3ec53bf95e58ffb985ebef6c1 100644 (file)
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -1,6 +1,7 @@
 //
 // Copyright (C) 2014-2015 LunarG, Inc.
 // Copyright (C) 2015-2018 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -616,6 +617,21 @@ Id Builder::makeAccelerationStructureType()
 
     return type->getResultId();
 }
+
+Id Builder::makeRayQueryType()
+{
+    Instruction *type;
+    if (groupedTypes[OpTypeRayQueryProvisionalKHR].size() == 0) {
+        type = new Instruction(getUniqueId(), NoType, OpTypeRayQueryProvisionalKHR);
+        groupedTypes[OpTypeRayQueryProvisionalKHR].push_back(type);
+        constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+        module.mapInstruction(type);
+    } else {
+        type = groupedTypes[OpTypeRayQueryProvisionalKHR].back();
+    }
+
+    return type->getResultId();
+}
 #endif
 
 Id Builder::getDerefTypeId(Id resultId) const

diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index 885902977875c56b4f45e94f2c787fa497beb3ff..71b90d609bb9f9136398391417505111b5201799 100644 (file)
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -2,6 +2,7 @@
 // Copyright (C) 2014-2015 LunarG, Inc.
 // Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -183,6 +184,8 @@ public:
 
     // accelerationStructureNV type
     Id makeAccelerationStructureType();
+    // rayQueryEXT type
+    Id makeRayQueryType();
 
     // For querying about types.
     Id getTypeId(Id resultId) const { return module.getTypeId(resultId); }

diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
index f3c399929f45dc5d80b38f8756ac44214bf02ee4..b1f2b820d247900a3e7bac1e27fc147c34a825f0 100644 (file)
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -1,5 +1,6 @@
 //
 // Copyright (C) 2014-2015 LunarG, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -892,6 +893,8 @@ const char* CapabilityString(int info)
     case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
     case CapabilityRayTracingNV:                    return "RayTracingNV";
     case CapabilityRayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
+    case CapabilityRayQueryProvisionalKHR:          return "RayQueryProvisionalKHR";
+    case CapabilityRayTraversalPrimitiveCullingProvisionalKHR: return "RayTraversalPrimitiveCullingProvisionalKHR";
     case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
     case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
     case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
@@ -1337,6 +1340,31 @@ const char* OpcodeString(int op)
     case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
 
+    case OpTypeRayQueryProvisionalKHR:                                        return "OpTypeRayQueryProvisionalKHR";
+    case OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
+    case OpRayQueryTerminateKHR:                                              return "OpRayQueryTerminateKHR";
+    case OpRayQueryGenerateIntersectionKHR:                                   return "OpRayQueryGenerateIntersectionKHR";
+    case OpRayQueryConfirmIntersectionKHR:                                    return "OpRayQueryConfirmIntersectionKHR";
+    case OpRayQueryProceedKHR:                                                return "OpRayQueryProceedKHR";
+    case OpRayQueryGetIntersectionTypeKHR:                                    return "OpRayQueryGetIntersectionTypeKHR";
+    case OpRayQueryGetRayTMinKHR:                                             return "OpRayQueryGetRayTMinKHR";
+    case OpRayQueryGetRayFlagsKHR:                                            return "OpRayQueryGetRayFlagsKHR";
+    case OpRayQueryGetIntersectionTKHR:                                       return "OpRayQueryGetIntersectionTKHR";
+    case OpRayQueryGetIntersectionInstanceCustomIndexKHR:                     return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
+    case OpRayQueryGetIntersectionInstanceIdKHR:                              return "OpRayQueryGetIntersectionInstanceIdKHR";
+    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:  return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
+    case OpRayQueryGetIntersectionGeometryIndexKHR:                           return "OpRayQueryGetIntersectionGeometryIndexKHR";
+    case OpRayQueryGetIntersectionPrimitiveIndexKHR:                          return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
+    case OpRayQueryGetIntersectionBarycentricsKHR:                            return "OpRayQueryGetIntersectionBarycentricsKHR";
+    case OpRayQueryGetIntersectionFrontFaceKHR:                               return "OpRayQueryGetIntersectionFrontFaceKHR";
+    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:                     return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
+    case OpRayQueryGetIntersectionObjectRayDirectionKHR:                      return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
+    case OpRayQueryGetIntersectionObjectRayOriginKHR:                         return "OpRayQueryGetIntersectionObjectRayOriginKHR";
+    case OpRayQueryGetWorldRayDirectionKHR:                                   return "OpRayQueryGetWorldRayDirectionKHR";
+    case OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
+    case OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
+    case OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
+
     case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
     case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
     case OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
@@ -2722,6 +2750,100 @@ void Parameterize()
     InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData ID");
     InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
 
+    // Ray Query
+    InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
+    InstructionDesc[OpTypeRayQueryProvisionalKHR].setResultAndType(true, false);
+
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
+    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
+    InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
+
+    InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
+
+    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
+    InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
+
+    InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
+
+    InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
+
+    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
+    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
+    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
+
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");

diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index 9f98683d4f3d9dceae287381326e7e51fe38cf36..c2f790902e05b48e55d2f4d17852e0e6de74dd8d 100644 (file)
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2020 The Khronos Group Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 // 
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and/or associated documentation files (the "Materials"),
@@ -1939,6 +1940,31 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
     case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
     case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
+    case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
+    case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
     case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
     case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
     case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;

diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h
index b2d6cb80b768c13e5fb6e943851ed409aebfa62a..816b17948671bc3300f96fc28805e80868659a12 100644 (file)
--- a/glslang/Include/BaseTypes.h
+++ b/glslang/Include/BaseTypes.h
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -63,6 +64,7 @@ enum TBasicType {
     EbtBlock,
     EbtAccStruct,
     EbtReference,
+    EbtRayQuery,
 
     // HLSL types that live only temporarily.
     EbtString,

diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h
index 350b0e89dc4b070e465e44d1d79922194b95baa2..a8c57a4a64424eb2655d614f33411e73f3adf7ee 100644 (file)
--- a/glslang/Include/Types.h
+++ b/glslang/Include/Types.h
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2015-2016 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -1673,7 +1674,7 @@ public:
     }
     virtual bool isOpaque() const { return basicType == EbtSampler
 #ifndef GLSLANG_WEB
-         || basicType == EbtAtomicUint || basicType == EbtAccStruct
+         || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
 #endif
         ; }
     virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
@@ -1950,6 +1951,7 @@ public:
         case EbtStruct:            return "structure";
         case EbtBlock:             return "block";
         case EbtAccStruct:         return "accelerationStructureNV";
+        case EbtRayQuery:          return "rayQueryEXT";
         case EbtReference:         return "reference";
 #endif
         default:                   return "unknown type";

diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
index 47cc274a19e1dffdb5cfd2c1794fcda8dc3699d9..bf12fcf8f7e8426ddeac4f09bde9fbd07d148d2b 100644 (file)
--- a/glslang/Include/intermediate.h
+++ b/glslang/Include/intermediate.h
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -916,6 +917,35 @@ enum TOperator {
     EOpTerminateRay,
     EOpExecuteCallable,
     EOpWritePackedPrimitiveIndices4x8NV,
+
+    //
+    // GL_EXT_ray_query operations
+    //
+
+    EOpRayQueryInitialize,
+    EOpRayQueryTerminate,
+    EOpRayQueryGenerateIntersection,
+    EOpRayQueryConfirmIntersection,
+    EOpRayQueryProceed,
+    EOpRayQueryGetIntersectionType,
+    EOpRayQueryGetRayTMin,
+    EOpRayQueryGetRayFlags,
+    EOpRayQueryGetIntersectionT,
+    EOpRayQueryGetIntersectionInstanceCustomIndex,
+    EOpRayQueryGetIntersectionInstanceId,
+    EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset,
+    EOpRayQueryGetIntersectionGeometryIndex,
+    EOpRayQueryGetIntersectionPrimitiveIndex,
+    EOpRayQueryGetIntersectionBarycentrics,
+    EOpRayQueryGetIntersectionFrontFace,
+    EOpRayQueryGetIntersectionCandidateAABBOpaque,
+    EOpRayQueryGetIntersectionObjectRayDirection,
+    EOpRayQueryGetIntersectionObjectRayOrigin,
+    EOpRayQueryGetWorldRayDirection,
+    EOpRayQueryGetWorldRayOrigin,
+    EOpRayQueryGetIntersectionObjectToWorld,
+    EOpRayQueryGetIntersectionWorldToObject,
+
     //
     // HLSL operations
     //

diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp
index 92326a969e1fa2b007ae91d24ade73571c258fea..0f31225a29bf0088a8be2c9f5164cac4702877a3 100644 (file)
--- a/glslang/MachineIndependent/Initialize.cpp
+++ b/glslang/MachineIndependent/Initialize.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -4322,8 +4323,33 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
             "\n");
         }
 
-    // Builtins for GL_NV_ray_tracing/GL_EXT_ray_tracing
+    // Builtins for GL_NV_ray_tracing/GL_EXT_ray_tracing//GL_EXT_ray_query
     if (profile != EEsProfile && version >= 460) {
+         commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);"
+            "bool rayQueryProceedEXT(rayQueryEXT);"
+            "void rayQueryTerminateEXT(rayQueryEXT);"
+            "void rayQueryGenerateIntersectionEXT(rayQueryEXT, float);"
+            "void rayQueryConfirmIntersectionEXT(rayQueryEXT);"
+            "uint rayQueryGetIntersectionTypeEXT(rayQueryEXT, bool);"
+            "float rayQueryGetRayTMinEXT(rayQueryEXT);"
+            "uint rayQueryGetRayFlagsEXT(rayQueryEXT);"
+            "vec3 rayQueryGetWorldRayOriginEXT(rayQueryEXT);"
+            "vec3 rayQueryGetWorldRayDirectionEXT(rayQueryEXT);"
+            "float rayQueryGetIntersectionTEXT(rayQueryEXT, bool);"
+            "int rayQueryGetIntersectionInstanceCustomIndexEXT(rayQueryEXT, bool);"
+            "int rayQueryGetIntersectionInstanceIdEXT(rayQueryEXT, bool);"
+            "uint rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT(rayQueryEXT, bool);"
+            "int rayQueryGetIntersectionGeometryIndexEXT(rayQueryEXT, bool);"
+            "int rayQueryGetIntersectionPrimitiveIndexEXT(rayQueryEXT, bool);"
+            "vec2 rayQueryGetIntersectionBarycentricsEXT(rayQueryEXT, bool);"
+            "bool rayQueryGetIntersectionFrontFaceEXT(rayQueryEXT, bool);"
+            "bool rayQueryGetIntersectionCandidateAABBOpaqueEXT(rayQueryEXT);"
+            "vec3 rayQueryGetIntersectionObjectRayDirectionEXT(rayQueryEXT, bool);"
+            "vec3 rayQueryGetIntersectionObjectRayOriginEXT(rayQueryEXT, bool);"
+            "mat4x3 rayQueryGetIntersectionObjectToWorldEXT(rayQueryEXT, bool);"
+            "mat4x3 rayQueryGetIntersectionWorldToObjectEXT(rayQueryEXT, bool);"
+            "\n");
+
         stageBuiltins[EShLangRayGen].append(
             "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
             "void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
@@ -5436,6 +5462,17 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
             "const uint gl_HitKindFrontFacingTriangleEXT = 254U;"
             "const uint gl_HitKindBackFacingTriangleEXT = 255U;"
             "\n";
+
+        const char *constRayQueryIntersection =
+            "const uint gl_RayQueryCandidateIntersectionEXT = 0U;"
+            "const uint gl_RayQueryCommittedIntersectionEXT = 1U;"
+            "const uint gl_RayQueryCommittedIntersectionNoneEXT = 0U;"
+            "const uint gl_RayQueryCommittedIntersectionTriangleEXT = 1U;"
+            "const uint gl_RayQueryCommittedIntersectionGeneratedEXT = 2U;"
+            "const uint gl_RayQueryCandidateIntersectionTriangleEXT = 0U;"
+            "const uint gl_RayQueryCandidateIntersectionAABBEXT = 1U;"
+            "\n";
+
         const char *rayGenDecls =
             "in    uvec3  gl_LaunchIDNV;"
             "in    uvec3  gl_LaunchIDEXT;"
@@ -5535,6 +5572,7 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
             "\n";
 
 
+        commonBuiltins.append(constRayQueryIntersection);
 
         stageBuiltins[EShLangRayGen].append(rayGenDecls);
         stageBuiltins[EShLangRayGen].append(constRayFlags);
@@ -7522,6 +7560,32 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
             BuiltInVariable("gl_FragStencilRefARB", EbvFragStencilRef, symbolTable);
         }
 
+        if (profile != EEsProfile && version >= 460) {
+            symbolTable.setFunctionExtensions("rayQueryInitializeEXT",                                            1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryTerminateEXT",                                             1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGenerateIntersectionEXT",                                  1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryConfirmIntersectionEXT",                                   1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryProceedEXT",                                               1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionTypeEXT",                                   1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionTEXT",                                      1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetRayFlagsEXT",                                           1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetRayTMinEXT",                                            1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceCustomIndexEXT",                    1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceIdEXT",                             1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT", 1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionGeometryIndexEXT",                          1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionPrimitiveIndexEXT",                         1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionBarycentricsEXT",                           1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionFrontFaceEXT",                              1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionCandidateAABBOpaqueEXT",                    1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayDirectionEXT",                     1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayOriginEXT",                        1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectToWorldEXT",                          1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetIntersectionWorldToObjectEXT",                          1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetWorldRayOriginEXT",                                     1, &E_GL_EXT_ray_query);
+            symbolTable.setFunctionExtensions("rayQueryGetWorldRayDirectionEXT",                                  1, &E_GL_EXT_ray_query);
+        }
+
         if ((profile != EEsProfile && version >= 130) ||
             (profile == EEsProfile && version >= 310)) {
             BuiltInVariable("gl_SampleID",           EbvSampleId,       symbolTable);
@@ -8860,6 +8924,33 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
             symbolTable.relateToOperator("dFdyCoarse",   EOpDPdyCoarse);
             symbolTable.relateToOperator("fwidthCoarse", EOpFwidthCoarse);
         }
+
+        if (profile != EEsProfile && version >= 460) {
+            symbolTable.relateToOperator("rayQueryInitializeEXT",                                             EOpRayQueryInitialize);
+            symbolTable.relateToOperator("rayQueryTerminateEXT",                                              EOpRayQueryTerminate);
+            symbolTable.relateToOperator("rayQueryGenerateIntersectionEXT",                                   EOpRayQueryGenerateIntersection);
+            symbolTable.relateToOperator("rayQueryConfirmIntersectionEXT",                                    EOpRayQueryConfirmIntersection);
+            symbolTable.relateToOperator("rayQueryProceedEXT",                                                EOpRayQueryProceed);
+            symbolTable.relateToOperator("rayQueryGetIntersectionTypeEXT",                                    EOpRayQueryGetIntersectionType);
+            symbolTable.relateToOperator("rayQueryGetRayTMinEXT",                                             EOpRayQueryGetRayTMin);
+            symbolTable.relateToOperator("rayQueryGetRayFlagsEXT",                                            EOpRayQueryGetRayFlags);
+            symbolTable.relateToOperator("rayQueryGetIntersectionTEXT",                                       EOpRayQueryGetIntersectionT);
+            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceCustomIndexEXT",                     EOpRayQueryGetIntersectionInstanceCustomIndex);
+            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceIdEXT",                              EOpRayQueryGetIntersectionInstanceId);
+            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT",  EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset);
+            symbolTable.relateToOperator("rayQueryGetIntersectionGeometryIndexEXT",                           EOpRayQueryGetIntersectionGeometryIndex);
+            symbolTable.relateToOperator("rayQueryGetIntersectionPrimitiveIndexEXT",                          EOpRayQueryGetIntersectionPrimitiveIndex);
+            symbolTable.relateToOperator("rayQueryGetIntersectionBarycentricsEXT",                            EOpRayQueryGetIntersectionBarycentrics);
+            symbolTable.relateToOperator("rayQueryGetIntersectionFrontFaceEXT",                               EOpRayQueryGetIntersectionFrontFace);
+            symbolTable.relateToOperator("rayQueryGetIntersectionCandidateAABBOpaqueEXT",                     EOpRayQueryGetIntersectionCandidateAABBOpaque);
+            symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayDirectionEXT",                      EOpRayQueryGetIntersectionObjectRayDirection);
+            symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayOriginEXT",                         EOpRayQueryGetIntersectionObjectRayOrigin);
+            symbolTable.relateToOperator("rayQueryGetWorldRayDirectionEXT",                                   EOpRayQueryGetWorldRayDirection);
+            symbolTable.relateToOperator("rayQueryGetWorldRayOriginEXT",                                      EOpRayQueryGetWorldRayOrigin);
+            symbolTable.relateToOperator("rayQueryGetIntersectionObjectToWorldEXT",                           EOpRayQueryGetIntersectionObjectToWorld);
+            symbolTable.relateToOperator("rayQueryGetIntersectionWorldToObjectEXT",                           EOpRayQueryGetIntersectionWorldToObject);
+        }
+
         symbolTable.relateToOperator("interpolateAtCentroid", EOpInterpolateAtCentroid);
         symbolTable.relateToOperator("interpolateAtSample",   EOpInterpolateAtSample);
         symbolTable.relateToOperator("interpolateAtOffset",   EOpInterpolateAtOffset);

diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp
index f6a5e7f27a98d0ea58a45a60d5a62e8f4876cfe5..5bd764ef1881d3578279f99f2d8a054c792b2e7a 100755 (executable)
--- a/glslang/MachineIndependent/Intermediate.cpp
+++ b/glslang/MachineIndependent/Intermediate.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2015 LunarG, Inc.
 // Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -539,6 +540,7 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const
     case EbtAtomicUint:
     case EbtSampler:
     case EbtAccStruct:
+    case EbtRayQuery:
         // opaque types can be passed to functions
         if (op == EOpFunction)
             break;

diff --git a/glslang/MachineIndependent/ParseContextBase.cpp b/glslang/MachineIndependent/ParseContextBase.cpp
index 81842d83be359b60c517dbfc667b400066421b8b..58da56daf51e4dc435b03ddfb1c25ca1b2e299d6 100644 (file)
--- a/glslang/MachineIndependent/ParseContextBase.cpp
+++ b/glslang/MachineIndependent/ParseContextBase.cpp
@@ -1,6 +1,7 @@
 //
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2016 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -184,6 +185,9 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
         case EbtAccStruct:
             message = "can't modify accelerationStructureNV";
             break;
+        case EbtRayQuery:
+            message = "can't modify rayQueryEXT";
+            break;
 #endif
         default:
             break;

diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
index d338a7dddbd928b06a53a985aa0821599bec617b..01ef094212c0a0f0f22e3efb395b584e9265179e 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.cpp
+++ b/glslang/MachineIndependent/ParseHelper.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2015 LunarG, Inc.
 // Copyright (C) 2015-2018 Google, Inc.
 // Copyright (C) 2017, 2019 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -2041,6 +2042,23 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
             error(loc, "argument must be compile-time constant", "callable data number", "");
         break;
 
+    case EOpRayQueryGetIntersectionType:
+    case EOpRayQueryGetIntersectionT:
+    case EOpRayQueryGetIntersectionInstanceCustomIndex:
+    case EOpRayQueryGetIntersectionInstanceId:
+    case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
+    case EOpRayQueryGetIntersectionGeometryIndex:
+    case EOpRayQueryGetIntersectionPrimitiveIndex:
+    case EOpRayQueryGetIntersectionBarycentrics:
+    case EOpRayQueryGetIntersectionFrontFace:
+    case EOpRayQueryGetIntersectionObjectRayDirection:
+    case EOpRayQueryGetIntersectionObjectRayOrigin:
+    case EOpRayQueryGetIntersectionObjectToWorld:
+    case EOpRayQueryGetIntersectionWorldToObject:
+        if (!(*argp)[1]->getAsConstantUnion())
+            error(loc, "argument must be compile-time constant", "committed", "");
+        break;
+
     case EOpTextureQuerySamples:
     case EOpImageQuerySamples:
         // GL_ARB_shader_texture_image_samples
@@ -3241,6 +3259,11 @@ void TParseContext::accStructCheck(const TSourceLoc& loc, const TType& type, con
 
 }
 
+void TParseContext::rayQueryCheck(const TSourceLoc& loc, const TType& type, const TString& identifier)
+{
+    return;
+}
+
 #endif // GLSLANG_WEB
 
 void TParseContext::transparentOpaqueCheck(const TSourceLoc& loc, const TType& type, const TString& identifier)
@@ -3992,7 +4015,7 @@ void TParseContext::checkRuntimeSizable(const TSourceLoc& loc, const TIntermType
     }
 
     // check for additional things allowed by GL_EXT_nonuniform_qualifier
-    if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct ||
+    if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || base.getBasicType() == EbtRayQuery ||
         (base.getBasicType() == EbtBlock && base.getType().getQualifier().isUniformOrBuffer()))
         requireExtensions(loc, 1, &E_GL_EXT_nonuniform_qualifier, "variable index");
     else
@@ -6488,6 +6511,7 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
 #ifndef GLSLANG_WEB
     atomicUintCheck(loc, type, identifier);
     accStructCheck(loc, type, identifier);
+    rayQueryCheck(loc, type, identifier);
     checkAndResizeMeshViewDim(loc, type, /*isBlockMember*/ false);
 #endif
     if (type.getQualifier().storage == EvqConst && type.containsReference()) {

diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h
index 20df640538fdd0eb303ab1ae74e0b959dfd8b9fc..aea1eb609943eebf11712379a5d7b7c4b36db4e5 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.h
+++ b/glslang/MachineIndependent/ParseHelper.h
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2015-2018 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -359,6 +360,7 @@ public:
     void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier, TIntermTyped* initializer);
     void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier);
     void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
+    void rayQueryCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
     void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier);
     void memberQualifierCheck(glslang::TPublicType&);
     void globalQualifierFixCheck(const TSourceLoc&, TQualifier&);

diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
index 0fafe931d0cdcea9e4377f94e767392cd7f5b603..b37e1ef95b0056a8da792df6b23ed9ce4f6762dd 100644 (file)
--- a/glslang/MachineIndependent/Scan.cpp
+++ b/glslang/MachineIndependent/Scan.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2020 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -715,6 +716,7 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["callableDataInEXT"] =       CALLDATAINEXT;
     (*KeywordMap)["accelerationStructureNV"] = ACCSTRUCTNV;
     (*KeywordMap)["accelerationStructureEXT"]   = ACCSTRUCTEXT;
+    (*KeywordMap)["rayQueryEXT"] =              RAYQUERYEXT;
     (*KeywordMap)["perprimitiveNV"] =          PERPRIMITIVENV;
     (*KeywordMap)["perviewNV"] =               PERVIEWNV;
     (*KeywordMap)["taskNV"] =                  PERTASKNV;
@@ -1031,6 +1033,12 @@ int TScanContext::tokenizeIdentifier()
             parseContext.extensionTurnedOn(E_GL_EXT_ray_tracing))
             return keyword;
         return identifierOrType();
+    case RAYQUERYEXT:
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            (!parseContext.isEsProfile() && parseContext.version >= 460
+                 && parseContext.extensionTurnedOn(E_GL_EXT_ray_query)))
+            return keyword;
+        return identifierOrType();
     case ATOMIC_UINT:
         if ((parseContext.isEsProfile() && parseContext.version >= 310) ||
             parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters))

diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp
index 07c8b42fe637a93e7df5f3dfed5fdc8989ae1fc1..5dc8353988c9abee5f1d32fe899a4a3df79962bb 100644 (file)
--- a/glslang/MachineIndependent/SymbolTable.cpp
+++ b/glslang/MachineIndependent/SymbolTable.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2018 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -75,6 +76,7 @@ void TType::buildMangledName(TString& mangledName) const
     case EbtUint64:             mangledName += "u64";    break;
     case EbtAtomicUint:         mangledName += "au";     break;
     case EbtAccStruct:          mangledName += "as";     break;
+    case EbtRayQuery:           mangledName += "rq";     break;
 #endif
     case EbtSampler:
         switch (sampler.type) {

diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
index 819bac7c5062a42a68bb0a43e5ce0e4dce784b5e..180f5b3d1f4edc3492790c7b007d5f4e2de7f3d6 100644 (file)
--- a/glslang/MachineIndependent/Versions.cpp
+++ b/glslang/MachineIndependent/Versions.cpp
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2020 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -296,6 +297,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_multiview]                = EBhDisable;
     extensionBehavior[E_GL_EXT_shader_realtime_clock]    = EBhDisable;
     extensionBehavior[E_GL_EXT_ray_tracing]              = EBhDisable;
+    extensionBehavior[E_GL_EXT_ray_query]                = EBhDisable;
 
     // OVR extensions
     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -435,6 +437,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define E_GL_EXT_shader_atomic_int64 1\n"
             "#define E_GL_EXT_shader_realtime_clock 1\n"
             "#define E_GL_EXT_ray_tracing 1\n"
+            "#define E_GL_EXT_ray_query 1\n"
 
             "#define GL_AMD_shader_ballot 1\n"
             "#define GL_AMD_shader_trinary_minmax 1\n"

diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
index 173995fa40203a95d563f0a0f338072ac3240570..e8cebebf9cd9b9f8880721aa7546b4ab36688a78 100644 (file)
--- a/glslang/MachineIndependent/Versions.h
+++ b/glslang/MachineIndependent/Versions.h
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2018 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -187,6 +188,7 @@ const char* const E_GL_EXT_demote_to_helper_invocation      = "GL_EXT_demote_to_
 const char* const E_GL_EXT_shader_realtime_clock            = "GL_EXT_shader_realtime_clock";
 const char* const E_GL_EXT_debug_printf                     = "GL_EXT_debug_printf";
 const char* const E_GL_EXT_ray_tracing                      = "GL_EXT_ray_tracing";
+const char* const E_GL_EXT_ray_query                        = "GL_EXT_ray_query";
 
 // Arrays of extensions for the above viewportEXTs duplications
 

diff --git a/glslang/MachineIndependent/glslang.m4 b/glslang/MachineIndependent/glslang.m4
index 38b7608fc3bffcea0f245421a6c8daffa47c4c04..1432bf6e80cac3f8fc3b5aac26fbbc89e7137efb 100644 (file)
--- a/glslang/MachineIndependent/glslang.m4
+++ b/glslang/MachineIndependent/glslang.m4
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2019 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -205,6 +206,7 @@ GLSLANG_WEB_EXCLUDE_ON
 %token <lex> ATOMIC_UINT
 %token <lex> ACCSTRUCTNV
 %token <lex> ACCSTRUCTEXT
+%token <lex> RAYQUERYEXT
 %token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
 
 // combined image/sampler
@@ -2406,6 +2408,10 @@ GLSLANG_WEB_EXCLUDE_ON
        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
        $$.basicType = EbtAccStruct;
     }
+    | RAYQUERYEXT {
+       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+       $$.basicType = EbtRayQuery;
+    }
     | ATOMIC_UINT {
         parseContext.vulkanRemoved($1.loc, "atomic counter types");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());

diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
index c03847b93c9cc9decdb22d78027f6e75e42baac6..e33d7d1ca319a28a563b947080d76bd9c2931c54 100644 (file)
--- a/glslang/MachineIndependent/glslang.y
+++ b/glslang/MachineIndependent/glslang.y
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2019 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -205,6 +206,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> ATOMIC_UINT
 %token <lex> ACCSTRUCTNV
 %token <lex> ACCSTRUCTEXT
+%token <lex> RAYQUERYEXT
 %token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
 
 // combined image/sampler
@@ -2406,6 +2408,10 @@ type_specifier_nonarray
        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
        $$.basicType = EbtAccStruct;
     }
+    | RAYQUERYEXT {
+       $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+       $$.basicType = EbtRayQuery;
+    }
     | ATOMIC_UINT {
         parseContext.vulkanRemoved($1.loc, "atomic counter types");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
@@ -3879,3 +3885,4 @@ single_attribute
 
 
 %%
+

diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
index ee9a654b1537d1bcac771f32eac169c26eb3396e..69f7f8e0b665362df87216d414211a27b076f2b0 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp
+++ b/glslang/MachineIndependent/glslang_tab.cpp
@@ -62,7 +62,7 @@
 
 
 /* Copy the first part of user declarations.  */
-#line 68 "MachineIndependent/glslang.y" /* yacc.c:339  */
+#line 69 "glslang.y" /* yacc.c:339  */
 
 
 /* Based on:
@@ -88,7 +88,7 @@ Jutta Degener, 1995
 using namespace glslang;
 
 
-#line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339  */
+#line 92 "glslang_tab.cpp" /* yacc.c:339  */
 
 # ifndef YY_NULLPTR
 #  if defined __cplusplus && 201103L <= __cplusplus
@@ -108,8 +108,8 @@ using namespace glslang;
 
 /* In a future release of Bison, this section will be replaced
    by #include "glslang_tab.cpp.h".  */
-#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -282,263 +282,264 @@ extern int yydebug;
     ATOMIC_UINT = 414,
     ACCSTRUCTNV = 415,
     ACCSTRUCTEXT = 416,
-    FCOOPMATNV = 417,
-    ICOOPMATNV = 418,
-    UCOOPMATNV = 419,
-    SAMPLERCUBEARRAY = 420,
-    SAMPLERCUBEARRAYSHADOW = 421,
-    ISAMPLERCUBEARRAY = 422,
-    USAMPLERCUBEARRAY = 423,
-    SAMPLER1D = 424,
-    SAMPLER1DARRAY = 425,
-    SAMPLER1DARRAYSHADOW = 426,
-    ISAMPLER1D = 427,
-    SAMPLER1DSHADOW = 428,
-    SAMPLER2DRECT = 429,
-    SAMPLER2DRECTSHADOW = 430,
-    ISAMPLER2DRECT = 431,
-    USAMPLER2DRECT = 432,
-    SAMPLERBUFFER = 433,
-    ISAMPLERBUFFER = 434,
-    USAMPLERBUFFER = 435,
-    SAMPLER2DMS = 436,
-    ISAMPLER2DMS = 437,
-    USAMPLER2DMS = 438,
-    SAMPLER2DMSARRAY = 439,
-    ISAMPLER2DMSARRAY = 440,
-    USAMPLER2DMSARRAY = 441,
-    SAMPLEREXTERNALOES = 442,
-    SAMPLEREXTERNAL2DY2YEXT = 443,
-    ISAMPLER1DARRAY = 444,
-    USAMPLER1D = 445,
-    USAMPLER1DARRAY = 446,
-    F16SAMPLER1D = 447,
-    F16SAMPLER2D = 448,
-    F16SAMPLER3D = 449,
-    F16SAMPLER2DRECT = 450,
-    F16SAMPLERCUBE = 451,
-    F16SAMPLER1DARRAY = 452,
-    F16SAMPLER2DARRAY = 453,
-    F16SAMPLERCUBEARRAY = 454,
-    F16SAMPLERBUFFER = 455,
-    F16SAMPLER2DMS = 456,
-    F16SAMPLER2DMSARRAY = 457,
-    F16SAMPLER1DSHADOW = 458,
-    F16SAMPLER2DSHADOW = 459,
-    F16SAMPLER1DARRAYSHADOW = 460,
-    F16SAMPLER2DARRAYSHADOW = 461,
-    F16SAMPLER2DRECTSHADOW = 462,
-    F16SAMPLERCUBESHADOW = 463,
-    F16SAMPLERCUBEARRAYSHADOW = 464,
-    IMAGE1D = 465,
-    IIMAGE1D = 466,
-    UIMAGE1D = 467,
-    IMAGE2D = 468,
-    IIMAGE2D = 469,
-    UIMAGE2D = 470,
-    IMAGE3D = 471,
-    IIMAGE3D = 472,
-    UIMAGE3D = 473,
-    IMAGE2DRECT = 474,
-    IIMAGE2DRECT = 475,
-    UIMAGE2DRECT = 476,
-    IMAGECUBE = 477,
-    IIMAGECUBE = 478,
-    UIMAGECUBE = 479,
-    IMAGEBUFFER = 480,
-    IIMAGEBUFFER = 481,
-    UIMAGEBUFFER = 482,
-    IMAGE1DARRAY = 483,
-    IIMAGE1DARRAY = 484,
-    UIMAGE1DARRAY = 485,
-    IMAGE2DARRAY = 486,
-    IIMAGE2DARRAY = 487,
-    UIMAGE2DARRAY = 488,
-    IMAGECUBEARRAY = 489,
-    IIMAGECUBEARRAY = 490,
-    UIMAGECUBEARRAY = 491,
-    IMAGE2DMS = 492,
-    IIMAGE2DMS = 493,
-    UIMAGE2DMS = 494,
-    IMAGE2DMSARRAY = 495,
-    IIMAGE2DMSARRAY = 496,
-    UIMAGE2DMSARRAY = 497,
-    F16IMAGE1D = 498,
-    F16IMAGE2D = 499,
-    F16IMAGE3D = 500,
-    F16IMAGE2DRECT = 501,
-    F16IMAGECUBE = 502,
-    F16IMAGE1DARRAY = 503,
-    F16IMAGE2DARRAY = 504,
-    F16IMAGECUBEARRAY = 505,
-    F16IMAGEBUFFER = 506,
-    F16IMAGE2DMS = 507,
-    F16IMAGE2DMSARRAY = 508,
-    TEXTURECUBEARRAY = 509,
-    ITEXTURECUBEARRAY = 510,
-    UTEXTURECUBEARRAY = 511,
-    TEXTURE1D = 512,
-    ITEXTURE1D = 513,
-    UTEXTURE1D = 514,
-    TEXTURE1DARRAY = 515,
-    ITEXTURE1DARRAY = 516,
-    UTEXTURE1DARRAY = 517,
-    TEXTURE2DRECT = 518,
-    ITEXTURE2DRECT = 519,
-    UTEXTURE2DRECT = 520,
-    TEXTUREBUFFER = 521,
-    ITEXTUREBUFFER = 522,
-    UTEXTUREBUFFER = 523,
-    TEXTURE2DMS = 524,
-    ITEXTURE2DMS = 525,
-    UTEXTURE2DMS = 526,
-    TEXTURE2DMSARRAY = 527,
-    ITEXTURE2DMSARRAY = 528,
-    UTEXTURE2DMSARRAY = 529,
-    F16TEXTURE1D = 530,
-    F16TEXTURE2D = 531,
-    F16TEXTURE3D = 532,
-    F16TEXTURE2DRECT = 533,
-    F16TEXTURECUBE = 534,
-    F16TEXTURE1DARRAY = 535,
-    F16TEXTURE2DARRAY = 536,
-    F16TEXTURECUBEARRAY = 537,
-    F16TEXTUREBUFFER = 538,
-    F16TEXTURE2DMS = 539,
-    F16TEXTURE2DMSARRAY = 540,
-    SUBPASSINPUT = 541,
-    SUBPASSINPUTMS = 542,
-    ISUBPASSINPUT = 543,
-    ISUBPASSINPUTMS = 544,
-    USUBPASSINPUT = 545,
-    USUBPASSINPUTMS = 546,
-    F16SUBPASSINPUT = 547,
-    F16SUBPASSINPUTMS = 548,
-    LEFT_OP = 549,
-    RIGHT_OP = 550,
-    INC_OP = 551,
-    DEC_OP = 552,
-    LE_OP = 553,
-    GE_OP = 554,
-    EQ_OP = 555,
-    NE_OP = 556,
-    AND_OP = 557,
-    OR_OP = 558,
-    XOR_OP = 559,
-    MUL_ASSIGN = 560,
-    DIV_ASSIGN = 561,
-    ADD_ASSIGN = 562,
-    MOD_ASSIGN = 563,
-    LEFT_ASSIGN = 564,
-    RIGHT_ASSIGN = 565,
-    AND_ASSIGN = 566,
-    XOR_ASSIGN = 567,
-    OR_ASSIGN = 568,
-    SUB_ASSIGN = 569,
-    STRING_LITERAL = 570,
-    LEFT_PAREN = 571,
-    RIGHT_PAREN = 572,
-    LEFT_BRACKET = 573,
-    RIGHT_BRACKET = 574,
-    LEFT_BRACE = 575,
-    RIGHT_BRACE = 576,
-    DOT = 577,
-    COMMA = 578,
-    COLON = 579,
-    EQUAL = 580,
-    SEMICOLON = 581,
-    BANG = 582,
-    DASH = 583,
-    TILDE = 584,
-    PLUS = 585,
-    STAR = 586,
-    SLASH = 587,
-    PERCENT = 588,
-    LEFT_ANGLE = 589,
-    RIGHT_ANGLE = 590,
-    VERTICAL_BAR = 591,
-    CARET = 592,
-    AMPERSAND = 593,
-    QUESTION = 594,
-    INVARIANT = 595,
-    HIGH_PRECISION = 596,
-    MEDIUM_PRECISION = 597,
-    LOW_PRECISION = 598,
-    PRECISION = 599,
-    PACKED = 600,
-    RESOURCE = 601,
-    SUPERP = 602,
-    FLOATCONSTANT = 603,
-    INTCONSTANT = 604,
-    UINTCONSTANT = 605,
-    BOOLCONSTANT = 606,
-    IDENTIFIER = 607,
-    TYPE_NAME = 608,
-    CENTROID = 609,
-    IN = 610,
-    OUT = 611,
-    INOUT = 612,
-    STRUCT = 613,
-    VOID = 614,
-    WHILE = 615,
-    BREAK = 616,
-    CONTINUE = 617,
-    DO = 618,
-    ELSE = 619,
-    FOR = 620,
-    IF = 621,
-    DISCARD = 622,
-    RETURN = 623,
-    SWITCH = 624,
-    CASE = 625,
-    DEFAULT = 626,
-    UNIFORM = 627,
-    SHARED = 628,
-    BUFFER = 629,
-    FLAT = 630,
-    SMOOTH = 631,
-    LAYOUT = 632,
-    DOUBLECONSTANT = 633,
-    INT16CONSTANT = 634,
-    UINT16CONSTANT = 635,
-    FLOAT16CONSTANT = 636,
-    INT32CONSTANT = 637,
-    UINT32CONSTANT = 638,
-    INT64CONSTANT = 639,
-    UINT64CONSTANT = 640,
-    SUBROUTINE = 641,
-    DEMOTE = 642,
-    PAYLOADNV = 643,
-    PAYLOADINNV = 644,
-    HITATTRNV = 645,
-    CALLDATANV = 646,
-    CALLDATAINNV = 647,
-    PAYLOADEXT = 648,
-    PAYLOADINEXT = 649,
-    HITATTREXT = 650,
-    CALLDATAEXT = 651,
-    CALLDATAINEXT = 652,
-    PATCH = 653,
-    SAMPLE = 654,
-    NONUNIFORM = 655,
-    COHERENT = 656,
-    VOLATILE = 657,
-    RESTRICT = 658,
-    READONLY = 659,
-    WRITEONLY = 660,
-    DEVICECOHERENT = 661,
-    QUEUEFAMILYCOHERENT = 662,
-    WORKGROUPCOHERENT = 663,
-    SUBGROUPCOHERENT = 664,
-    NONPRIVATE = 665,
-    SHADERCALLCOHERENT = 666,
-    NOPERSPECTIVE = 667,
-    EXPLICITINTERPAMD = 668,
-    PERVERTEXNV = 669,
-    PERPRIMITIVENV = 670,
-    PERVIEWNV = 671,
-    PERTASKNV = 672,
-    PRECISE = 673
+    RAYQUERYEXT = 417,
+    FCOOPMATNV = 418,
+    ICOOPMATNV = 419,
+    UCOOPMATNV = 420,
+    SAMPLERCUBEARRAY = 421,
+    SAMPLERCUBEARRAYSHADOW = 422,
+    ISAMPLERCUBEARRAY = 423,
+    USAMPLERCUBEARRAY = 424,
+    SAMPLER1D = 425,
+    SAMPLER1DARRAY = 426,
+    SAMPLER1DARRAYSHADOW = 427,
+    ISAMPLER1D = 428,
+    SAMPLER1DSHADOW = 429,
+    SAMPLER2DRECT = 430,
+    SAMPLER2DRECTSHADOW = 431,
+    ISAMPLER2DRECT = 432,
+    USAMPLER2DRECT = 433,
+    SAMPLERBUFFER = 434,
+    ISAMPLERBUFFER = 435,
+    USAMPLERBUFFER = 436,
+    SAMPLER2DMS = 437,
+    ISAMPLER2DMS = 438,
+    USAMPLER2DMS = 439,
+    SAMPLER2DMSARRAY = 440,
+    ISAMPLER2DMSARRAY = 441,
+    USAMPLER2DMSARRAY = 442,
+    SAMPLEREXTERNALOES = 443,
+    SAMPLEREXTERNAL2DY2YEXT = 444,
+    ISAMPLER1DARRAY = 445,
+    USAMPLER1D = 446,
+    USAMPLER1DARRAY = 447,
+    F16SAMPLER1D = 448,
+    F16SAMPLER2D = 449,
+    F16SAMPLER3D = 450,
+    F16SAMPLER2DRECT = 451,
+    F16SAMPLERCUBE = 452,
+    F16SAMPLER1DARRAY = 453,
+    F16SAMPLER2DARRAY = 454,
+    F16SAMPLERCUBEARRAY = 455,
+    F16SAMPLERBUFFER = 456,
+    F16SAMPLER2DMS = 457,
+    F16SAMPLER2DMSARRAY = 458,
+    F16SAMPLER1DSHADOW = 459,
+    F16SAMPLER2DSHADOW = 460,
+    F16SAMPLER1DARRAYSHADOW = 461,
+    F16SAMPLER2DARRAYSHADOW = 462,
+    F16SAMPLER2DRECTSHADOW = 463,
+    F16SAMPLERCUBESHADOW = 464,
+    F16SAMPLERCUBEARRAYSHADOW = 465,
+    IMAGE1D = 466,
+    IIMAGE1D = 467,
+    UIMAGE1D = 468,
+    IMAGE2D = 469,
+    IIMAGE2D = 470,
+    UIMAGE2D = 471,
+    IMAGE3D = 472,
+    IIMAGE3D = 473,
+    UIMAGE3D = 474,
+    IMAGE2DRECT = 475,
+    IIMAGE2DRECT = 476,
+    UIMAGE2DRECT = 477,
+    IMAGECUBE = 478,
+    IIMAGECUBE = 479,
+    UIMAGECUBE = 480,
+    IMAGEBUFFER = 481,
+    IIMAGEBUFFER = 482,
+    UIMAGEBUFFER = 483,
+    IMAGE1DARRAY = 484,
+    IIMAGE1DARRAY = 485,
+    UIMAGE1DARRAY = 486,
+    IMAGE2DARRAY = 487,
+    IIMAGE2DARRAY = 488,
+    UIMAGE2DARRAY = 489,
+    IMAGECUBEARRAY = 490,
+    IIMAGECUBEARRAY = 491,
+    UIMAGECUBEARRAY = 492,
+    IMAGE2DMS = 493,
+    IIMAGE2DMS = 494,
+    UIMAGE2DMS = 495,
+    IMAGE2DMSARRAY = 496,
+    IIMAGE2DMSARRAY = 497,
+    UIMAGE2DMSARRAY = 498,
+    F16IMAGE1D = 499,
+    F16IMAGE2D = 500,
+    F16IMAGE3D = 501,
+    F16IMAGE2DRECT = 502,
+    F16IMAGECUBE = 503,
+    F16IMAGE1DARRAY = 504,
+    F16IMAGE2DARRAY = 505,
+    F16IMAGECUBEARRAY = 506,
+    F16IMAGEBUFFER = 507,
+    F16IMAGE2DMS = 508,
+    F16IMAGE2DMSARRAY = 509,
+    TEXTURECUBEARRAY = 510,
+    ITEXTURECUBEARRAY = 511,
+    UTEXTURECUBEARRAY = 512,
+    TEXTURE1D = 513,
+    ITEXTURE1D = 514,
+    UTEXTURE1D = 515,
+    TEXTURE1DARRAY = 516,
+    ITEXTURE1DARRAY = 517,
+    UTEXTURE1DARRAY = 518,
+    TEXTURE2DRECT = 519,
+    ITEXTURE2DRECT = 520,
+    UTEXTURE2DRECT = 521,
+    TEXTUREBUFFER = 522,
+    ITEXTUREBUFFER = 523,
+    UTEXTUREBUFFER = 524,
+    TEXTURE2DMS = 525,
+    ITEXTURE2DMS = 526,
+    UTEXTURE2DMS = 527,
+    TEXTURE2DMSARRAY = 528,
+    ITEXTURE2DMSARRAY = 529,
+    UTEXTURE2DMSARRAY = 530,
+    F16TEXTURE1D = 531,
+    F16TEXTURE2D = 532,
+    F16TEXTURE3D = 533,
+    F16TEXTURE2DRECT = 534,
+    F16TEXTURECUBE = 535,
+    F16TEXTURE1DARRAY = 536,
+    F16TEXTURE2DARRAY = 537,
+    F16TEXTURECUBEARRAY = 538,
+    F16TEXTUREBUFFER = 539,
+    F16TEXTURE2DMS = 540,
+    F16TEXTURE2DMSARRAY = 541,
+    SUBPASSINPUT = 542,
+    SUBPASSINPUTMS = 543,
+    ISUBPASSINPUT = 544,
+    ISUBPASSINPUTMS = 545,
+    USUBPASSINPUT = 546,
+    USUBPASSINPUTMS = 547,
+    F16SUBPASSINPUT = 548,
+    F16SUBPASSINPUTMS = 549,
+    LEFT_OP = 550,
+    RIGHT_OP = 551,
+    INC_OP = 552,
+    DEC_OP = 553,
+    LE_OP = 554,
+    GE_OP = 555,
+    EQ_OP = 556,
+    NE_OP = 557,
+    AND_OP = 558,
+    OR_OP = 559,
+    XOR_OP = 560,
+    MUL_ASSIGN = 561,
+    DIV_ASSIGN = 562,
+    ADD_ASSIGN = 563,
+    MOD_ASSIGN = 564,
+    LEFT_ASSIGN = 565,
+    RIGHT_ASSIGN = 566,
+    AND_ASSIGN = 567,
+    XOR_ASSIGN = 568,
+    OR_ASSIGN = 569,
+    SUB_ASSIGN = 570,
+    STRING_LITERAL = 571,
+    LEFT_PAREN = 572,
+    RIGHT_PAREN = 573,
+    LEFT_BRACKET = 574,
+    RIGHT_BRACKET = 575,
+    LEFT_BRACE = 576,
+    RIGHT_BRACE = 577,
+    DOT = 578,
+    COMMA = 579,
+    COLON = 580,
+    EQUAL = 581,
+    SEMICOLON = 582,
+    BANG = 583,
+    DASH = 584,
+    TILDE = 585,
+    PLUS = 586,
+    STAR = 587,
+    SLASH = 588,
+    PERCENT = 589,
+    LEFT_ANGLE = 590,
+    RIGHT_ANGLE = 591,
+    VERTICAL_BAR = 592,
+    CARET = 593,
+    AMPERSAND = 594,
+    QUESTION = 595,
+    INVARIANT = 596,
+    HIGH_PRECISION = 597,
+    MEDIUM_PRECISION = 598,
+    LOW_PRECISION = 599,
+    PRECISION = 600,
+    PACKED = 601,
+    RESOURCE = 602,
+    SUPERP = 603,
+    FLOATCONSTANT = 604,
+    INTCONSTANT = 605,
+    UINTCONSTANT = 606,
+    BOOLCONSTANT = 607,
+    IDENTIFIER = 608,
+    TYPE_NAME = 609,
+    CENTROID = 610,
+    IN = 611,
+    OUT = 612,
+    INOUT = 613,
+    STRUCT = 614,
+    VOID = 615,
+    WHILE = 616,
+    BREAK = 617,
+    CONTINUE = 618,
+    DO = 619,
+    ELSE = 620,
+    FOR = 621,
+    IF = 622,
+    DISCARD = 623,
+    RETURN = 624,
+    SWITCH = 625,
+    CASE = 626,
+    DEFAULT = 627,
+    UNIFORM = 628,
+    SHARED = 629,
+    BUFFER = 630,
+    FLAT = 631,
+    SMOOTH = 632,
+    LAYOUT = 633,
+    DOUBLECONSTANT = 634,
+    INT16CONSTANT = 635,
+    UINT16CONSTANT = 636,
+    FLOAT16CONSTANT = 637,
+    INT32CONSTANT = 638,
+    UINT32CONSTANT = 639,
+    INT64CONSTANT = 640,
+    UINT64CONSTANT = 641,
+    SUBROUTINE = 642,
+    DEMOTE = 643,
+    PAYLOADNV = 644,
+    PAYLOADINNV = 645,
+    HITATTRNV = 646,
+    CALLDATANV = 647,
+    CALLDATAINNV = 648,
+    PAYLOADEXT = 649,
+    PAYLOADINEXT = 650,
+    HITATTREXT = 651,
+    CALLDATAEXT = 652,
+    CALLDATAINEXT = 653,
+    PATCH = 654,
+    SAMPLE = 655,
+    NONUNIFORM = 656,
+    COHERENT = 657,
+    VOLATILE = 658,
+    RESTRICT = 659,
+    READONLY = 660,
+    WRITEONLY = 661,
+    DEVICECOHERENT = 662,
+    QUEUEFAMILYCOHERENT = 663,
+    WORKGROUPCOHERENT = 664,
+    SUBGROUPCOHERENT = 665,
+    NONPRIVATE = 666,
+    SHADERCALLCOHERENT = 667,
+    NOPERSPECTIVE = 668,
+    EXPLICITINTERPAMD = 669,
+    PERVERTEXNV = 670,
+    PERPRIMITIVENV = 671,
+    PERVIEWNV = 672,
+    PERTASKNV = 673,
+    PRECISE = 674
   };
 #endif
 
@@ -547,7 +548,7 @@ extern int yydebug;
 
 union YYSTYPE
 {
-#line 96 "MachineIndependent/glslang.y" /* yacc.c:355  */
+#line 97 "glslang.y" /* yacc.c:355  */
 
     struct {
         glslang::TSourceLoc loc;
@@ -583,7 +584,7 @@ union YYSTYPE
         glslang::TArraySizes* typeParameters;
     } interm;
 
-#line 587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
+#line 588 "glslang_tab.cpp" /* yacc.c:355  */
 };
 
 typedef union YYSTYPE YYSTYPE;
@@ -595,10 +596,10 @@ typedef union YYSTYPE YYSTYPE;
 
 int yyparse (glslang::TParseContext* pParseContext);
 
-#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */
 
 /* Copy the second part of user declarations.  */
-#line 132 "MachineIndependent/glslang.y" /* yacc.c:358  */
+#line 133 "glslang.y" /* yacc.c:358  */
 
 
 /* windows only pragma */
@@ -614,7 +615,7 @@ int yyparse (glslang::TParseContext* pParseContext);
 extern int yylex(YYSTYPE*, TParseContext&);
 
 
-#line 618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
+#line 619 "glslang_tab.cpp" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -854,23 +855,23 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  393
+#define YYFINAL  394
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   9528
+#define YYLAST   9550
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  419
+#define YYNTOKENS  420
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  111
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  590
+#define YYNRULES  591
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  735
+#define YYNSTATES  736
 
 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
    by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   673
+#define YYMAXUTOK   674
 
 #define YYTRANSLATE(YYX)                                                \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -946,73 +947,73 @@ static const yytype_uint16 yytranslate[] =
      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,   410,   411,   412,   413,   414,
-     415,   416,   417,   418
+     415,   416,   417,   418,   419
 };
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   355,   355,   361,   364,   369,   372,   375,   379,   383,
-     386,   390,   394,   398,   402,   406,   410,   416,   424,   427,
-     430,   433,   436,   441,   449,   456,   463,   469,   473,   480,
-     483,   489,   496,   506,   514,   519,   547,   556,   562,   566,
-     570,   590,   591,   592,   593,   599,   600,   605,   610,   619,
-     620,   625,   633,   634,   640,   649,   650,   655,   660,   665,
-     673,   674,   683,   695,   696,   705,   706,   715,   716,   725,
-     726,   734,   735,   743,   744,   752,   753,   753,   771,   772,
-     788,   792,   796,   800,   805,   809,   813,   817,   821,   825,
-     829,   836,   839,   850,   857,   862,   867,   874,   878,   882,
-     886,   891,   896,   905,   905,   916,   920,   927,   934,   937,
-     944,   952,   972,   995,  1010,  1035,  1046,  1056,  1066,  1076,
-    1085,  1088,  1092,  1096,  1101,  1109,  1116,  1121,  1126,  1131,
-    1140,  1150,  1177,  1186,  1193,  1201,  1208,  1215,  1223,  1233,
-    1240,  1251,  1257,  1260,  1267,  1271,  1275,  1284,  1294,  1297,
-    1308,  1311,  1314,  1318,  1322,  1327,  1331,  1338,  1342,  1347,
-    1353,  1359,  1366,  1371,  1379,  1385,  1397,  1411,  1417,  1422,
-    1430,  1438,  1446,  1454,  1462,  1470,  1478,  1486,  1493,  1500,
-    1504,  1509,  1514,  1519,  1524,  1529,  1534,  1538,  1542,  1546,
-    1550,  1556,  1567,  1574,  1577,  1586,  1591,  1601,  1606,  1614,
-    1618,  1628,  1631,  1637,  1643,  1650,  1660,  1664,  1668,  1672,
-    1677,  1681,  1686,  1691,  1696,  1701,  1706,  1711,  1716,  1721,
-    1726,  1732,  1738,  1744,  1749,  1754,  1759,  1764,  1769,  1774,
-    1779,  1784,  1789,  1794,  1799,  1805,  1812,  1817,  1822,  1827,
-    1832,  1837,  1842,  1847,  1852,  1857,  1862,  1867,  1875,  1883,
-    1891,  1897,  1903,  1909,  1915,  1921,  1927,  1933,  1939,  1945,
-    1951,  1957,  1963,  1969,  1975,  1981,  1987,  1993,  1999,  2005,
-    2011,  2017,  2023,  2029,  2035,  2041,  2047,  2053,  2059,  2065,
-    2071,  2077,  2083,  2089,  2097,  2105,  2113,  2121,  2129,  2137,
-    2145,  2153,  2161,  2169,  2177,  2185,  2191,  2197,  2203,  2209,
-    2215,  2221,  2227,  2233,  2239,  2245,  2251,  2257,  2263,  2269,
-    2275,  2281,  2287,  2293,  2299,  2305,  2311,  2317,  2323,  2329,
-    2335,  2341,  2347,  2353,  2359,  2365,  2371,  2377,  2383,  2389,
-    2395,  2401,  2405,  2409,  2414,  2420,  2425,  2430,  2435,  2440,
-    2445,  2450,  2456,  2461,  2466,  2471,  2476,  2481,  2487,  2493,
+       0,   357,   357,   363,   366,   371,   374,   377,   381,   385,
+     388,   392,   396,   400,   404,   408,   412,   418,   426,   429,
+     432,   435,   438,   443,   451,   458,   465,   471,   475,   482,
+     485,   491,   498,   508,   516,   521,   549,   558,   564,   568,
+     572,   592,   593,   594,   595,   601,   602,   607,   612,   621,
+     622,   627,   635,   636,   642,   651,   652,   657,   662,   667,
+     675,   676,   685,   697,   698,   707,   708,   717,   718,   727,
+     728,   736,   737,   745,   746,   754,   755,   755,   773,   774,
+     790,   794,   798,   802,   807,   811,   815,   819,   823,   827,
+     831,   838,   841,   852,   859,   864,   869,   876,   880,   884,
+     888,   893,   898,   907,   907,   918,   922,   929,   936,   939,
+     946,   954,   974,   997,  1012,  1037,  1048,  1058,  1068,  1078,
+    1087,  1090,  1094,  1098,  1103,  1111,  1118,  1123,  1128,  1133,
+    1142,  1152,  1179,  1188,  1195,  1203,  1210,  1217,  1225,  1235,
+    1242,  1253,  1259,  1262,  1269,  1273,  1277,  1286,  1296,  1299,
+    1310,  1313,  1316,  1320,  1324,  1329,  1333,  1340,  1344,  1349,
+    1355,  1361,  1368,  1373,  1381,  1387,  1399,  1413,  1419,  1424,
+    1432,  1440,  1448,  1456,  1464,  1472,  1480,  1488,  1495,  1502,
+    1506,  1511,  1516,  1521,  1526,  1531,  1536,  1540,  1544,  1548,
+    1552,  1558,  1569,  1576,  1579,  1588,  1593,  1603,  1608,  1616,
+    1620,  1630,  1633,  1639,  1645,  1652,  1662,  1666,  1670,  1674,
+    1679,  1683,  1688,  1693,  1698,  1703,  1708,  1713,  1718,  1723,
+    1728,  1734,  1740,  1746,  1751,  1756,  1761,  1766,  1771,  1776,
+    1781,  1786,  1791,  1796,  1801,  1807,  1814,  1819,  1824,  1829,
+    1834,  1839,  1844,  1849,  1854,  1859,  1864,  1869,  1877,  1885,
+    1893,  1899,  1905,  1911,  1917,  1923,  1929,  1935,  1941,  1947,
+    1953,  1959,  1965,  1971,  1977,  1983,  1989,  1995,  2001,  2007,
+    2013,  2019,  2025,  2031,  2037,  2043,  2049,  2055,  2061,  2067,
+    2073,  2079,  2085,  2091,  2099,  2107,  2115,  2123,  2131,  2139,
+    2147,  2155,  2163,  2171,  2179,  2187,  2193,  2199,  2205,  2211,
+    2217,  2223,  2229,  2235,  2241,  2247,  2253,  2259,  2265,  2271,
+    2277,  2283,  2289,  2295,  2301,  2307,  2313,  2319,  2325,  2331,
+    2337,  2343,  2349,  2355,  2361,  2367,  2373,  2379,  2385,  2391,
+    2397,  2403,  2407,  2411,  2415,  2420,  2426,  2431,  2436,  2441,
+    2446,  2451,  2456,  2462,  2467,  2472,  2477,  2482,  2487,  2493,
     2499,  2505,  2511,  2517,  2523,  2529,  2535,  2541,  2547,  2553,
-    2559,  2565,  2570,  2575,  2580,  2585,  2590,  2595,  2601,  2606,
-    2611,  2616,  2621,  2626,  2631,  2636,  2642,  2647,  2652,  2657,
-    2662,  2667,  2672,  2677,  2682,  2687,  2692,  2697,  2702,  2707,
-    2712,  2718,  2723,  2728,  2734,  2740,  2745,  2750,  2755,  2761,
-    2766,  2771,  2776,  2782,  2787,  2792,  2797,  2803,  2808,  2813,
-    2818,  2824,  2830,  2836,  2842,  2847,  2853,  2859,  2865,  2870,
-    2875,  2880,  2885,  2890,  2896,  2901,  2906,  2911,  2917,  2922,
-    2927,  2932,  2938,  2943,  2948,  2953,  2959,  2964,  2969,  2974,
-    2980,  2985,  2990,  2995,  3001,  3006,  3011,  3016,  3022,  3027,
-    3032,  3037,  3043,  3048,  3053,  3058,  3064,  3069,  3074,  3079,
-    3085,  3090,  3095,  3100,  3106,  3111,  3116,  3121,  3127,  3132,
-    3137,  3142,  3148,  3153,  3158,  3163,  3169,  3174,  3179,  3184,
-    3190,  3195,  3200,  3206,  3212,  3218,  3224,  3231,  3238,  3244,
-    3250,  3256,  3262,  3268,  3274,  3281,  3286,  3302,  3307,  3312,
-    3320,  3320,  3331,  3331,  3341,  3344,  3357,  3379,  3406,  3410,
-    3416,  3421,  3432,  3436,  3442,  3453,  3456,  3463,  3467,  3468,
-    3474,  3475,  3476,  3477,  3478,  3479,  3480,  3482,  3488,  3497,
-    3498,  3502,  3498,  3514,  3515,  3519,  3519,  3526,  3526,  3540,
-    3543,  3551,  3559,  3570,  3571,  3575,  3579,  3586,  3593,  3597,
-    3605,  3609,  3622,  3626,  3633,  3633,  3653,  3656,  3662,  3674,
-    3686,  3690,  3697,  3697,  3712,  3712,  3728,  3728,  3749,  3752,
-    3758,  3761,  3767,  3771,  3778,  3783,  3788,  3795,  3798,  3807,
-    3811,  3820,  3823,  3827,  3836,  3836,  3859,  3865,  3868,  3873,
-    3876
+    2559,  2565,  2571,  2576,  2581,  2586,  2591,  2596,  2601,  2607,
+    2612,  2617,  2622,  2627,  2632,  2637,  2642,  2648,  2653,  2658,
+    2663,  2668,  2673,  2678,  2683,  2688,  2693,  2698,  2703,  2708,
+    2713,  2718,  2724,  2729,  2734,  2740,  2746,  2751,  2756,  2761,
+    2767,  2772,  2777,  2782,  2788,  2793,  2798,  2803,  2809,  2814,
+    2819,  2824,  2830,  2836,  2842,  2848,  2853,  2859,  2865,  2871,
+    2876,  2881,  2886,  2891,  2896,  2902,  2907,  2912,  2917,  2923,
+    2928,  2933,  2938,  2944,  2949,  2954,  2959,  2965,  2970,  2975,
+    2980,  2986,  2991,  2996,  3001,  3007,  3012,  3017,  3022,  3028,
+    3033,  3038,  3043,  3049,  3054,  3059,  3064,  3070,  3075,  3080,
+    3085,  3091,  3096,  3101,  3106,  3112,  3117,  3122,  3127,  3133,
+    3138,  3143,  3148,  3154,  3159,  3164,  3169,  3175,  3180,  3185,
+    3190,  3196,  3201,  3206,  3212,  3218,  3224,  3230,  3237,  3244,
+    3250,  3256,  3262,  3268,  3274,  3280,  3287,  3292,  3308,  3313,
+    3318,  3326,  3326,  3337,  3337,  3347,  3350,  3363,  3385,  3412,
+    3416,  3422,  3427,  3438,  3442,  3448,  3459,  3462,  3469,  3473,
+    3474,  3480,  3481,  3482,  3483,  3484,  3485,  3486,  3488,  3494,
+    3503,  3504,  3508,  3504,  3520,  3521,  3525,  3525,  3532,  3532,
+    3546,  3549,  3557,  3565,  3576,  3577,  3581,  3585,  3592,  3599,
+    3603,  3611,  3615,  3628,  3632,  3639,  3639,  3659,  3662,  3668,
+    3680,  3692,  3696,  3703,  3703,  3718,  3718,  3734,  3734,  3755,
+    3758,  3764,  3767,  3773,  3777,  3784,  3789,  3794,  3801,  3804,
+    3813,  3817,  3826,  3829,  3833,  3842,  3842,  3865,  3871,  3874,
+    3879,  3882
 };
 #endif
 
@@ -1049,16 +1050,17 @@ static const char *const yytname[] =
   "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3",
   "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2",
   "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4",
-  "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "FCOOPMATNV", "ICOOPMATNV",
-  "UCOOPMATNV", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW",
-  "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY",
-  "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT",
-  "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT",
-  "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS",
-  "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY",
-  "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT",
-  "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D",
-  "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
+  "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "RAYQUERYEXT",
+  "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", "SAMPLERCUBEARRAY",
+  "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY",
+  "SAMPLER1D", "SAMPLER1DARRAY", "SAMPLER1DARRAYSHADOW", "ISAMPLER1D",
+  "SAMPLER1DSHADOW", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW",
+  "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER",
+  "USAMPLERBUFFER", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS",
+  "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY",
+  "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "ISAMPLER1DARRAY",
+  "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", "F16SAMPLER2D",
+  "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
   "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY",
   "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY",
   "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
@@ -1197,16 +1199,16 @@ static const yytype_uint16 yytoknum[] =
      635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
      645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
      655,   656,   657,   658,   659,   660,   661,   662,   663,   664,
-     665,   666,   667,   668,   669,   670,   671,   672,   673
+     665,   666,   667,   668,   669,   670,   671,   672,   673,   674
 };
 # endif
 
-#define YYPACT_NINF -456
+#define YYPACT_NINF -457
 
 #define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-456)))
+  (!!((Yystate) == (-457)))
 
-#define YYTABLE_NINF -536
+#define YYTABLE_NINF -537
 
 #define yytable_value_is_error(Yytable_value) \
   0
@@ -1215,80 +1217,80 @@ static const yytype_uint16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    4066,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,   132,  -456,  -456,
-    -456,  -456,  -456,    -1,  -456,  -456,  -456,  -456,  -456,  -456,
-    -300,  -297,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,    11,  -248,    17,    30,  6146,    20,
-    -456,    28,  -456,  -456,  -456,  -456,  4482,  -456,  -456,  -456,
-    -456,    50,  -456,  -456,   738,  -456,  -456,    16,  -456,    81,
-     -29,    69,  -456,  -312,  -456,   111,  -456,  6146,  -456,  -456,
-    -456,  6146,   103,   106,  -456,  -313,  -456,    72,  -456,  -456,
-    8546,   142,  -456,  -456,  -456,   136,  6146,  -456,   144,  -456,
-      53,  -456,  -456,    76,  6958,  -456,  -311,  1154,  -456,  -456,
-    -456,  -456,   142,  -308,  -456,  7355,  -307,  -456,   119,  -456,
-      65,  8546,  8546,  -456,  8546,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,    36,  -456,  -456,  -456,   171,    85,
-    8943,   173,  -456,  8546,  -456,  -456,  -322,   174,  -456,  6146,
-     139,  4898,  -456,  6146,  8546,  -456,   -29,  -456,   141,  -456,
-    -456,   145,    99,    35,    26,    71,   156,   159,   161,   196,
-     195,    23,   181,  7752,  -456,   183,   182,  -456,  -456,   186,
-     179,   180,  -456,   191,   192,   187,  8149,   193,  8546,   188,
-     189,   127,  -456,  -456,    96,  -456,  -248,   200,   201,  -456,
-    -456,  -456,  -456,  -456,  1570,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,   -24,   174,  7355,    13,  7355,  -456,
-    -456,  7355,  6146,  -456,   166,  -456,  -456,  -456,    86,  -456,
-    -456,  8546,   168,  -456,  -456,  8546,   205,  -456,  -456,  -456,
-    8546,  -456,   139,   142,   124,  -456,  -456,  -456,  5314,  -456,
-    -456,  -456,  -456,  8546,  8546,  8546,  8546,  8546,  8546,  8546,
-    8546,  8546,  8546,  8546,  8546,  8546,  8546,  8546,  8546,  8546,
-    8546,  8546,  -456,  -456,  -456,   206,   172,  -456,  1986,  -456,
-    -456,  -456,  1986,  -456,  8546,  -456,  -456,   130,  8546,   125,
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  -456,  8546,  8546,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  7355,  -456,    94,  -456,  5730,  -456,  -456,   207,
-     204,  -456,  -456,  -456,   131,   174,   139,  -456,  -456,  -456,
-    -456,  -456,   145,   145,    99,    99,    35,    35,    35,    35,
-      26,    26,    71,   156,   159,   161,   196,   195,  8546,  -456,
-     212,    60,  -456,  1986,  3650,   169,  3234,    87,  -456,    89,
-    -456,  -456,  -456,  -456,  -456,  6561,  -456,  -456,  -456,  -456,
-     143,  8546,   211,   172,   210,   204,   184,  6146,   217,   219,
-    -456,  -456,  3650,   218,  -456,  -456,  -456,  8546,   220,  -456,
-    -456,  -456,   214,  2402,  8546,  -456,   216,   223,   185,   224,
-    2818,  -456,   225,  -456,  -456,  7355,  -456,  -456,  -456,    97,
-    8546,  2402,   218,  -456,  -456,  1986,  -456,   222,   204,  -456,
-    -456,  1986,   229,  -456,  -456
+    4075,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,   132,  -457,
+    -457,  -457,  -457,  -457,    -1,  -457,  -457,  -457,  -457,  -457,
+    -457,  -301,  -298,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,    11,  -249,    17,    30,  6160,
+      20,  -457,    28,  -457,  -457,  -457,  -457,  4492,  -457,  -457,
+    -457,  -457,    50,  -457,  -457,   739,  -457,  -457,    16,  -457,
+      81,   -29,    69,  -457,  -313,  -457,   111,  -457,  6160,  -457,
+    -457,  -457,  6160,   103,   106,  -457,  -314,  -457,    72,  -457,
+    -457,  8566,   142,  -457,  -457,  -457,   136,  6160,  -457,   144,
+    -457,    53,  -457,  -457,    76,  6974,  -457,  -312,  1156,  -457,
+    -457,  -457,  -457,   142,  -309,  -457,  7372,  -308,  -457,   119,
+    -457,    65,  8566,  8566,  -457,  8566,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,    36,  -457,  -457,  -457,   171,
+      85,  8964,   173,  -457,  8566,  -457,  -457,  -323,   174,  -457,
+    6160,   139,  4909,  -457,  6160,  8566,  -457,   -29,  -457,   141,
+    -457,  -457,   145,    99,    35,    26,    71,   156,   159,   161,
+     196,   195,    23,   181,  7770,  -457,   183,   182,  -457,  -457,
+     186,   179,   180,  -457,   191,   192,   187,  8168,   193,  8566,
+     188,   189,   127,  -457,  -457,    96,  -457,  -249,   200,   201,
+    -457,  -457,  -457,  -457,  -457,  1573,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,   -24,   174,  7372,    13,  7372,
+    -457,  -457,  7372,  6160,  -457,   166,  -457,  -457,  -457,    86,
+    -457,  -457,  8566,   168,  -457,  -457,  8566,   205,  -457,  -457,
+    -457,  8566,  -457,   139,   142,   124,  -457,  -457,  -457,  5326,
+    -457,  -457,  -457,  -457,  8566,  8566,  8566,  8566,  8566,  8566,
+    8566,  8566,  8566,  8566,  8566,  8566,  8566,  8566,  8566,  8566,
+    8566,  8566,  8566,  -457,  -457,  -457,   206,   172,  -457,  1990,
+    -457,  -457,  -457,  1990,  -457,  8566,  -457,  -457,   130,  8566,
+     125,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  8566,  8566,  -457,  -457,  -457,  -457,
+    -457,  -457,  -457,  7372,  -457,    94,  -457,  5743,  -457,  -457,
+     207,   204,  -457,  -457,  -457,   131,   174,   139,  -457,  -457,
+    -457,  -457,  -457,   145,   145,    99,    99,    35,    35,    35,
+      35,    26,    26,    71,   156,   159,   161,   196,   195,  8566,
+    -457,   212,    60,  -457,  1990,  3658,   169,  3241,    87,  -457,
+      89,  -457,  -457,  -457,  -457,  -457,  6576,  -457,  -457,  -457,
+    -457,   143,  8566,   211,   172,   210,   204,   184,  6160,   217,
+     219,  -457,  -457,  3658,   218,  -457,  -457,  -457,  8566,   220,
+    -457,  -457,  -457,   214,  2407,  8566,  -457,   216,   223,   185,
+     224,  2824,  -457,   225,  -457,  -457,  7372,  -457,  -457,  -457,
+      97,  8566,  2407,   218,  -457,  -457,  1990,  -457,   222,   204,
+    -457,  -457,  1990,   229,  -457,  -457
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -1299,9 +1301,9 @@ static const yytype_uint16 yydefact[] =
        0,   157,   210,   208,   209,   207,   214,   215,   216,   217,
      218,   219,   220,   221,   222,   211,   212,   213,   223,   224,
      225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     335,   336,   337,   338,   339,   340,   341,   361,   362,   363,
-     364,   365,   366,   367,   376,   389,   390,   377,   378,   380,
-     379,   381,   382,   383,   384,   385,   386,   387,   388,   165,
+     336,   337,   338,   339,   340,   341,   342,   362,   363,   364,
+     365,   366,   367,   368,   377,   390,   391,   378,   379,   381,
+     380,   382,   383,   384,   385,   386,   387,   388,   389,   165,
      166,   236,   237,   235,   238,   245,   246,   243,   244,   241,
      242,   239,   240,   268,   269,   270,   280,   281,   282,   265,
      266,   267,   277,   278,   279,   262,   263,   264,   274,   275,
@@ -1311,99 +1313,99 @@ static const yytype_uint16 yydefact[] =
      321,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      298,   299,   300,   301,   302,   303,   304,   305,   306,   310,
      311,   312,   313,   314,   315,   316,   317,   318,   322,   323,
-     324,   325,   326,   327,   328,   329,   330,   333,   331,   332,
-     492,   493,   494,   345,   346,   369,   372,   334,   343,   344,
-     360,   342,   391,   392,   395,   396,   397,   399,   400,   401,
-     403,   404,   405,   407,   408,   482,   483,   368,   370,   371,
-     347,   348,   349,   393,   350,   354,   355,   358,   398,   402,
-     406,   351,   352,   356,   357,   394,   353,   359,   438,   440,
-     441,   442,   444,   445,   446,   448,   449,   450,   452,   453,
-     454,   456,   457,   458,   460,   461,   462,   464,   465,   466,
-     468,   469,   470,   472,   473,   474,   476,   477,   478,   480,
-     481,   439,   443,   447,   451,   455,   463,   467,   471,   459,
-     475,   479,   373,   374,   375,   409,   418,   420,   414,   419,
-     421,   422,   424,   425,   426,   428,   429,   430,   432,   433,
-     434,   436,   437,   410,   411,   412,   423,   413,   415,   416,
-     417,   427,   431,   435,   484,   485,   488,   489,   490,   491,
-     486,   487,   583,   132,   497,   498,   499,     0,   496,   161,
-     159,   160,   158,     0,   206,   162,   163,   164,   134,   133,
-       0,   190,   171,   173,   169,   175,   177,   172,   174,   170,
-     176,   178,   167,   168,   192,   179,   186,   187,   188,   189,
-     180,   181,   182,   183,   184,   185,   135,   136,   137,   138,
-     139,   140,   147,   582,     0,   584,     0,   109,   108,     0,
-     120,   125,   154,   153,   151,   155,     0,   148,   150,   156,
-     130,   202,   152,   495,     0,   579,   581,     0,   502,     0,
-       0,     0,    97,     0,    94,     0,   107,     0,   116,   110,
-     118,     0,   119,     0,    95,   126,   100,     0,   149,   131,
-       0,   195,   201,     1,   580,     0,     0,   500,   144,   146,
-       0,   142,   193,     0,     0,    98,     0,     0,   585,   111,
-     115,   117,   113,   121,   112,     0,   127,   103,     0,   101,
-       0,     0,     0,     9,     0,    43,    42,    44,    41,     5,
-       6,     7,     8,     2,    16,    14,    15,    17,    10,    11,
-      12,    13,     3,    18,    37,    20,    25,    26,     0,     0,
-      30,     0,   204,     0,    36,    34,     0,   196,    96,     0,
-       0,     0,   504,     0,     0,   141,     0,   191,     0,   197,
-      45,    49,    52,    55,    60,    63,    65,    67,    69,    71,
-      73,    75,     0,     0,    99,     0,   530,   539,   543,     0,
-       0,     0,   564,     0,     0,     0,     0,     0,     0,     0,
-       0,    45,    78,    91,     0,   517,     0,   156,   130,   520,
-     541,   519,   527,   518,     0,   521,   522,   545,   523,   552,
-     524,   525,   560,   526,     0,   114,     0,   122,     0,   512,
-     129,     0,     0,   105,     0,   102,    38,    39,     0,    22,
-      23,     0,     0,    28,    27,     0,   206,    31,    33,    40,
-       0,   203,     0,   510,     0,   508,   503,   505,     0,    93,
-     145,   143,   194,     0,     0,     0,     0,     0,     0,     0,
+     324,   325,   326,   327,   328,   329,   330,   334,   331,   332,
+     333,   493,   494,   495,   346,   347,   370,   373,   335,   344,
+     345,   361,   343,   392,   393,   396,   397,   398,   400,   401,
+     402,   404,   405,   406,   408,   409,   483,   484,   369,   371,
+     372,   348,   349,   350,   394,   351,   355,   356,   359,   399,
+     403,   407,   352,   353,   357,   358,   395,   354,   360,   439,
+     441,   442,   443,   445,   446,   447,   449,   450,   451,   453,
+     454,   455,   457,   458,   459,   461,   462,   463,   465,   466,
+     467,   469,   470,   471,   473,   474,   475,   477,   478,   479,
+     481,   482,   440,   444,   448,   452,   456,   464,   468,   472,
+     460,   476,   480,   374,   375,   376,   410,   419,   421,   415,
+     420,   422,   423,   425,   426,   427,   429,   430,   431,   433,
+     434,   435,   437,   438,   411,   412,   413,   424,   414,   416,
+     417,   418,   428,   432,   436,   485,   486,   489,   490,   491,
+     492,   487,   488,   584,   132,   498,   499,   500,     0,   497,
+     161,   159,   160,   158,     0,   206,   162,   163,   164,   134,
+     133,     0,   190,   171,   173,   169,   175,   177,   172,   174,
+     170,   176,   178,   167,   168,   192,   179,   186,   187,   188,
+     189,   180,   181,   182,   183,   184,   185,   135,   136,   137,
+     138,   139,   140,   147,   583,     0,   585,     0,   109,   108,
+       0,   120,   125,   154,   153,   151,   155,     0,   148,   150,
+     156,   130,   202,   152,   496,     0,   580,   582,     0,   503,
+       0,     0,     0,    97,     0,    94,     0,   107,     0,   116,
+     110,   118,     0,   119,     0,    95,   126,   100,     0,   149,
+     131,     0,   195,   201,     1,   581,     0,     0,   501,   144,
+     146,     0,   142,   193,     0,     0,    98,     0,     0,   586,
+     111,   115,   117,   113,   121,   112,     0,   127,   103,     0,
+     101,     0,     0,     0,     9,     0,    43,    42,    44,    41,
+       5,     6,     7,     8,     2,    16,    14,    15,    17,    10,
+      11,    12,    13,     3,    18,    37,    20,    25,    26,     0,
+       0,    30,     0,   204,     0,    36,    34,     0,   196,    96,
+       0,     0,     0,   505,     0,     0,   141,     0,   191,     0,
+     197,    45,    49,    52,    55,    60,    63,    65,    67,    69,
+      71,    73,    75,     0,     0,    99,     0,   531,   540,   544,
+       0,     0,     0,   565,     0,     0,     0,     0,     0,     0,
+       0,     0,    45,    78,    91,     0,   518,     0,   156,   130,
+     521,   542,   520,   528,   519,     0,   522,   523,   546,   524,
+     553,   525,   526,   561,   527,     0,   114,     0,   122,     0,
+     513,   129,     0,     0,   105,     0,   102,    38,    39,     0,
+      22,    23,     0,     0,    28,    27,     0,   206,    31,    33,
+      40,     0,   203,     0,   511,     0,   509,   504,   506,     0,
+      93,   145,   143,   194,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    76,   198,   199,     0,     0,   529,     0,   562,
-     575,   574,     0,   566,     0,   578,   576,     0,     0,     0,
-     559,   528,    81,    82,    84,    83,    86,    87,    88,    89,
-      90,    85,    80,     0,     0,   544,   540,   542,   546,   553,
-     561,   124,     0,   515,     0,   128,     0,   106,     4,     0,
-      24,    21,    32,   205,     0,   511,     0,   506,   501,    46,
-      47,    48,    51,    50,    53,    54,    58,    59,    56,    57,
-      61,    62,    64,    66,    68,    70,    72,    74,     0,   200,
-     589,     0,   587,   531,     0,     0,     0,     0,   577,     0,
-     558,    79,    92,   123,   513,     0,   104,    19,   507,   509,
-       0,     0,     0,     0,     0,   550,     0,     0,     0,     0,
-     569,   568,   571,   537,   554,   514,   516,     0,     0,   586,
-     588,   532,     0,     0,     0,   570,     0,     0,   549,     0,
-       0,   547,     0,    77,   590,     0,   534,   563,   533,     0,
-     572,     0,   537,   536,   538,   556,   551,     0,   573,   567,
-     548,   557,     0,   565,   555
+       0,     0,     0,    76,   198,   199,     0,     0,   530,     0,
+     563,   576,   575,     0,   567,     0,   579,   577,     0,     0,
+       0,   560,   529,    81,    82,    84,    83,    86,    87,    88,
+      89,    90,    85,    80,     0,     0,   545,   541,   543,   547,
+     554,   562,   124,     0,   516,     0,   128,     0,   106,     4,
+       0,    24,    21,    32,   205,     0,   512,     0,   507,   502,
+      46,    47,    48,    51,    50,    53,    54,    58,    59,    56,
+      57,    61,    62,    64,    66,    68,    70,    72,    74,     0,
+     200,   590,     0,   588,   532,     0,     0,     0,     0,   578,
+       0,   559,    79,    92,   123,   514,     0,   104,    19,   508,
+     510,     0,     0,     0,     0,     0,   551,     0,     0,     0,
+       0,   570,   569,   572,   538,   555,   515,   517,     0,     0,
+     587,   589,   533,     0,     0,     0,   571,     0,     0,   550,
+       0,     0,   548,     0,    77,   591,     0,   535,   564,   534,
+       0,   573,     0,   538,   537,   539,   557,   552,     0,   574,
+     568,   549,   558,     0,   566,   556
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,  -456,
-    -456,  -456,  8847,  -456,   -87,   -84,  -127,   -93,   -33,   -31,
-     -27,   -25,   -28,   -26,  -456,   -86,  -456,  -103,  -456,  -111,
-    -125,     2,  -456,  -456,  -456,     4,  -456,  -456,  -456,   176,
-     194,   178,  -456,  -456,  -337,  -456,  -456,  -456,  -456,    95,
-    -456,   -37,   -46,  -456,     9,  -456,     0,   -63,  -456,  -456,
-    -456,  -456,   263,  -456,  -456,  -456,  -455,  -140,    10,   -73,
-    -211,  -456,  -102,  -198,  -321,  -456,  -144,  -456,  -456,  -155,
-    -154,  -456,  -456,   198,  -274,   -97,  -456,    46,  -456,  -118,
-    -456,    51,  -456,  -456,  -456,  -456,    52,  -456,  -456,  -456,
-    -456,  -456,  -456,  -456,  -456,   213,  -456,  -456,  -456,  -456,
+    -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,  -457,
+    -457,  -457,  8868,  -457,   -87,   -84,  -127,   -93,   -33,   -31,
+     -27,   -25,   -28,   -26,  -457,   -86,  -457,  -103,  -457,  -111,
+    -125,     2,  -457,  -457,  -457,     4,  -457,  -457,  -457,   176,
+     194,   178,  -457,  -457,  -337,  -457,  -457,  -457,  -457,    95,
+    -457,   -37,   -46,  -457,     9,  -457,     0,   -63,  -457,  -457,
+    -457,  -457,   263,  -457,  -457,  -457,  -456,  -140,    10,   -73,
+    -211,  -457,  -102,  -198,  -321,  -457,  -144,  -457,  -457,  -155,
+    -154,  -457,  -457,   198,  -274,   -97,  -457,    46,  -457,  -118,
+    -457,    51,  -457,  -457,  -457,  -457,    52,  -457,  -457,  -457,
+    -457,  -457,  -457,  -457,  -457,   213,  -457,  -457,  -457,  -457,
     -105
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,   442,   443,   444,   629,   445,   446,   447,   448,   449,
-     450,   451,   501,   453,   471,   472,   473,   474,   475,   476,
-     477,   478,   479,   480,   481,   502,   658,   503,   613,   504,
-     560,   505,   344,   532,   420,   506,   346,   347,   348,   378,
-     379,   380,   349,   350,   351,   352,   353,   354,   400,   401,
-     355,   356,   357,   358,   454,   403,   455,   406,   391,   392,
-     456,   361,   362,   363,   463,   396,   461,   462,   554,   555,
-     530,   624,   509,   510,   511,   512,   513,   588,   684,   717,
-     708,   709,   710,   718,   514,   515,   516,   517,   711,   688,
-     518,   519,   712,   732,   520,   521,   522,   664,   592,   666,
-     692,   706,   707,   523,   364,   365,   366,   375,   524,   661,
-     662
+      -1,   443,   444,   445,   630,   446,   447,   448,   449,   450,
+     451,   452,   502,   454,   472,   473,   474,   475,   476,   477,
+     478,   479,   480,   481,   482,   503,   659,   504,   614,   505,
+     561,   506,   345,   533,   421,   507,   347,   348,   349,   379,
+     380,   381,   350,   351,   352,   353,   354,   355,   401,   402,
+     356,   357,   358,   359,   455,   404,   456,   407,   392,   393,
+     457,   362,   363,   364,   464,   397,   462,   463,   555,   556,
+     531,   625,   510,   511,   512,   513,   514,   589,   685,   718,
+     709,   710,   711,   719,   515,   516,   517,   518,   712,   689,
+     519,   520,   713,   733,   521,   522,   523,   665,   593,   667,
+     693,   707,   708,   524,   365,   366,   367,   376,   525,   662,
+     663
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -1411,14 +1413,14 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     360,   550,   343,   414,   345,   404,   404,   483,   558,   359,
-     404,   483,   415,   551,   405,   484,   370,   526,   531,   371,
+     361,   551,   344,   415,   346,   405,   405,   484,   559,   360,
+     405,   484,   416,   552,   406,   485,   371,   527,   532,   372,
        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,   626,   374,    61,
+      52,    53,    54,    55,    56,    57,    58,   627,   375,    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,
@@ -1442,174 +1444,91 @@ static const yytype_int16 yytable[] =
      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,
-     388,   381,   529,   538,   663,   621,   617,   623,   482,   368,
-     625,   557,   416,   398,   570,   571,   581,   686,   457,   568,
-     569,   483,   539,   540,   376,   388,   489,   372,   622,   492,
-     381,   493,   494,   383,   399,   497,   384,   547,   382,   525,
-     527,   369,   -35,   377,   541,   686,   389,   359,   542,   459,
-     572,   573,   582,   373,   360,   359,   343,   395,   345,   298,
-     465,   574,   575,   359,   303,   304,   466,   382,   559,   682,
-     385,   382,   716,   683,   390,   597,   359,   599,   534,   724,
-     359,   535,   417,   467,   665,   418,   460,   585,   419,   468,
-     716,   397,   544,   628,   693,   359,   694,   508,   545,   614,
-     614,   673,   614,   388,   727,   674,   507,   675,   557,   614,
-     614,   402,   615,   529,   459,   529,   459,   566,   529,   567,
-     630,   407,   602,   603,   604,   605,   606,   607,   608,   609,
-     610,   611,   632,   646,   647,   648,   649,   636,   614,   670,
-     637,   731,   612,   614,   636,   412,   668,   678,   413,   552,
-     404,   460,   458,   460,   696,   617,   614,   697,   359,   464,
-     359,   533,   359,   294,   295,   296,   563,   564,   565,   642,
-     643,   650,   651,   667,   644,   645,   557,   669,   543,   548,
-     635,   553,   483,   562,   576,   459,   577,   578,   579,   580,
-     583,   586,   589,   587,   726,   590,   591,   593,   594,   598,
-     671,   672,   600,   595,   508,   601,   -36,   -34,   627,   529,
-     631,   459,   -29,   507,   660,   659,   677,   614,   681,   689,
-     699,   701,   460,   617,   703,   704,   702,   714,  -535,   715,
-     721,   359,   720,   652,   486,   725,   653,   680,   733,   722,
-     734,   654,   656,   685,   655,   657,   698,   410,   460,   411,
-     367,   561,   634,   679,   690,   723,   729,   359,   730,   691,
-     618,   409,   529,   408,   705,   619,   620,   394,   700,     0,
-       0,   685,     0,     0,     0,     0,     0,     0,   508,   459,
-       0,     0,   508,   719,   713,   559,     0,   507,     0,     0,
-       0,   507,     0,     0,     0,     0,     0,     0,     0,   728,
-       0,     0,   529,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   460,   687,     0,     0,
-       0,     0,     0,     0,     0,   359,     0,     0,     0,     0,
-       0,   388,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   687,     0,     0,     0,     0,
+     292,   389,   382,   530,   539,   664,   622,   618,   624,   483,
+     369,   626,   558,   417,   399,   571,   572,   582,   687,   458,
+     569,   570,   484,   540,   541,   377,   389,   490,   373,   623,
+     493,   382,   494,   495,   384,   400,   498,   385,   548,   383,
+     526,   528,   370,   -35,   378,   542,   687,   390,   360,   543,
+     460,   573,   574,   583,   374,   361,   360,   344,   396,   346,
+     299,   466,   575,   576,   360,   304,   305,   467,   383,   560,
+     683,   386,   383,   717,   684,   391,   598,   360,   600,   535,
+     725,   360,   536,   418,   468,   666,   419,   461,   586,   420,
+     469,   717,   398,   545,   629,   694,   360,   695,   509,   546,
+     615,   615,   674,   615,   389,   728,   675,   508,   676,   558,
+     615,   615,   403,   616,   530,   460,   530,   460,   567,   530,
+     568,   631,   408,   603,   604,   605,   606,   607,   608,   609,
+     610,   611,   612,   633,   647,   648,   649,   650,   637,   615,
+     671,   638,   732,   613,   615,   637,   413,   669,   679,   414,
+     553,   405,   461,   459,   461,   697,   618,   615,   698,   360,
+     465,   360,   534,   360,   295,   296,   297,   564,   565,   566,
+     643,   644,   651,   652,   668,   645,   646,   558,   670,   544,
+     549,   636,   554,   484,   563,   577,   460,   578,   579,   580,
+     581,   584,   587,   590,   588,   727,   591,   592,   594,   595,
+     599,   672,   673,   601,   596,   509,   602,   -36,   -34,   628,
+     530,   632,   460,   -29,   508,   661,   660,   678,   615,   682,
+     690,   700,   702,   461,   618,   704,   705,   703,   715,  -536,
+     716,   722,   360,   721,   653,   487,   726,   654,   681,   734,
+     723,   735,   655,   657,   686,   656,   658,   699,   411,   461,
+     412,   368,   562,   635,   680,   691,   724,   730,   360,   731,
+     692,   619,   410,   530,   409,   706,   620,   621,   395,   701,
+       0,     0,   686,     0,     0,     0,     0,     0,     0,   509,
+     460,     0,     0,   509,   720,   714,   560,     0,   508,     0,
+       0,     0,   508,     0,     0,     0,     0,     0,     0,     0,
+     729,     0,     0,   530,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   461,   688,     0,
+       0,     0,     0,     0,     0,     0,   360,     0,     0,     0,
+       0,     0,   389,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   688,     0,     0,     0,
+       0,     0,     0,     0,   509,   509,     0,   509,     0,     0,
        0,     0,     0,   508,   508,     0,   508,     0,     0,     0,
-       0,     0,   507,   507,     0,   507,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   389,     0,     0,
-       0,     0,   508,     0,     0,     0,   359,     0,     0,     0,
-       0,   507,     0,   508,     0,     0,     0,     0,     0,     0,
-     508,     0,   507,     0,     0,     0,     0,     0,     0,   507,
-       0,   508,     0,     0,     0,   508,     0,     0,     0,     0,
-     507,   508,     0,     0,   507,     0,     0,     0,   393,     0,
-     507,     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,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   390,     0,
+       0,     0,     0,   509,     0,     0,     0,   360,     0,     0,
+       0,     0,   508,     0,   509,     0,     0,     0,     0,     0,
+       0,   509,     0,   508,     0,     0,     0,     0,     0,     0,
+     508,     0,   509,     0,     0,     0,   509,     0,     0,     0,
+       0,   508,   509,     0,     0,   508,     0,     0,     0,   394,
+       0,   508,     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,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   292,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   293,   294,
-     295,   296,   297,     0,     0,     0,     0,     0,     0,     0,
-       0,   298,   299,   300,   301,   302,   303,   304,     0,     0,
+       0,     0,     0,     0,     0,     0,   293,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     305,   306,   307,   308,   309,   310,     0,     0,     0,     0,
-       0,     0,     0,     0,   311,     0,   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,     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,     0,     0,
-     421,   422,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   423,
-     424,     0,   485,     0,   486,   487,     0,     0,     0,     0,
-     488,   425,   426,   427,   428,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   293,   294,   295,   296,   297,     0,
-       0,     0,   429,   430,   431,   432,   433,   298,   299,   300,
-     301,   302,   303,   304,   489,   490,   491,   492,     0,   493,
-     494,   495,   496,   497,   498,   499,   305,   306,   307,   308,
-     309,   310,   434,   435,   436,   437,   438,   439,   440,   441,
-     311,   500,   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,     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,     0,     0,   421,   422,     0,     0,
+     294,   295,   296,   297,   298,     0,     0,     0,     0,     0,
+       0,     0,     0,   299,   300,   301,   302,   303,   304,   305,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   423,   424,     0,   485,     0,
-     486,   616,     0,     0,     0,     0,   488,   425,   426,   427,
-     428,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     293,   294,   295,   296,   297,     0,     0,     0,   429,   430,
-     431,   432,   433,   298,   299,   300,   301,   302,   303,   304,
-     489,   490,   491,   492,     0,   493,   494,   495,   496,   497,
-     498,   499,   305,   306,   307,   308,   309,   310,   434,   435,
-     436,   437,   438,   439,   440,   441,   311,   500,   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,     1,
+       0,     0,   306,   307,   308,   309,   310,   311,     0,     0,
+       0,     0,     0,     0,     0,     0,   312,     0,   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,     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,
@@ -1639,144 +1558,61 @@ static const yytype_int16 yytable[] =
      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,
-       0,     0,   421,   422,     0,     0,     0,     0,     0,     0,
+     292,     0,     0,   422,   423,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   423,   424,     0,   485,     0,   486,     0,     0,     0,
-       0,     0,   488,   425,   426,   427,   428,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   293,   294,   295,   296,
-     297,     0,     0,     0,   429,   430,   431,   432,   433,   298,
-     299,   300,   301,   302,   303,   304,   489,   490,   491,   492,
-       0,   493,   494,   495,   496,   497,   498,   499,   305,   306,
-     307,   308,   309,   310,   434,   435,   436,   437,   438,   439,
-     440,   441,   311,   500,   312,   313,   314,   315,   316,   317,
+       0,     0,   424,   425,     0,   486,     0,   487,   488,     0,
+       0,     0,     0,   489,   426,   427,   428,   429,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   294,   295,   296,
+     297,   298,     0,     0,     0,   430,   431,   432,   433,   434,
+     299,   300,   301,   302,   303,   304,   305,   490,   491,   492,
+     493,     0,   494,   495,   496,   497,   498,   499,   500,   306,
+     307,   308,   309,   310,   311,   435,   436,   437,   438,   439,
+     440,   441,   442,   312,   501,   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,     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,     0,     0,   421,   422,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   423,   424,     0,
-     485,     0,   407,     0,     0,     0,     0,     0,   488,   425,
-     426,   427,   428,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   293,   294,   295,   296,   297,     0,     0,     0,
-     429,   430,   431,   432,   433,   298,   299,   300,   301,   302,
-     303,   304,   489,   490,   491,   492,     0,   493,   494,   495,
-     496,   497,   498,   499,   305,   306,   307,   308,   309,   310,
-     434,   435,   436,   437,   438,   439,   440,   441,   311,   500,
-     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,     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,     0,     0,   421,   422,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   423,   424,     0,   485,     0,     0,     0,
-       0,     0,     0,     0,   488,   425,   426,   427,   428,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   293,   294,
-     295,   296,   297,     0,     0,     0,   429,   430,   431,   432,
-     433,   298,   299,   300,   301,   302,   303,   304,   489,   490,
-     491,   492,     0,   493,   494,   495,   496,   497,   498,   499,
-     305,   306,   307,   308,   309,   310,   434,   435,   436,   437,
-     438,   439,   440,   441,   311,   500,   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,     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,     0,     0,
-     421,   422,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   423,
-     424,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     488,   425,   426,   427,   428,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   293,   294,   295,   296,   297,     0,
-       0,     0,   429,   430,   431,   432,   433,   298,   299,   300,
-     301,   302,   303,   304,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   305,   306,   307,   308,
-     309,   310,   434,   435,   436,   437,   438,   439,   440,   441,
-     311,     0,   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,     1,     2,     3,     4,     5,     6,     7,
+     338,   339,   340,   341,   342,   343,     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,     0,     0,
+     422,   423,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   424,
+     425,     0,   486,     0,   487,   617,     0,     0,     0,     0,
+     489,   426,   427,   428,   429,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   294,   295,   296,   297,   298,     0,
+       0,     0,   430,   431,   432,   433,   434,   299,   300,   301,
+     302,   303,   304,   305,   490,   491,   492,   493,     0,   494,
+     495,   496,   497,   498,   499,   500,   306,   307,   308,   309,
+     310,   311,   435,   436,   437,   438,   439,   440,   441,   442,
+     312,   501,   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,     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,
@@ -1805,144 +1641,61 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   421,   422,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   423,   424,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   425,   426,   427,
-     428,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     293,   294,   295,   296,     0,     0,     0,     0,   429,   430,
-     431,   432,   433,   298,   299,   300,   301,   302,   303,   304,
+     288,   289,   290,   291,   292,     0,     0,   422,   423,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   305,   306,   307,   308,   309,   310,   434,   435,
-     436,   437,   438,   439,   440,   441,   311,     0,   312,   313,
+       0,     0,     0,     0,     0,     0,   424,   425,     0,   486,
+       0,   487,     0,     0,     0,     0,     0,   489,   426,   427,
+     428,   429,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   294,   295,   296,   297,   298,     0,     0,     0,   430,
+     431,   432,   433,   434,   299,   300,   301,   302,   303,   304,
+     305,   490,   491,   492,   493,     0,   494,   495,   496,   497,
+     498,   499,   500,   306,   307,   308,   309,   310,   311,   435,
+     436,   437,   438,   439,   440,   441,   442,   312,   501,   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,     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,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   292,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   293,   294,   295,   296,
-     297,     0,     0,     0,     0,     0,     0,     0,     0,   298,
-     299,   300,   301,   302,   303,   304,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   305,   306,
-     307,   308,   309,   310,     0,     0,     0,     0,     0,     0,
-       0,     0,   311,     0,   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,     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,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   386,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   293,   294,   295,   296,     0,     0,     0,     0,
-       0,     0,     0,     0,   387,   298,   299,   300,   301,   302,
-     303,   304,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   305,   306,   307,   308,   309,   310,
-       0,     0,     0,     0,     0,     0,     0,     0,   311,     0,
-     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,     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,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   556,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   293,   294,
-     295,   296,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   298,   299,   300,   301,   302,   303,   304,     0,     0,
+     334,   335,   336,   337,   338,   339,   340,   341,   342,   343,
+       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,     0,     0,   422,   423,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     305,   306,   307,   308,   309,   310,     0,     0,     0,     0,
-       0,     0,     0,     0,   311,     0,   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,     1,     2,     3,
+       0,     0,     0,   424,   425,     0,   486,     0,   408,     0,
+       0,     0,     0,     0,   489,   426,   427,   428,   429,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   294,   295,
+     296,   297,   298,     0,     0,     0,   430,   431,   432,   433,
+     434,   299,   300,   301,   302,   303,   304,   305,   490,   491,
+     492,   493,     0,   494,   495,   496,   497,   498,   499,   500,
+     306,   307,   308,   309,   310,   311,   435,   436,   437,   438,
+     439,   440,   441,   442,   312,   501,   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,     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,
@@ -1956,124 +1709,41 @@ static const yytype_int16 yytable[] =
      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,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   638,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   293,   294,   295,   296,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   298,   299,   300,
-     301,   302,   303,   304,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   305,   306,   307,   308,
-     309,   310,     0,     0,     0,     0,     0,     0,     0,     0,
-     311,     0,   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,     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,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   676,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     293,   294,   295,   296,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   298,   299,   300,   301,   302,   303,   304,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   305,   306,   307,   308,   309,   310,     0,     0,
-       0,     0,     0,     0,     0,     0,   311,     0,   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,     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,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     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,     0,
+       0,   422,   423,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   293,   294,   295,   296,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   298,
-     299,   300,   301,   302,   303,   304,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   305,   306,
-     307,   308,   309,   310,     0,     0,     0,     0,     0,     0,
-       0,     0,   311,     0,   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,     2,     3,     4,     5,     6,
+     424,   425,     0,   486,     0,     0,     0,     0,     0,     0,
+       0,   489,   426,   427,   428,   429,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   294,   295,   296,   297,   298,
+       0,     0,     0,   430,   431,   432,   433,   434,   299,   300,
+     301,   302,   303,   304,   305,   490,   491,   492,   493,     0,
+     494,   495,   496,   497,   498,   499,   500,   306,   307,   308,
+     309,   310,   311,   435,   436,   437,   438,   439,   440,   441,
+     442,   312,   501,   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,     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,     0,     0,    61,    62,    63,    64,    65,    66,
+      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,
@@ -2096,24 +1766,26 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   421,   422,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   423,   424,     0,     0,
-       0,   528,   695,     0,     0,     0,     0,     0,   425,   426,
-     427,   428,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   429,
-     430,   431,   432,   433,   298,     0,     0,     0,     0,   303,
-     304,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   434,
-     435,   436,   437,   438,   439,   440,   441,     0,     0,     0,
+     287,   288,   289,   290,   291,   292,     0,     0,   422,   423,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   324,     2,     3,     4,     5,     6,     7,     8,     9,
+       0,     0,     0,     0,     0,     0,     0,   424,   425,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   489,   426,
+     427,   428,   429,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   294,   295,   296,   297,   298,     0,     0,     0,
+     430,   431,   432,   433,   434,   299,   300,   301,   302,   303,
+     304,   305,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   306,   307,   308,   309,   310,   311,
+     435,   436,   437,   438,   439,   440,   441,   442,   312,     0,
+     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,     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,     0,
-       0,    61,    62,    63,    64,    65,    66,    67,    68,    69,
+      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,
@@ -2136,23 +1808,25 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   421,   422,     0,     0,     0,     0,
+     290,   291,   292,     0,     0,   422,   423,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   423,   424,     0,     0,   469,     0,     0,
-       0,     0,     0,     0,     0,   425,   426,   427,   428,     0,
+       0,     0,     0,     0,   424,   425,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   426,   427,   428,   429,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   294,
+     295,   296,   297,     0,     0,     0,     0,   430,   431,   432,
+     433,   434,   299,   300,   301,   302,   303,   304,   305,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   429,   430,   431,   432,
-     433,   298,     0,     0,     0,     0,   303,   304,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   434,   435,   436,   437,
-     438,   439,   440,   441,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   324,     2,
+       0,   306,   307,   308,   309,   310,   311,   435,   436,   437,
+     438,   439,   440,   441,   442,   312,     0,   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,     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,     0,     0,    61,    62,
+      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,
@@ -2175,24 +1849,26 @@ static const yytype_int16 yytable[] =
      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,     0,
-       0,   421,   422,     0,     0,     0,     0,     0,     0,     0,
+     283,   284,   285,   286,   287,   288,   289,   290,   291,   292,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     423,   424,     0,     0,     0,   528,     0,     0,     0,     0,
-       0,     0,   425,   426,   427,   428,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   429,   430,   431,   432,   433,   298,     0,
-       0,     0,     0,   303,   304,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   434,   435,   436,   437,   438,   439,   440,
-     441,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   324,     2,     3,     4,     5,
+       0,     0,   293,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   294,   295,   296,   297,
+     298,     0,     0,     0,     0,     0,     0,     0,     0,   299,
+     300,   301,   302,   303,   304,   305,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   306,   307,
+     308,   309,   310,   311,     0,     0,     0,     0,     0,     0,
+       0,     0,   312,     0,   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,     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,     0,     0,    61,    62,    63,    64,    65,
+      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,
@@ -2215,24 +1891,26 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   421,   422,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   423,   424,     0,
-       0,   584,     0,     0,     0,     0,     0,     0,     0,   425,
-     426,   427,   428,     0,     0,     0,     0,     0,     0,     0,
+     286,   287,   288,   289,   290,   291,   292,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     429,   430,   431,   432,   433,   298,     0,     0,     0,     0,
-     303,   304,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     434,   435,   436,   437,   438,   439,   440,   441,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   387,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   324,     2,     3,     4,     5,     6,     7,     8,
+       0,     0,     0,   294,   295,   296,   297,     0,     0,     0,
+       0,     0,     0,     0,     0,   388,   299,   300,   301,   302,
+     303,   304,   305,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   306,   307,   308,   309,   310,
+     311,     0,     0,     0,     0,     0,     0,     0,     0,   312,
+       0,   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,     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,
-       0,     0,    61,    62,    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,
@@ -2255,194 +1933,20 @@ static const yytype_int16 yytable[] =
      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,     0,     0,   421,   422,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   423,   424,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   596,   425,   426,   427,   428,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   429,   430,   431,
-     432,   433,   298,     0,     0,     0,     0,   303,   304,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   434,   435,   436,
-     437,   438,   439,   440,   441,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   324,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    57,    58,     0,     0,    61,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
-     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
-     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
-     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
-     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
-     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
-     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
-     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
-     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
-     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
-       0,     0,   421,   422,     0,     0,     0,     0,     0,     0,
+     289,   290,   291,   292,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   423,   424,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   425,   426,   427,   428,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   429,   430,   431,   432,   433,   298,
-       0,     0,     0,     0,   303,   304,     0,     0,     0,     0,
+       0,   557,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   434,   435,   436,   437,   438,   439,
-     440,   441,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   324,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,     0,     0,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
-     155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
-     165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
-     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
-     215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
-     225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
-     235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
-     245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   452,     0,   421,
-     422,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   470,     0,     0,     0,     0,     0,     0,   423,   424,
-       0,     0,     0,     0,     0,     0,     0,     0,   536,   537,
-     425,   426,   427,   428,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   429,   430,   431,   432,   433,   298,     0,     0,     0,
-     549,   303,   546,     0,     0,     0,     0,     0,     0,     0,
-       0,   470,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   434,   435,   436,   437,   438,   439,   440,   441,     0,
-     470,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   324,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   633,     0,     0,
+     294,   295,   296,   297,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   299,   300,   301,   302,   303,   304,   305,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     639,   640,   641,   470,   470,   470,   470,   470,   470,   470,
-     470,   470,   470,   470,   470,   470,   470,   470,   470,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   470
-};
-
-static const yytype_int16 yycheck[] =
-{
-       0,   323,     0,   316,     0,   318,   318,   318,   463,     0,
-     318,   318,   325,   335,   326,   326,   316,   325,   325,   316,
-       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,   532,   326,    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,
-     356,   348,   415,   424,   588,   526,   514,   528,   404,   320,
-     531,   461,   385,   352,   298,   299,   303,   664,   391,   294,
-     295,   318,   296,   297,   317,   381,   360,   326,   325,   363,
-     377,   365,   366,   323,   373,   369,   326,   450,   348,   412,
-     413,   352,   316,   323,   318,   692,   356,   348,   322,   396,
-     334,   335,   339,   352,   364,   356,   364,   367,   364,   353,
-     317,   300,   301,   364,   358,   359,   323,   377,   464,   319,
-     352,   381,   703,   323,   334,   496,   377,   498,   323,   710,
-     381,   326,   320,   317,   592,   323,   396,   483,   326,   323,
-     721,   320,   317,   317,   317,   396,   317,   407,   323,   323,
-     323,   622,   323,   459,   317,   321,   407,   323,   558,   323,
-     323,   352,   326,   526,   461,   528,   463,   328,   531,   330,
-     541,   320,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   545,   570,   571,   572,   573,   323,   323,   324,
-     326,   725,   325,   323,   323,   352,   326,   326,   352,   459,
-     318,   461,   326,   463,   675,   663,   323,   324,   459,   325,
-     461,   352,   463,   341,   342,   343,   331,   332,   333,   566,
-     567,   574,   575,   594,   568,   569,   626,   598,   317,   316,
-     553,   352,   318,   352,   338,   532,   337,   336,   302,   304,
-     319,   318,   316,   321,   715,   326,   326,   316,   316,   316,
-     613,   614,   324,   326,   514,   326,   316,   316,   352,   622,
-     352,   558,   317,   514,   352,   319,   319,   323,   316,   360,
-     319,   321,   532,   731,   317,   316,   352,   317,   320,   325,
-     317,   532,   326,   576,   320,   320,   577,   658,   326,   364,
-     321,   578,   580,   664,   579,   581,   681,   381,   558,   381,
-     297,   466,   552,   636,   666,   709,   721,   558,   722,   666,
-     524,   377,   675,   375,   692,   524,   524,   364,   683,    -1,
-      -1,   692,    -1,    -1,    -1,    -1,    -1,    -1,   588,   626,
-      -1,    -1,   592,   704,   697,   681,    -1,   588,    -1,    -1,
-      -1,   592,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   720,
-      -1,    -1,   715,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   626,   664,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   626,    -1,    -1,    -1,    -1,
-      -1,   687,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   692,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   663,   664,    -1,   666,    -1,    -1,    -1,
-      -1,    -1,   663,   664,    -1,   666,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   687,    -1,    -1,
-      -1,    -1,   692,    -1,    -1,    -1,   687,    -1,    -1,    -1,
-      -1,   692,    -1,   703,    -1,    -1,    -1,    -1,    -1,    -1,
-     710,    -1,   703,    -1,    -1,    -1,    -1,    -1,    -1,   710,
-      -1,   721,    -1,    -1,    -1,   725,    -1,    -1,    -1,    -1,
-     721,   731,    -1,    -1,   725,    -1,    -1,    -1,     0,    -1,
-     731,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+       0,     0,   306,   307,   308,   309,   310,   311,     0,     0,
+       0,     0,     0,     0,     0,     0,   312,     0,   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,     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,
@@ -2462,153 +1966,70 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   326,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   340,   341,
-     342,   343,   344,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   353,   354,   355,   356,   357,   358,   359,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     372,   373,   374,   375,   376,   377,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   386,    -1,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,     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,    -1,    -1,
-     296,   297,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   315,
-     316,    -1,   318,    -1,   320,   321,    -1,    -1,    -1,    -1,
-     326,   327,   328,   329,   330,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   340,   341,   342,   343,   344,    -1,
-      -1,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,   360,   361,   362,   363,    -1,   365,
-     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,     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,    -1,    -1,   296,   297,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   315,   316,    -1,   318,    -1,
-     320,   321,    -1,    -1,    -1,    -1,   326,   327,   328,   329,
-     330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     340,   341,   342,   343,   344,    -1,    -1,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,    -1,   365,   366,   367,   368,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,     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,
-      -1,    -1,   296,   297,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   315,   316,    -1,   318,    -1,   320,    -1,    -1,    -1,
-      -1,    -1,   326,   327,   328,   329,   330,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   340,   341,   342,   343,
-     344,    -1,    -1,    -1,   348,   349,   350,   351,   352,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-      -1,   365,   366,   367,   368,   369,   370,   371,   372,   373,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
-     384,   385,   386,   387,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,     3,     4,     5,     6,     7,
+     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,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   639,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   294,   295,   296,
+     297,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     299,   300,   301,   302,   303,   304,   305,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   306,
+     307,   308,   309,   310,   311,     0,     0,     0,     0,     0,
+       0,     0,     0,   312,     0,   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,     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,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   677,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   294,   295,   296,   297,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   299,   300,   301,
+     302,   303,   304,   305,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   306,   307,   308,   309,
+     310,   311,     0,     0,     0,     0,     0,     0,     0,     0,
+     312,     0,   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,     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,
@@ -2637,25 +2058,25 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   315,   316,    -1,
-     318,    -1,   320,    -1,    -1,    -1,    -1,    -1,   326,   327,
-     328,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   340,   341,   342,   343,   344,    -1,    -1,    -1,
-     348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
-     358,   359,   360,   361,   362,   363,    -1,   365,   366,   367,
-     368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+     288,   289,   290,   291,   292,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   294,   295,   296,   297,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   299,   300,   301,   302,   303,   304,
+     305,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   306,   307,   308,   309,   310,   311,     0,
+       0,     0,     0,     0,     0,     0,     0,   312,     0,   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,
+       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,
+      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,
@@ -2679,25 +2100,63 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   315,   316,    -1,   318,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   326,   327,   328,   329,   330,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   340,   341,
-     342,   343,   344,    -1,    -1,    -1,   348,   349,   350,   351,
-     352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,    -1,   365,   366,   367,   368,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,     3,     4,     5,
+     292,     0,     0,   422,   423,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   424,   425,     0,     0,     0,   529,   696,     0,
+       0,     0,     0,     0,   426,   427,   428,   429,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   430,   431,   432,   433,   434,
+     299,     0,     0,     0,     0,   304,   305,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   435,   436,   437,   438,   439,
+     440,   441,   442,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   325,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,     0,     0,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,     0,
+       0,   422,   423,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     424,   425,     0,     0,   470,     0,     0,     0,     0,     0,
+       0,     0,   426,   427,   428,   429,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   430,   431,   432,   433,   434,   299,     0,
+       0,     0,     0,   304,   305,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   435,   436,   437,   438,   439,   440,   441,
+     442,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   325,     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,
+      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,
@@ -2720,26 +2179,64 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,
-     296,   297,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   315,
-     316,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     326,   327,   328,   329,   330,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   340,   341,   342,   343,   344,    -1,
-      -1,    -1,   348,   349,   350,   351,   352,   353,   354,   355,
-     356,   357,   358,   359,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   372,   373,   374,   375,
-     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
-     386,    -1,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,     3,     4,     5,     6,     7,     8,     9,
+     286,   287,   288,   289,   290,   291,   292,     0,     0,   422,
+     423,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   424,   425,
+       0,     0,     0,   529,     0,     0,     0,     0,     0,     0,
+     426,   427,   428,   429,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   430,   431,   432,   433,   434,   299,     0,     0,     0,
+       0,   304,   305,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   435,   436,   437,   438,   439,   440,   441,   442,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   325,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,     0,     0,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
+     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
+     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
+     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
+     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
+     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
+     288,   289,   290,   291,   292,     0,     0,   422,   423,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   424,   425,     0,     0,
+     585,     0,     0,     0,     0,     0,     0,     0,   426,   427,
+     428,   429,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   430,
+     431,   432,   433,   434,   299,     0,     0,     0,     0,   304,
+     305,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   435,
+     436,   437,   438,   439,   440,   441,   442,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   325,     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,
+      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,
@@ -2762,19 +2259,236 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,    -1,    -1,
+     290,   291,   292,     0,     0,   422,   423,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   424,   425,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   597,   426,   427,   428,   429,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   430,   431,   432,
+     433,   434,   299,     0,     0,     0,     0,   304,   305,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   435,   436,   437,
+     438,   439,   440,   441,   442,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   325,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,     0,     0,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,     0,     0,   422,   423,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   424,   425,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   426,   427,   428,   429,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   430,   431,   432,   433,   434,
+     299,     0,     0,     0,     0,   304,   305,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   435,   436,   437,   438,   439,
+     440,   441,   442,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   325,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,     0,     0,    61,    62,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   453,
+       0,   422,   423,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   471,     0,     0,     0,     0,     0,     0,
+     424,   425,     0,     0,     0,     0,     0,     0,     0,     0,
+     537,   538,   426,   427,   428,   429,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   430,   431,   432,   433,   434,   299,     0,
+       0,     0,   550,   304,   547,     0,     0,     0,     0,     0,
+       0,     0,     0,   471,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   435,   436,   437,   438,   439,   440,   441,
+     442,     0,   471,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   325,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   634,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   640,   641,   642,   471,   471,   471,   471,   471,
+     471,   471,   471,   471,   471,   471,   471,   471,   471,   471,
+     471,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     471
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,   324,     0,   317,     0,   319,   319,   319,   464,     0,
+     319,   319,   326,   336,   327,   327,   317,   326,   326,   317,
+       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,   533,   327,    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,   357,   349,   416,   425,   589,   527,   515,   529,   405,
+     321,   532,   462,   386,   353,   299,   300,   304,   665,   392,
+     295,   296,   319,   297,   298,   318,   382,   361,   327,   326,
+     364,   378,   366,   367,   324,   374,   370,   327,   451,   349,
+     413,   414,   353,   317,   324,   319,   693,   357,   349,   323,
+     397,   335,   336,   340,   353,   365,   357,   365,   368,   365,
+     354,   318,   301,   302,   365,   359,   360,   324,   378,   465,
+     320,   353,   382,   704,   324,   335,   497,   378,   499,   324,
+     711,   382,   327,   321,   318,   593,   324,   397,   484,   327,
+     324,   722,   321,   318,   318,   318,   397,   318,   408,   324,
+     324,   324,   623,   324,   460,   318,   322,   408,   324,   559,
+     324,   324,   353,   327,   527,   462,   529,   464,   329,   532,
+     331,   542,   321,   306,   307,   308,   309,   310,   311,   312,
+     313,   314,   315,   546,   571,   572,   573,   574,   324,   324,
+     325,   327,   726,   326,   324,   324,   353,   327,   327,   353,
+     460,   319,   462,   327,   464,   676,   664,   324,   325,   460,
+     326,   462,   353,   464,   342,   343,   344,   332,   333,   334,
+     567,   568,   575,   576,   595,   569,   570,   627,   599,   318,
+     317,   554,   353,   319,   353,   339,   533,   338,   337,   303,
+     305,   320,   319,   317,   322,   716,   327,   327,   317,   317,
+     317,   614,   615,   325,   327,   515,   327,   317,   317,   353,
+     623,   353,   559,   318,   515,   353,   320,   320,   324,   317,
+     361,   320,   322,   533,   732,   318,   317,   353,   318,   321,
+     326,   318,   533,   327,   577,   321,   321,   578,   659,   327,
+     365,   322,   579,   581,   665,   580,   582,   682,   382,   559,
+     382,   298,   467,   553,   637,   667,   710,   722,   559,   723,
+     667,   525,   378,   676,   376,   693,   525,   525,   365,   684,
+      -1,    -1,   693,    -1,    -1,    -1,    -1,    -1,    -1,   589,
+     627,    -1,    -1,   593,   705,   698,   682,    -1,   589,    -1,
+      -1,    -1,   593,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     721,    -1,    -1,   716,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   627,   665,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   627,    -1,    -1,    -1,
+      -1,    -1,   688,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   693,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   664,   665,    -1,   667,    -1,    -1,
+      -1,    -1,    -1,   664,   665,    -1,   667,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   688,    -1,
+      -1,    -1,    -1,   693,    -1,    -1,    -1,   688,    -1,    -1,
+      -1,    -1,   693,    -1,   704,    -1,    -1,    -1,    -1,    -1,
+      -1,   711,    -1,   704,    -1,    -1,    -1,    -1,    -1,    -1,
+     711,    -1,   722,    -1,    -1,    -1,   726,    -1,    -1,    -1,
+      -1,   722,   732,    -1,    -1,   726,    -1,    -1,    -1,     0,
+      -1,   732,     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,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   315,   316,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   327,   328,   329,
-     330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     340,   341,   342,   343,    -1,    -1,    -1,    -1,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   372,   373,   374,   375,   376,   377,   378,   379,
-     380,   381,   382,   383,   384,   385,   386,    -1,   388,   389,
-     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
-     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,     3,
+      -1,    -1,    -1,    -1,    -1,    -1,   327,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     341,   342,   343,   344,   345,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   354,   355,   356,   357,   358,   359,   360,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   373,   374,   375,   376,   377,   378,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   387,    -1,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
+     411,   412,   413,   414,   415,   416,   417,   418,   419,     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,
@@ -2804,144 +2518,61 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   297,   298,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   340,   341,   342,   343,
-     344,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   353,
-     354,   355,   356,   357,   358,   359,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,   373,
-     374,   375,   376,   377,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   386,    -1,   388,   389,   390,   391,   392,   393,
+      -1,    -1,   316,   317,    -1,   319,    -1,   321,   322,    -1,
+      -1,    -1,    -1,   327,   328,   329,   330,   331,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   341,   342,   343,
+     344,   345,    -1,    -1,    -1,   349,   350,   351,   352,   353,
+     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
+     364,    -1,   366,   367,   368,   369,   370,   371,   372,   373,
+     374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
+     384,   385,   386,   387,   388,   389,   390,   391,   392,   393,
      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
      404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,     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,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   326,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   340,   341,   342,   343,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   352,   353,   354,   355,   356,   357,
-     358,   359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   372,   373,   374,   375,   376,   377,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   386,    -1,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
-     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
-     418,     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,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   321,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   340,   341,
-     342,   343,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   353,   354,   355,   356,   357,   358,   359,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     372,   373,   374,   375,   376,   377,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   386,    -1,   388,   389,   390,   391,
-     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
-     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
-     412,   413,   414,   415,   416,   417,   418,     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,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   321,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   340,   341,   342,   343,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   353,   354,   355,
-     356,   357,   358,   359,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   372,   373,   374,   375,
-     376,   377,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     386,    -1,   388,   389,   390,   391,   392,   393,   394,   395,
-     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
-     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,     3,     4,     5,     6,     7,     8,     9,
+     414,   415,   416,   417,   418,   419,     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,    -1,    -1,
+     297,   298,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   316,
+     317,    -1,   319,    -1,   321,   322,    -1,    -1,    -1,    -1,
+     327,   328,   329,   330,   331,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   341,   342,   343,   344,   345,    -1,
+      -1,    -1,   349,   350,   351,   352,   353,   354,   355,   356,
+     357,   358,   359,   360,   361,   362,   363,   364,    -1,   366,
+     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
+     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
+     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
+     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
+     417,   418,   419,     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,
@@ -2970,67 +2601,109 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   321,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     340,   341,   342,   343,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   353,   354,   355,   356,   357,   358,   359,
+     290,   291,   292,   293,   294,    -1,    -1,   297,   298,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   372,   373,   374,   375,   376,   377,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   386,    -1,   388,   389,
+      -1,    -1,    -1,    -1,    -1,    -1,   316,   317,    -1,   319,
+      -1,   321,    -1,    -1,    -1,    -1,    -1,   327,   328,   329,
+     330,   331,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   341,   342,   343,   344,   345,    -1,    -1,    -1,   349,
+     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
+     360,   361,   362,   363,   364,    -1,   366,   367,   368,   369,
+     370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
+     380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
      390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
      400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
-     410,   411,   412,   413,   414,   415,   416,   417,   418,     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,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
+       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,    -1,    -1,   297,   298,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   316,   317,    -1,   319,    -1,   321,    -1,
+      -1,    -1,    -1,    -1,   327,   328,   329,   330,   331,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   341,   342,
+     343,   344,   345,    -1,    -1,    -1,   349,   350,   351,   352,
+     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
+     363,   364,    -1,   366,   367,   368,   369,   370,   371,   372,
+     373,   374,   375,   376,   377,   378,   379,   380,   381,   382,
+     383,   384,   385,   386,   387,   388,   389,   390,   391,   392,
+     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
+     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
+     413,   414,   415,   416,   417,   418,   419,     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,    -1,
+      -1,   297,   298,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   340,   341,   342,   343,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   353,
-     354,   355,   356,   357,   358,   359,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   372,   373,
-     374,   375,   376,   377,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   386,    -1,   388,   389,   390,   391,   392,   393,
-     394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
-     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
-     414,   415,   416,   417,   418,     4,     5,     6,     7,     8,
+     316,   317,    -1,   319,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   327,   328,   329,   330,   331,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   341,   342,   343,   344,   345,
+      -1,    -1,    -1,   349,   350,   351,   352,   353,   354,   355,
+     356,   357,   358,   359,   360,   361,   362,   363,   364,    -1,
+     366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
+     376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
+     386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
+     416,   417,   418,   419,     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,
@@ -3053,24 +2726,26 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,    -1,
+     289,   290,   291,   292,   293,   294,    -1,    -1,   297,   298,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   315,   316,    -1,    -1,
-      -1,   320,   321,    -1,    -1,    -1,    -1,    -1,   327,   328,
-     329,   330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,
-     349,   350,   351,   352,   353,    -1,    -1,    -1,    -1,   358,
-     359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   378,
-     379,   380,   381,   382,   383,   384,   385,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   400,     4,     5,     6,     7,     8,     9,    10,    11,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   316,   317,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   327,   328,
+     329,   330,   331,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   341,   342,   343,   344,   345,    -1,    -1,    -1,
+     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
+     359,   360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,   378,
+     379,   380,   381,   382,   383,   384,   385,   386,   387,    -1,
+     389,   390,   391,   392,   393,   394,   395,   396,   397,   398,
+     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
+     409,   410,   411,   412,   413,   414,   415,   416,   417,   418,
+     419,     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,    69,    70,    71,
+      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,
@@ -3093,23 +2768,25 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   315,   316,    -1,    -1,   319,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   327,   328,   329,   330,    -1,
+     292,   293,   294,    -1,    -1,   297,   298,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   348,   349,   350,   351,
-     352,   353,    -1,    -1,    -1,    -1,   358,   359,    -1,    -1,
+      -1,    -1,    -1,    -1,   316,   317,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   328,   329,   330,   331,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   341,
+     342,   343,   344,    -1,    -1,    -1,    -1,   349,   350,   351,
+     352,   353,   354,   355,   356,   357,   358,   359,   360,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   378,   379,   380,   381,
-     382,   383,   384,   385,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   400,     4,
+      -1,   373,   374,   375,   376,   377,   378,   379,   380,   381,
+     382,   383,   384,   385,   386,   387,    -1,   389,   390,   391,
+     392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
+     402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
+     412,   413,   414,   415,   416,   417,   418,   419,     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,
+      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,
@@ -3132,24 +2809,26 @@ static const yytype_int16 yycheck[] =
      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,    -1,
-      -1,   296,   297,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     315,   316,    -1,    -1,    -1,   320,    -1,    -1,    -1,    -1,
-      -1,    -1,   327,   328,   329,   330,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   348,   349,   350,   351,   352,   353,    -1,
-      -1,    -1,    -1,   358,   359,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   378,   379,   380,   381,   382,   383,   384,
-     385,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   400,     4,     5,     6,     7,
+      -1,    -1,   327,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   341,   342,   343,   344,
+     345,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   354,
+     355,   356,   357,   358,   359,   360,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,   374,
+     375,   376,   377,   378,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   387,    -1,   389,   390,   391,   392,   393,   394,
+     395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
+     405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
+     415,   416,   417,   418,   419,     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,    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,
@@ -3172,24 +2851,26 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,
+     288,   289,   290,   291,   292,   293,   294,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   315,   316,    -1,
-      -1,   319,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   327,
-     328,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     348,   349,   350,   351,   352,   353,    -1,    -1,    -1,    -1,
-     358,   359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   327,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     378,   379,   380,   381,   382,   383,   384,   385,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   400,     4,     5,     6,     7,     8,     9,    10,
+      -1,    -1,    -1,   341,   342,   343,   344,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   353,   354,   355,   356,   357,
+     358,   359,   360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,   377,
+     378,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,
+      -1,   389,   390,   391,   392,   393,   394,   395,   396,   397,
+     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,   411,   412,   413,   414,   415,   416,   417,
+     418,   419,     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,    69,    70,
+      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,
@@ -3212,23 +2893,25 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   296,   297,    -1,    -1,    -1,
+     291,   292,   293,   294,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   315,   316,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   326,   327,   328,   329,   330,
+      -1,   322,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   348,   349,   350,
-     351,   352,   353,    -1,    -1,    -1,    -1,   358,   359,    -1,
+     341,   342,   343,   344,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   354,   355,   356,   357,   358,   359,   360,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   378,   379,   380,
-     381,   382,   383,   384,   385,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   400,
+      -1,    -1,   373,   374,   375,   376,   377,   378,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   387,    -1,   389,   390,
+     391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
+     411,   412,   413,   414,   415,   416,   417,   418,   419,     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,
+      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,
@@ -3252,23 +2935,25 @@ static const yytype_int16 yycheck[] =
      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,
-      -1,    -1,   296,   297,    -1,    -1,    -1,    -1,    -1,    -1,
+     294,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   315,   316,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   327,   328,   329,   330,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   322,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   348,   349,   350,   351,   352,   353,
-      -1,    -1,    -1,    -1,   358,   359,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   378,   379,   380,   381,   382,   383,
-     384,   385,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   400,     4,     5,     6,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   341,   342,   343,
+     344,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     354,   355,   356,   357,   358,   359,   360,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   373,
+     374,   375,   376,   377,   378,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   387,    -1,   389,   390,   391,   392,   393,
+     394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
+     404,   405,   406,   407,   408,   409,   410,   411,   412,   413,
+     414,   415,   416,   417,   418,   419,     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,
+      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,
@@ -3291,26 +2976,349 @@ static const yytype_int16 yycheck[] =
      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,   390,    -1,   296,
-     297,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   404,    -1,    -1,    -1,    -1,    -1,    -1,   315,   316,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   421,   422,
-     327,   328,   329,   330,    -1,    -1,    -1,    -1,    -1,    -1,
+     287,   288,   289,   290,   291,   292,   293,   294,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   322,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   341,   342,   343,   344,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   354,   355,   356,
+     357,   358,   359,   360,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   373,   374,   375,   376,
+     377,   378,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     387,    -1,   389,   390,   391,   392,   393,   394,   395,   396,
+     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,   409,   410,   411,   412,   413,   414,   415,   416,
+     417,   418,   419,     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,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   341,   342,   343,   344,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   354,   355,   356,   357,   358,   359,
+     360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   373,   374,   375,   376,   377,   378,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   387,    -1,   389,
+     390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
+     400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
+     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,    -1,    -1,   297,   298,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   316,   317,    -1,    -1,    -1,   321,   322,    -1,
+      -1,    -1,    -1,    -1,   328,   329,   330,   331,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   349,   350,   351,   352,   353,
+     354,    -1,    -1,    -1,    -1,   359,   360,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   379,   380,   381,   382,   383,
+     384,   385,   386,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   401,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
+      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
+     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
+     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
+     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
+     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
+     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+     216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
+     226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
+     236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
+     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
+     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
+     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+     286,   287,   288,   289,   290,   291,   292,   293,   294,    -1,
+      -1,   297,   298,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     316,   317,    -1,    -1,   320,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   328,   329,   330,   331,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   349,   350,   351,   352,   353,   354,    -1,
+      -1,    -1,    -1,   359,   360,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   379,   380,   381,   382,   383,   384,   385,
+     386,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   401,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+      58,    59,    60,    -1,    -1,    63,    64,    65,    66,    67,
+      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
+     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
+     218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
+     228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
+     248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
+     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
+     288,   289,   290,   291,   292,   293,   294,    -1,    -1,   297,
+     298,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   316,   317,
+      -1,    -1,    -1,   321,    -1,    -1,    -1,    -1,    -1,    -1,
+     328,   329,   330,   331,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   349,   350,   351,   352,   353,   354,    -1,    -1,    -1,
+      -1,   359,   360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   379,   380,   381,   382,   383,   384,   385,   386,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   401,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    -1,    -1,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+     170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
+     240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
+     250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
+     260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,    -1,    -1,   297,   298,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   316,   317,    -1,    -1,
+     320,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   328,   329,
+     330,   331,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   349,
+     350,   351,   352,   353,   354,    -1,    -1,    -1,    -1,   359,
+     360,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,
+     380,   381,   382,   383,   384,   385,   386,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   401,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
+      -1,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
+     112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
+     232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
+     242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
+     252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
+     262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
+     292,   293,   294,    -1,    -1,   297,   298,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   316,   317,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   327,   328,   329,   330,   331,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   349,   350,   351,
+     352,   353,   354,    -1,    -1,    -1,    -1,   359,   360,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,   380,   381,
+     382,   383,   384,   385,   386,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   401,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      54,    55,    56,    57,    58,    59,    60,    -1,    -1,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
+     114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
+     224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
+     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
+     244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
+     254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
+     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,   286,   287,   288,   289,   290,   291,   292,   293,
+     294,    -1,    -1,   297,   298,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   316,   317,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   328,   329,   330,   331,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   349,   350,   351,   352,   353,
+     354,    -1,    -1,    -1,    -1,   359,   360,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   379,   380,   381,   382,   383,
+     384,   385,   386,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   401,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    57,    58,    59,    60,    -1,    -1,    63,    64,    65,
+      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
+     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
+     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
+     166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
+     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
+     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+     216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
+     226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
+     236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
+     246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
+     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
+     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+     286,   287,   288,   289,   290,   291,   292,   293,   294,   391,
+      -1,   297,   298,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   405,    -1,    -1,    -1,    -1,    -1,    -1,
+     316,   317,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     422,   423,   328,   329,   330,   331,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   348,   349,   350,   351,   352,   353,    -1,    -1,    -1,
-     453,   358,   359,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   464,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   378,   379,   380,   381,   382,   383,   384,   385,    -1,
-     483,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   400,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   349,   350,   351,   352,   353,   354,    -1,
+      -1,    -1,   454,   359,   360,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   465,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   379,   380,   381,   382,   383,   384,   385,
+     386,    -1,   484,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   401,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   550,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   551,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     563,   564,   565,   566,   567,   568,   569,   570,   571,   572,
-     573,   574,   575,   576,   577,   578,   579,   580,   581,    -1,
+      -1,    -1,   564,   565,   566,   567,   568,   569,   570,   571,
+     572,   573,   574,   575,   576,   577,   578,   579,   580,   581,
+     582,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
@@ -3320,7 +3328,7 @@ static const yytype_int16 yycheck[] =
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   681
+     682
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -3356,116 +3364,116 @@ static const yytype_uint16 yystos[] =
      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,   326,   340,   341,   342,   343,   344,   353,   354,
-     355,   356,   357,   358,   359,   372,   373,   374,   375,   376,
-     377,   386,   388,   389,   390,   391,   392,   393,   394,   395,
+     292,   293,   294,   327,   341,   342,   343,   344,   345,   354,
+     355,   356,   357,   358,   359,   360,   373,   374,   375,   376,
+     377,   378,   387,   389,   390,   391,   392,   393,   394,   395,
      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
      406,   407,   408,   409,   410,   411,   412,   413,   414,   415,
-     416,   417,   418,   450,   451,   454,   455,   456,   457,   461,
-     462,   463,   464,   465,   466,   469,   470,   471,   472,   473,
-     475,   480,   481,   482,   523,   524,   525,   481,   320,   352,
-     316,   316,   326,   352,   326,   526,   317,   323,   458,   459,
-     460,   470,   475,   323,   326,   352,   326,   352,   471,   475,
-     334,   477,   478,     0,   524,   475,   484,   320,   352,   373,
-     467,   468,   352,   474,   318,   326,   476,   320,   502,   459,
-     458,   460,   352,   352,   316,   325,   476,   320,   323,   326,
-     453,   296,   297,   315,   316,   327,   328,   329,   330,   348,
-     349,   350,   351,   352,   378,   379,   380,   381,   382,   383,
-     384,   385,   420,   421,   422,   424,   425,   426,   427,   428,
-     429,   430,   431,   432,   473,   475,   479,   476,   326,   470,
-     475,   485,   486,   483,   325,   317,   323,   317,   323,   319,
-     431,   433,   434,   435,   436,   437,   438,   439,   440,   441,
-     442,   443,   444,   318,   326,   318,   320,   321,   326,   360,
-     361,   362,   363,   365,   366,   367,   368,   369,   370,   371,
-     387,   431,   444,   446,   448,   450,   454,   473,   475,   491,
-     492,   493,   494,   495,   503,   504,   505,   506,   509,   510,
-     513,   514,   515,   522,   527,   476,   325,   476,   320,   446,
-     489,   325,   452,   352,   323,   326,   431,   431,   448,   296,
-     297,   318,   322,   317,   317,   323,   359,   446,   316,   431,
-     323,   335,   475,   352,   487,   488,   321,   486,   485,   444,
-     449,   468,   352,   331,   332,   333,   328,   330,   294,   295,
-     298,   299,   334,   335,   300,   301,   338,   337,   336,   302,
-     304,   303,   339,   319,   319,   444,   318,   321,   496,   316,
-     326,   326,   517,   316,   316,   326,   326,   448,   316,   448,
-     324,   326,   305,   306,   307,   308,   309,   310,   311,   312,
-     313,   314,   325,   447,   323,   326,   321,   492,   506,   510,
-     515,   489,   325,   489,   490,   489,   485,   352,   317,   423,
-     448,   352,   446,   431,   487,   476,   323,   326,   321,   431,
-     431,   431,   433,   433,   434,   434,   435,   435,   435,   435,
-     436,   436,   437,   438,   439,   440,   441,   442,   445,   319,
-     352,   528,   529,   503,   516,   492,   518,   448,   326,   448,
-     324,   446,   446,   489,   321,   323,   321,   319,   326,   488,
-     448,   316,   319,   323,   497,   448,   463,   470,   508,   360,
-     491,   504,   519,   317,   317,   321,   489,   324,   449,   319,
-     529,   321,   352,   317,   316,   508,   520,   521,   499,   500,
-     501,   507,   511,   446,   317,   325,   493,   498,   502,   448,
-     326,   317,   364,   495,   493,   320,   489,   317,   448,   498,
-     499,   503,   512,   326,   321
+     416,   417,   418,   419,   451,   452,   455,   456,   457,   458,
+     462,   463,   464,   465,   466,   467,   470,   471,   472,   473,
+     474,   476,   481,   482,   483,   524,   525,   526,   482,   321,
+     353,   317,   317,   327,   353,   327,   527,   318,   324,   459,
+     460,   461,   471,   476,   324,   327,   353,   327,   353,   472,
+     476,   335,   478,   479,     0,   525,   476,   485,   321,   353,
+     374,   468,   469,   353,   475,   319,   327,   477,   321,   503,
+     460,   459,   461,   353,   353,   317,   326,   477,   321,   324,
+     327,   454,   297,   298,   316,   317,   328,   329,   330,   331,
+     349,   350,   351,   352,   353,   379,   380,   381,   382,   383,
+     384,   385,   386,   421,   422,   423,   425,   426,   427,   428,
+     429,   430,   431,   432,   433,   474,   476,   480,   477,   327,
+     471,   476,   486,   487,   484,   326,   318,   324,   318,   324,
+     320,   432,   434,   435,   436,   437,   438,   439,   440,   441,
+     442,   443,   444,   445,   319,   327,   319,   321,   322,   327,
+     361,   362,   363,   364,   366,   367,   368,   369,   370,   371,
+     372,   388,   432,   445,   447,   449,   451,   455,   474,   476,
+     492,   493,   494,   495,   496,   504,   505,   506,   507,   510,
+     511,   514,   515,   516,   523,   528,   477,   326,   477,   321,
+     447,   490,   326,   453,   353,   324,   327,   432,   432,   449,
+     297,   298,   319,   323,   318,   318,   324,   360,   447,   317,
+     432,   324,   336,   476,   353,   488,   489,   322,   487,   486,
+     445,   450,   469,   353,   332,   333,   334,   329,   331,   295,
+     296,   299,   300,   335,   336,   301,   302,   339,   338,   337,
+     303,   305,   304,   340,   320,   320,   445,   319,   322,   497,
+     317,   327,   327,   518,   317,   317,   327,   327,   449,   317,
+     449,   325,   327,   306,   307,   308,   309,   310,   311,   312,
+     313,   314,   315,   326,   448,   324,   327,   322,   493,   507,
+     511,   516,   490,   326,   490,   491,   490,   486,   353,   318,
+     424,   449,   353,   447,   432,   488,   477,   324,   327,   322,
+     432,   432,   432,   434,   434,   435,   435,   436,   436,   436,
+     436,   437,   437,   438,   439,   440,   441,   442,   443,   446,
+     320,   353,   529,   530,   504,   517,   493,   519,   449,   327,
+     449,   325,   447,   447,   490,   322,   324,   322,   320,   327,
+     489,   449,   317,   320,   324,   498,   449,   464,   471,   509,
+     361,   492,   505,   520,   318,   318,   322,   490,   325,   450,
+     320,   530,   322,   353,   318,   317,   509,   521,   522,   500,
+     501,   502,   508,   512,   447,   318,   326,   494,   499,   503,
+     449,   327,   318,   365,   496,   494,   321,   490,   318,   449,
+     499,   500,   504,   513,   327,   322
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint16 yyr1[] =
 {
-       0,   419,   420,   421,   421,   421,   421,   421,   421,   421,
-     421,   421,   421,   421,   421,   421,   421,   421,   422,   422,
-     422,   422,   422,   422,   423,   424,   425,   426,   426,   427,
-     427,   428,   428,   429,   430,   430,   430,   431,   431,   431,
-     431,   432,   432,   432,   432,   433,   433,   433,   433,   434,
-     434,   434,   435,   435,   435,   436,   436,   436,   436,   436,
-     437,   437,   437,   438,   438,   439,   439,   440,   440,   441,
-     441,   442,   442,   443,   443,   444,   445,   444,   446,   446,
-     447,   447,   447,   447,   447,   447,   447,   447,   447,   447,
-     447,   448,   448,   449,   450,   450,   450,   450,   450,   450,
-     450,   450,   450,   452,   451,   453,   453,   454,   455,   455,
-     456,   456,   457,   458,   458,   459,   459,   459,   459,   460,
-     461,   461,   461,   461,   461,   462,   462,   462,   462,   462,
-     463,   463,   464,   465,   465,   465,   465,   465,   465,   465,
-     465,   466,   467,   467,   468,   468,   468,   469,   470,   470,
-     471,   471,   471,   471,   471,   471,   471,   472,   472,   472,
-     472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
-     472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
-     472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
-     472,   472,   473,   474,   474,   475,   475,   476,   476,   476,
-     476,   477,   477,   478,   479,   479,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   480,   480,   480,
-     480,   480,   480,   480,   480,   480,   480,   481,   481,   481,
-     483,   482,   484,   482,   485,   485,   486,   486,   487,   487,
-     488,   488,   489,   489,   489,   490,   490,   491,   492,   492,
-     493,   493,   493,   493,   493,   493,   493,   493,   494,   495,
-     496,   497,   495,   498,   498,   500,   499,   501,   499,   502,
-     502,   503,   503,   504,   504,   505,   505,   506,   507,   507,
-     508,   508,   509,   509,   511,   510,   512,   512,   513,   513,
-     514,   514,   516,   515,   517,   515,   518,   515,   519,   519,
-     520,   520,   521,   521,   522,   522,   522,   522,   522,   523,
-     523,   524,   524,   524,   526,   525,   527,   528,   528,   529,
-     529
+       0,   420,   421,   422,   422,   422,   422,   422,   422,   422,
+     422,   422,   422,   422,   422,   422,   422,   422,   423,   423,
+     423,   423,   423,   423,   424,   425,   426,   427,   427,   428,
+     428,   429,   429,   430,   431,   431,   431,   432,   432,   432,
+     432,   433,   433,   433,   433,   434,   434,   434,   434,   435,
+     435,   435,   436,   436,   436,   437,   437,   437,   437,   437,
+     438,   438,   438,   439,   439,   440,   440,   441,   441,   442,
+     442,   443,   443,   444,   444,   445,   446,   445,   447,   447,
+     448,   448,   448,   448,   448,   448,   448,   448,   448,   448,
+     448,   449,   449,   450,   451,   451,   451,   451,   451,   451,
+     451,   451,   451,   453,   452,   454,   454,   455,   456,   456,
+     457,   457,   458,   459,   459,   460,   460,   460,   460,   461,
+     462,   462,   462,   462,   462,   463,   463,   463,   463,   463,
+     464,   464,   465,   466,   466,   466,   466,   466,   466,   466,
+     466,   467,   468,   468,   469,   469,   469,   470,   471,   471,
+     472,   472,   472,   472,   472,   472,   472,   473,   473,   473,
+     473,   473,   473,   473,   473,   473,   473,   473,   473,   473,
+     473,   473,   473,   473,   473,   473,   473,   473,   473,   473,
+     473,   473,   473,   473,   473,   473,   473,   473,   473,   473,
+     473,   473,   474,   475,   475,   476,   476,   477,   477,   477,
+     477,   478,   478,   479,   480,   480,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   481,   481,
+     481,   481,   481,   481,   481,   481,   481,   481,   482,   482,
+     482,   484,   483,   485,   483,   486,   486,   487,   487,   488,
+     488,   489,   489,   490,   490,   490,   491,   491,   492,   493,
+     493,   494,   494,   494,   494,   494,   494,   494,   494,   495,
+     496,   497,   498,   496,   499,   499,   501,   500,   502,   500,
+     503,   503,   504,   504,   505,   505,   506,   506,   507,   508,
+     508,   509,   509,   510,   510,   512,   511,   513,   513,   514,
+     514,   515,   515,   517,   516,   518,   516,   519,   516,   520,
+     520,   521,   521,   522,   522,   523,   523,   523,   523,   523,
+     524,   524,   525,   525,   525,   527,   526,   528,   529,   529,
+     530,   530
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -3521,16 +3529,16 @@ static const yytype_uint8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       0,     6,     0,     5,     1,     2,     3,     4,     1,     3,
-       1,     2,     1,     3,     4,     1,     3,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
-       0,     0,     5,     1,     1,     0,     2,     0,     2,     2,
-       3,     1,     2,     1,     2,     1,     2,     5,     3,     1,
-       1,     4,     1,     2,     0,     8,     0,     1,     3,     2,
-       1,     2,     0,     6,     0,     8,     0,     7,     1,     1,
-       1,     0,     2,     3,     2,     2,     2,     3,     2,     1,
-       2,     1,     1,     1,     0,     3,     5,     1,     3,     1,
-       4
+       1,     0,     6,     0,     5,     1,     2,     3,     4,     1,
+       3,     1,     2,     1,     3,     4,     1,     3,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
+       2,     0,     0,     5,     1,     1,     0,     2,     0,     2,
+       2,     3,     1,     2,     1,     2,     1,     2,     5,     3,
+       1,     1,     4,     1,     2,     0,     8,     0,     1,     3,
+       2,     1,     2,     0,     6,     0,     8,     0,     7,     1,
+       1,     1,     0,     2,     3,     2,     2,     2,     3,     2,
+       1,     2,     1,     1,     1,     0,     3,     5,     1,     3,
+       1,     4
 };
 
 
@@ -4213,260 +4221,260 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-#line 355 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 357 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
     }
-#line 4221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4229 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 3:
-#line 361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 363 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4237 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 4:
-#line 364 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 366 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
     }
-#line 4239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4247 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 5:
-#line 369 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 371 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
     }
-#line 4247 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4255 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 6:
-#line 372 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 374 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4263 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 7:
-#line 375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 377 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4272 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 8:
-#line 379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 381 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
     }
-#line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4280 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 9:
-#line 383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 385 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true);
     }
-#line 4280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4288 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 10:
-#line 386 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 388 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4297 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 11:
-#line 390 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 392 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4306 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 12:
-#line 394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 396 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
     }
-#line 4307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4315 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 13:
-#line 398 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 400 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
     }
-#line 4316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4324 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 14:
-#line 402 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 404 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
     }
-#line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4333 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 15:
-#line 406 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 408 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
     }
-#line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4342 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 16:
-#line 410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 412 "glslang.y" /* yacc.c:1646  */
     {
         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 4345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4353 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 17:
-#line 416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 418 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
     }
-#line 4354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4362 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 18:
-#line 424 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 426 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4362 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4370 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 19:
-#line 427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 429 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4378 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 20:
-#line 430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 432 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4386 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 21:
-#line 433 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 435 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
     }
-#line 4386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4394 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 22:
-#line 436 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 438 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4404 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 23:
-#line 441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 443 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 4406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4414 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 24:
-#line 449 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 451 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4423 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 25:
-#line 456 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 458 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
         delete (yyvsp[0].interm).function;
     }
-#line 4424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4432 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 26:
-#line 463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 465 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4432 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4440 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 27:
-#line 469 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 471 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4449 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 28:
-#line 473 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 475 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4458 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 29:
-#line 480 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 482 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4466 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 30:
-#line 483 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 485 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 4466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4474 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 31:
-#line 489 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 491 "glslang.y" /* yacc.c:1646  */
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -4474,11 +4482,11 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-1].interm).function;
         (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
     }
-#line 4478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4486 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 32:
-#line 496 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 498 "glslang.y" /* yacc.c:1646  */
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
@@ -4486,29 +4494,29 @@ yyreduce:
         (yyval.interm).function = (yyvsp[-2].interm).function;
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
     }
-#line 4490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4498 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 33:
-#line 506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 508 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-1].interm);
     }
-#line 4498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4506 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 34:
-#line 514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 516 "glslang.y" /* yacc.c:1646  */
     {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4516 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 35:
-#line 519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 521 "glslang.y" /* yacc.c:1646  */
     {
         //
         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
@@ -4536,50 +4544,50 @@ yyreduce:
             (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
         }
     }
-#line 4540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4548 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 36:
-#line 547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 549 "glslang.y" /* yacc.c:1646  */
     {
         // Constructor
         (yyval.interm).intermNode = 0;
         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
     }
-#line 4550 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4558 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 37:
-#line 556 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 558 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
     }
-#line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4569 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 38:
-#line 562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 564 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 4570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4578 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 39:
-#line 566 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 568 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
     }
-#line 4579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4587 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 40:
-#line 570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 572 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm).op != EOpNull) {
             char errorOp[2] = {0, 0};
@@ -4596,179 +4604,179 @@ yyreduce:
                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
         }
     }
-#line 4600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4608 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 41:
-#line 590 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 592 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
-#line 4606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4614 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 42:
-#line 591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 593 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
-#line 4612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4620 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 43:
-#line 592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 594 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
-#line 4618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4626 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 44:
-#line 593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 595 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
               parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
-#line 4625 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4633 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 45:
-#line 599 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 601 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4639 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 46:
-#line 600 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 602 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4649 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 47:
-#line 605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 607 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4659 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 48:
-#line 610 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 612 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4670 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 49:
-#line 619 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 621 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4676 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 50:
-#line 620 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 622 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4686 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 51:
-#line 625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 627 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4696 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 52:
-#line 633 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 635 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4702 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 53:
-#line 634 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 636 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4713 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 54:
-#line 640 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 642 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4724 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 55:
-#line 649 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 651 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4730 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 56:
-#line 650 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 652 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4740 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 57:
-#line 655 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 657 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4750 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 58:
-#line 660 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 662 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4760 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 59:
-#line 665 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 667 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4770 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 60:
-#line 673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 675 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4768 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4776 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 61:
-#line 674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 676 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
@@ -4778,11 +4786,11 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4790 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 62:
-#line 683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 685 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
@@ -4792,124 +4800,124 @@ yyreduce:
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4804 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 63:
-#line 695 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 697 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4810 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 64:
-#line 696 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 698 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4821 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 65:
-#line 705 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 707 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4827 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 66:
-#line 706 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 708 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4830 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4838 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 67:
-#line 715 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 717 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4844 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 68:
-#line 716 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 718 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 4847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4855 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 69:
-#line 725 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 727 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4861 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 70:
-#line 726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 728 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4871 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 71:
-#line 734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 736 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4877 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 72:
-#line 735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 737 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4887 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 73:
-#line 743 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 745 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4893 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 74:
-#line 744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 746 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
     }
-#line 4895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4903 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 75:
-#line 752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 754 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4909 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 76:
-#line 753 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 755 "glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4917 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 77:
-#line 756 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 758 "glslang.y" /* yacc.c:1646  */
     {
         --parseContext.controlFlowNestingLevel;
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
@@ -4922,17 +4930,17 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 4926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4934 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 78:
-#line 771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 773 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
-#line 4932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4940 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 79:
-#line 772 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 774 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
         parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
@@ -4946,119 +4954,119 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
         }
     }
-#line 4950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4958 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 80:
-#line 788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 790 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
-#line 4959 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4967 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 81:
-#line 792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 794 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
-#line 4968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4976 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 82:
-#line 796 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 798 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
-#line 4977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4985 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 83:
-#line 800 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 802 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpModAssign;
     }
-#line 4987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 4995 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 84:
-#line 805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 807 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
-#line 4996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5004 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 85:
-#line 809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 811 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
-#line 5005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5013 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 86:
-#line 813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 815 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
-#line 5014 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5022 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 87:
-#line 817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 819 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
-#line 5023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5031 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 88:
-#line 821 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 823 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
-#line 5032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5040 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 89:
-#line 825 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 827 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
-#line 5041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5049 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 90:
-#line 829 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 831 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
-#line 5050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5058 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 91:
-#line 836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 838 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5066 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 92:
-#line 839 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 841 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
@@ -5067,40 +5075,40 @@ yyreduce:
             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         }
     }
-#line 5071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5079 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 93:
-#line 850 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 852 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 5080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5088 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 94:
-#line 857 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 859 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
         (yyval.interm.intermNode) = 0;
         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
     }
-#line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5098 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 95:
-#line 862 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 864 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
             (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
     }
-#line 5100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5108 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 96:
-#line 867 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 869 "glslang.y" /* yacc.c:1646  */
     {
         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
@@ -5108,75 +5116,75 @@ yyreduce:
         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
         (yyval.interm.intermNode) = 0;
     }
-#line 5112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5120 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 97:
-#line 874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 876 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
         (yyval.interm.intermNode) = 0;
     }
-#line 5121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5129 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 98:
-#line 878 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 880 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 5130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5138 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 99:
-#line 882 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 884 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
         (yyval.interm.intermNode) = 0;
     }
-#line 5139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5147 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 100:
-#line 886 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 888 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
         parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
         (yyval.interm.intermNode) = 0;
     }
-#line 5149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5157 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 101:
-#line 891 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 893 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
         parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
         (yyval.interm.intermNode) = 0;
     }
-#line 5159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5167 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 102:
-#line 896 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 898 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers);
         (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string);
         parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
         (yyval.interm.intermNode) = 0;
     }
-#line 5170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5178 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 103:
-#line 905 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 907 "glslang.y" /* yacc.c:1646  */
     { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
-#line 5176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5184 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 104:
-#line 905 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 907 "glslang.y" /* yacc.c:1646  */
     {
         --parseContext.structNestingLevel;
         parseContext.blockName = (yyvsp[-4].lex).string;
@@ -5186,54 +5194,54 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
     }
-#line 5190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5198 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 105:
-#line 916 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 918 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5207 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 106:
-#line 920 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 922 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
     }
-#line 5208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5216 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 107:
-#line 927 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 929 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).function = (yyvsp[-1].interm.function);
         (yyval.interm).loc = (yyvsp[0].lex).loc;
     }
-#line 5217 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5225 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 108:
-#line 934 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 936 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5233 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 109:
-#line 937 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 939 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.function) = (yyvsp[0].interm.function);
     }
-#line 5233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5241 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 110:
-#line 944 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 946 "glslang.y" /* yacc.c:1646  */
     {
         // Add the parameter
         (yyval.interm.function) = (yyvsp[-1].interm.function);
@@ -5242,11 +5250,11 @@ yyreduce:
         else
             delete (yyvsp[0].interm).param.type;
     }
-#line 5246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5254 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 111:
-#line 952 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 954 "glslang.y" /* yacc.c:1646  */
     {
         //
         // Only first parameter of one-parameter functions can be void
@@ -5264,11 +5272,11 @@ yyreduce:
             (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
         }
     }
-#line 5268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5276 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 112:
-#line 972 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 974 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
             parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
@@ -5288,11 +5296,11 @@ yyreduce:
         function = new TFunction((yyvsp[-1].lex).string, type);
         (yyval.interm.function) = function;
     }
-#line 5292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5300 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 113:
-#line 995 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 997 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5308,11 +5316,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[0].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5320 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 114:
-#line 1010 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1012 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -5332,11 +5340,11 @@ yyreduce:
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).param = param;
     }
-#line 5336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5344 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 115:
-#line 1035 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1037 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5348,11 +5356,11 @@ yyreduce:
         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
 
     }
-#line 5352 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5360 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 116:
-#line 1046 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1048 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5360,11 +5368,11 @@ yyreduce:
         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
     }
-#line 5364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5372 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 117:
-#line 1056 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1058 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
@@ -5375,11 +5383,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 5379 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5387 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 118:
-#line 1066 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1068 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
 
@@ -5387,68 +5395,68 @@ yyreduce:
         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
     }
-#line 5391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5399 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 119:
-#line 1076 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1078 "glslang.y" /* yacc.c:1646  */
     {
         TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
         (yyval.interm).param = param;
         if ((yyvsp[0].interm.type).arraySizes)
             parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
     }
-#line 5402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5410 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 120:
-#line 1085 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1087 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[0].interm);
     }
-#line 5410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5418 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 121:
-#line 1088 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1090 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-2].interm);
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
     }
-#line 5419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5427 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 122:
-#line 1092 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1094 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-3].interm);
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
     }
-#line 5428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5436 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 123:
-#line 1096 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1098 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-5].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
     }
-#line 5438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5446 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 124:
-#line 1101 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1103 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-4].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
     }
-#line 5448 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5456 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 125:
-#line 1109 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1111 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[0].interm.type);
         (yyval.interm).intermNode = 0;
@@ -5456,51 +5464,51 @@ yyreduce:
         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
 
     }
-#line 5460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5468 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 126:
-#line 1116 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1118 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-1].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
     }
-#line 5470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5478 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 127:
-#line 1121 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1123 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-2].interm.type);
         (yyval.interm).intermNode = 0;
         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
     }
-#line 5480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5488 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 128:
-#line 1126 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1128 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-4].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
     }
-#line 5490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5498 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 129:
-#line 1131 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1133 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).type = (yyvsp[-3].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
     }
-#line 5500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5508 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 130:
-#line 1140 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1142 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
 
@@ -5511,11 +5519,11 @@ yyreduce:
         }
         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
     }
-#line 5515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5523 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 131:
-#line 1150 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1152 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
         parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
@@ -5540,22 +5548,22 @@ yyreduce:
              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
             (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5552 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 132:
-#line 1177 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1179 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
         parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.invariant = true;
     }
-#line 5555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5563 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 133:
-#line 1186 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1188 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
@@ -5563,11 +5571,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.smooth = true;
     }
-#line 5567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5575 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 134:
-#line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1195 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
@@ -5575,11 +5583,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.flat = true;
     }
-#line 5579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5587 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 135:
-#line 1201 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1203 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
@@ -5587,11 +5595,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nopersp = true;
     }
-#line 5591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5599 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 136:
-#line 1208 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1210 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
@@ -5599,11 +5607,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.explicitInterp = true;
     }
-#line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5611 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 137:
-#line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1217 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
@@ -5612,11 +5620,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.pervertexNV = true;
     }
-#line 5616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5624 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 138:
-#line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1225 "glslang.y" /* yacc.c:1646  */
     {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
@@ -5627,11 +5635,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perPrimitiveNV = true;
     }
-#line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5639 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 139:
-#line 1233 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1235 "glslang.y" /* yacc.c:1646  */
     {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
@@ -5639,11 +5647,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perViewNV = true;
     }
-#line 5643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5651 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 140:
-#line 1240 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1242 "glslang.y" /* yacc.c:1646  */
     {
         // No need for profile version or extension check. Shader stage already checks both.
         parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
@@ -5651,84 +5659,84 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.perTaskNV = true;
     }
-#line 5655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5663 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 141:
-#line 1251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1253 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
     }
-#line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5671 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 142:
-#line 1257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1259 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5679 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 143:
-#line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1262 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-2].interm.type);
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
         parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
     }
-#line 5681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5689 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 144:
-#line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1269 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
     }
-#line 5690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5698 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 145:
-#line 1271 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1273 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[-2].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
     }
-#line 5699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5707 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 146:
-#line 1275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1277 "glslang.y" /* yacc.c:1646  */
     { // because "shared" is both an identifier and a keyword
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         TString strShared("shared");
         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
     }
-#line 5709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5717 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 147:
-#line 1284 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1286 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.noContraction = true;
     }
-#line 5720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5728 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 148:
-#line 1294 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1296 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5728 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5736 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 149:
-#line 1297 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1299 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         if ((yyval.interm.type).basicType == EbtVoid)
@@ -5737,112 +5745,112 @@ 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 5741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5749 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 150:
-#line 1308 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1310 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5757 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 151:
-#line 1311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1313 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5765 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 152:
-#line 1314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1316 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5774 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 153:
-#line 1318 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1320 "glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5775 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5783 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 154:
-#line 1322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1324 "glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5784 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5792 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 155:
-#line 1327 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1329 "glslang.y" /* yacc.c:1646  */
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5801 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 156:
-#line 1331 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1333 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
     }
-#line 5801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5809 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 157:
-#line 1338 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1340 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
     }
-#line 5810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5818 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 158:
-#line 1342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1344 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqInOut;
     }
-#line 5820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5828 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 159:
-#line 1347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1349 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "in");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqIn;
     }
-#line 5831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5839 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 160:
-#line 1353 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1355 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "out");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
         (yyval.interm.type).qualifier.storage = EvqOut;
     }
-#line 5842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5850 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 161:
-#line 1359 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1361 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
@@ -5850,21 +5858,21 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.centroid = true;
     }
-#line 5854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5862 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 162:
-#line 1366 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1368 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqUniform;
     }
-#line 5864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5872 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 163:
-#line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1373 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
@@ -5873,21 +5881,21 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqShared;
     }
-#line 5877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5885 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 164:
-#line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1381 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqBuffer;
     }
-#line 5887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5895 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 165:
-#line 1385 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1387 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
@@ -5900,11 +5908,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5912 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 166:
-#line 1397 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1399 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
@@ -5919,32 +5927,32 @@ yyreduce:
         else
             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
     }
-#line 5923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5931 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 167:
-#line 1411 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1413 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.patch = true;
     }
-#line 5934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5942 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 168:
-#line 1417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1419 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.sample = true;
     }
-#line 5944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5952 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 169:
-#line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1424 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -5953,11 +5961,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 5957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5965 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 170:
-#line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1432 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@@ -5966,11 +5974,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqHitAttr;
     }
-#line 5970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5978 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 171:
-#line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1440 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -5979,11 +5987,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 5983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 5991 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 172:
-#line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1448 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask |
@@ -5992,11 +6000,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayload;
     }
-#line 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6004 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 173:
-#line 1454 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1456 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -6005,11 +6013,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 6009 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6017 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 174:
-#line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1464 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask |
@@ -6018,11 +6026,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqPayloadIn;
     }
-#line 6022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6030 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 175:
-#line 1470 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1472 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -6031,11 +6039,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6043 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 176:
-#line 1478 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1480 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask |
@@ -6044,11 +6052,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableData;
     }
-#line 6048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6056 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 177:
-#line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1488 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV");
@@ -6056,11 +6064,11 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 6060 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6068 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 178:
-#line 1493 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1495 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT");
         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT");
@@ -6068,175 +6076,175 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqCallableDataIn;
     }
-#line 6072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6080 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 179:
-#line 1500 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1502 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
-#line 6081 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6089 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 180:
-#line 1504 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1506 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
         (yyval.interm.type).qualifier.devicecoherent = true;
     }
-#line 6091 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6099 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 181:
-#line 1509 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1511 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
         (yyval.interm.type).qualifier.queuefamilycoherent = true;
     }
-#line 6101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6109 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 182:
-#line 1514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1516 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
         (yyval.interm.type).qualifier.workgroupcoherent = true;
     }
-#line 6111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6119 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 183:
-#line 1519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1521 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
         (yyval.interm.type).qualifier.subgroupcoherent = true;
     }
-#line 6121 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6129 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 184:
-#line 1524 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1526 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
         (yyval.interm.type).qualifier.nonprivate = true;
     }
-#line 6131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6139 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 185:
-#line 1529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1531 "glslang.y" /* yacc.c:1646  */
     {
         (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 6141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6149 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 186:
-#line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1536 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.volatil = true;
     }
-#line 6150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6158 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 187:
-#line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1540 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.restrict = true;
     }
-#line 6159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6167 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 188:
-#line 1542 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1544 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.readonly = true;
     }
-#line 6168 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6176 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 189:
-#line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1548 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.writeonly = true;
     }
-#line 6177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6185 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 190:
-#line 1550 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1552 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[0].lex).loc);
     }
-#line 6188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6196 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 191:
-#line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1558 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
         parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
         (yyval.interm.type).init((yyvsp[-3].lex).loc);
     }
-#line 6199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6207 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 192:
-#line 1567 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1569 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc);
         (yyval.interm.type).qualifier.nonUniform = true;
     }
-#line 6208 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6216 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 193:
-#line 1574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1576 "glslang.y" /* yacc.c:1646  */
     {
         // TODO
     }
-#line 6216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6224 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 194:
-#line 1577 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1579 "glslang.y" /* yacc.c:1646  */
     {
         // TODO: 4.0 semantics: subroutines
         // 1) make sure each identifier is a type declared earlier with SUBROUTINE
         // 2) save all of the identifiers for future comparison with the declared function
     }
-#line 6226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6234 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 195:
-#line 1586 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1588 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[-1].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
         (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters);
     }
-#line 6236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6244 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 196:
-#line 1591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1593 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
         (yyval.interm.type) = (yyvsp[-2].interm.type);
@@ -6244,21 +6252,21 @@ yyreduce:
         (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters);
         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
     }
-#line 6248 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6256 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 197:
-#line 1601 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1603 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[-1].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 6258 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6266 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 198:
-#line 1606 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1608 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm).loc = (yyvsp[-2].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -6267,20 +6275,20 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 6271 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6279 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 199:
-#line 1614 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1616 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-2].interm);
         (yyval.interm).arraySizes->addInnerSize();
     }
-#line 6280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6288 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 200:
-#line 1618 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1620 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm) = (yyvsp[-3].interm);
 
@@ -6288,35 +6296,35 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
         (yyval.interm).arraySizes->addInnerSize(size);
     }
-#line 6292 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6300 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 201:
-#line 1628 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1630 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
     }
-#line 6300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6308 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 202:
-#line 1631 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1633 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeParameters) = 0;
     }
-#line 6308 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6316 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 203:
-#line 1637 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1639 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
     }
-#line 6316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6324 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 204:
-#line 1643 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1645 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeParameters) = new TArraySizes;
 
@@ -6324,11 +6332,11 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
         (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6336 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 205:
-#line 1650 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1652 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
 
@@ -6336,300 +6344,300 @@ yyreduce:
         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
         (yyval.interm.typeParameters)->addInnerSize(size);
     }
-#line 6340 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6348 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 206:
-#line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1662 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
-#line 6349 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6357 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 207:
-#line 1664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1666 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 6358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6366 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 208:
-#line 1668 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1670 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 6367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6375 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 209:
-#line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1674 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 6377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6385 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 210:
-#line 1677 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1679 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
     }
-#line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6394 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 211:
-#line 1681 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1683 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6404 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 212:
-#line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1688 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6414 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 213:
-#line 1691 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1693 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6424 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 214:
-#line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1698 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(2);
     }
-#line 6426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6434 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 215:
-#line 1701 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1703 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(3);
     }
-#line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6444 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 216:
-#line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1708 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
         (yyval.interm.type).setVector(4);
     }
-#line 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6454 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 217:
-#line 1711 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1713 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 6456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6464 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 218:
-#line 1716 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1718 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6474 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 219:
-#line 1721 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1723 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 6476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6484 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 220:
-#line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1728 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 6487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6495 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 221:
-#line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1734 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 6498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6506 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 222:
-#line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1740 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 6509 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6517 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 223:
-#line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1746 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 6519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6527 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 224:
-#line 1749 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1751 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 6529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6537 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 225:
-#line 1754 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1756 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 6539 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6547 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 226:
-#line 1759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1761 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 6549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6557 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 227:
-#line 1764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1766 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 6559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6567 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 228:
-#line 1769 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1771 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 6569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6577 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 229:
-#line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1776 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 6579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6587 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 230:
-#line 1779 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1781 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 6589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6597 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 231:
-#line 1784 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1786 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 6599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6607 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 232:
-#line 1789 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1791 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 6609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6617 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 233:
-#line 1794 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1796 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 6619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6627 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 234:
-#line 1799 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1801 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 6629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6637 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 235:
-#line 1805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1807 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -6637,121 +6645,121 @@ yyreduce:
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 6641 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6649 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 236:
-#line 1812 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1814 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
     }
-#line 6651 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6659 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 237:
-#line 1817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1819 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
-#line 6661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6669 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 238:
-#line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1824 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
     }
-#line 6671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6679 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 239:
-#line 1827 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1829 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
     }
-#line 6681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6689 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 240:
-#line 1832 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1834 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
     }
-#line 6691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6699 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 241:
-#line 1837 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1839 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
     }
-#line 6701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6709 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 242:
-#line 1842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1844 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
     }
-#line 6711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6719 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 243:
-#line 1847 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1849 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
-#line 6721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6729 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 244:
-#line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1854 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
     }
-#line 6731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6739 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 245:
-#line 1857 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1859 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
     }
-#line 6741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6749 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 246:
-#line 1862 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1864 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
     }
-#line 6751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6759 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 247:
-#line 1867 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1869 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -6760,11 +6768,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 6764 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6772 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 248:
-#line 1875 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1877 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -6773,11 +6781,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 6777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6785 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 249:
-#line 1883 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1885 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -6786,374 +6794,374 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 6790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6798 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 250:
-#line 1891 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1893 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(2);
     }
-#line 6801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6809 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 251:
-#line 1897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1899 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(3);
     }
-#line 6812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6820 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 252:
-#line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1905 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setVector(4);
     }
-#line 6823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6831 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 253:
-#line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1911 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(2);
     }
-#line 6834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6842 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 254:
-#line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1917 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(3);
     }
-#line 6845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6853 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 255:
-#line 1921 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1923 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setVector(4);
     }
-#line 6856 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6864 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 256:
-#line 1927 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1929 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(2);
     }
-#line 6867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6875 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 257:
-#line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1935 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(3);
     }
-#line 6878 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6886 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 258:
-#line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1941 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setVector(4);
     }
-#line 6889 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6897 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 259:
-#line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1947 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(2);
     }
-#line 6900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6908 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 260:
-#line 1951 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1953 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(3);
     }
-#line 6911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6919 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 261:
-#line 1957 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1959 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt8;
         (yyval.interm.type).setVector(4);
     }
-#line 6922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6930 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 262:
-#line 1963 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1965 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(2);
     }
-#line 6933 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6941 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 263:
-#line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1971 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(3);
     }
-#line 6944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6952 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 264:
-#line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1977 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt16;
         (yyval.interm.type).setVector(4);
     }
-#line 6955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6963 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 265:
-#line 1981 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1983 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(2);
     }
-#line 6966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6974 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 266:
-#line 1987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1989 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(3);
     }
-#line 6977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6985 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 267:
-#line 1993 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 1995 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).setVector(4);
     }
-#line 6988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 6996 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 268:
-#line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2001 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(2);
     }
-#line 6999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7007 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 269:
-#line 2005 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2007 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(3);
     }
-#line 7010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7018 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 270:
-#line 2011 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2013 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt64;
         (yyval.interm.type).setVector(4);
     }
-#line 7021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7029 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 271:
-#line 2017 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2019 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(2);
     }
-#line 7032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7040 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 272:
-#line 2023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2025 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(3);
     }
-#line 7043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7051 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 273:
-#line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2031 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint8;
         (yyval.interm.type).setVector(4);
     }
-#line 7054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7062 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 274:
-#line 2035 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2037 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(2);
     }
-#line 7065 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7073 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 275:
-#line 2041 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2043 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(3);
     }
-#line 7076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7084 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 276:
-#line 2047 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2049 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint16;
         (yyval.interm.type).setVector(4);
     }
-#line 7087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7095 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 277:
-#line 2053 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2055 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(2);
     }
-#line 7098 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7106 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 278:
-#line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2061 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(3);
     }
-#line 7109 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7117 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 279:
-#line 2065 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2067 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).setVector(4);
     }
-#line 7120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7128 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 280:
-#line 2071 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2073 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(2);
     }
-#line 7131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7139 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 281:
-#line 2077 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2079 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(3);
     }
-#line 7142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7150 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 282:
-#line 2083 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2085 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint64;
         (yyval.interm.type).setVector(4);
     }
-#line 7153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7161 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 283:
-#line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2091 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7162,11 +7170,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7174 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 284:
-#line 2097 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2099 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7175,11 +7183,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7179 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7187 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 285:
-#line 2105 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2107 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7188,11 +7196,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7200 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 286:
-#line 2113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2115 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7201,11 +7209,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7205 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7213 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 287:
-#line 2121 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2123 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7214,11 +7222,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7218 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7226 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 288:
-#line 2129 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2131 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7227,11 +7235,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7239 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 289:
-#line 2137 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2139 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7240,11 +7248,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7252 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 290:
-#line 2145 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2147 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7253,11 +7261,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7257 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7265 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 291:
-#line 2153 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2155 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7266,11 +7274,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7270 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7278 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 292:
-#line 2161 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2163 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7279,11 +7287,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7291 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 293:
-#line 2169 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2171 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7292,11 +7300,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7304 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 294:
-#line 2177 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2179 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
         if (! parseContext.symbolTable.atBuiltInLevel())
@@ -7305,1999 +7313,2008 @@ yyreduce:
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7317 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 295:
-#line 2185 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2187 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7328 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 296:
-#line 2191 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2193 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7339 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 297:
-#line 2197 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2199 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7350 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 298:
-#line 2203 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2205 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7361 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 299:
-#line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2211 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7372 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 300:
-#line 2215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2217 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7383 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 301:
-#line 2221 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2223 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7394 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 302:
-#line 2227 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2229 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7405 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 303:
-#line 2233 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2235 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7416 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 304:
-#line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2241 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7427 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 305:
-#line 2245 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2247 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7438 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 306:
-#line 2251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2253 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat16;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7449 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 307:
-#line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2259 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7460 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 308:
-#line 2263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2265 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7471 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 309:
-#line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2271 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7482 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 310:
-#line 2275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2277 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7493 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 311:
-#line 2281 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2283 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7504 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 312:
-#line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2289 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7515 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 313:
-#line 2293 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2295 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7526 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 314:
-#line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2301 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7537 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 315:
-#line 2305 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2307 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7548 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 316:
-#line 2311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2313 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7559 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 317:
-#line 2317 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2319 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7570 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 318:
-#line 2323 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2325 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7581 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 319:
-#line 2329 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2331 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7592 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 320:
-#line 2335 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2337 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7603 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 321:
-#line 2341 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2343 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7614 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 322:
-#line 2347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2349 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 2);
     }
-#line 7617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7625 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 323:
-#line 2353 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2355 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 3);
     }
-#line 7628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7636 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 324:
-#line 2359 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2361 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(2, 4);
     }
-#line 7639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7647 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 325:
-#line 2365 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2367 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 2);
     }
-#line 7650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7658 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 326:
-#line 2371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2373 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 3);
     }
-#line 7661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7669 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 327:
-#line 2377 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2379 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(3, 4);
     }
-#line 7672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7680 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 328:
-#line 2383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2385 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 2);
     }
-#line 7683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7691 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 329:
-#line 2389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2391 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 3);
     }
-#line 7694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7702 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 330:
-#line 2395 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2397 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtDouble;
         (yyval.interm.type).setMatrix(4, 4);
     }
-#line 7705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7713 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 331:
-#line 2401 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2403 "glslang.y" /* yacc.c:1646  */
     {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 7714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7722 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 332:
-#line 2405 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2407 "glslang.y" /* yacc.c:1646  */
     {
        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
        (yyval.interm.type).basicType = EbtAccStruct;
     }
-#line 7723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7731 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 333:
-#line 2409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 2411 "glslang.y" /* yacc.c:1646  */
+    {
+       (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
+       (yyval.interm.type).basicType = EbtRayQuery;
+    }
+#line 7740 "glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 334:
+#line 2415 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtAtomicUint;
     }
-#line 7733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7750 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 334:
-#line 2414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 335:
+#line 2420 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
     }
-#line 7743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7760 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 335:
-#line 2420 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 336:
+#line 2426 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
     }
-#line 7753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7770 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 336:
-#line 2425 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 337:
+#line 2431 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
     }
-#line 7763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7780 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 337:
-#line 2430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 338:
+#line 2436 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
     }
-#line 7773 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7790 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 338:
-#line 2435 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 339:
+#line 2441 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
     }
-#line 7783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7800 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 339:
-#line 2440 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 340:
+#line 2446 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
     }
-#line 7793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7810 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 340:
-#line 2445 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 341:
+#line 2451 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
     }
-#line 7803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7820 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 341:
-#line 2450 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 342:
+#line 2456 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
     }
-#line 7813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7830 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 342:
-#line 2456 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 343:
+#line 2462 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
     }
-#line 7823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7840 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 343:
-#line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 344:
+#line 2467 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
     }
-#line 7833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7850 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 344:
-#line 2466 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 345:
+#line 2472 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
     }
-#line 7843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7860 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 345:
-#line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 346:
+#line 2477 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
     }
-#line 7853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7870 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 346:
-#line 2476 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 347:
+#line 2482 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
     }
-#line 7863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7880 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 347:
-#line 2481 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 348:
+#line 2487 "glslang.y" /* yacc.c:1646  */
     {
         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 7874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7891 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 348:
-#line 2487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 349:
+#line 2493 "glslang.y" /* yacc.c:1646  */
     {
         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 7885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7902 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 349:
-#line 2493 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 350:
+#line 2499 "glslang.y" /* yacc.c:1646  */
     {
         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 7896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7913 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 350:
-#line 2499 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 351:
+#line 2505 "glslang.y" /* yacc.c:1646  */
     {
         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 7907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7924 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 351:
-#line 2505 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 352:
+#line 2511 "glslang.y" /* yacc.c:1646  */
     {
         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 7918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7935 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 352:
-#line 2511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 353:
+#line 2517 "glslang.y" /* yacc.c:1646  */
     {
         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 7929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7946 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 353:
-#line 2517 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 354:
+#line 2523 "glslang.y" /* yacc.c:1646  */
     {
         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 7940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7957 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 354:
-#line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 355:
+#line 2529 "glslang.y" /* yacc.c:1646  */
     {
         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 7951 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7968 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 355:
-#line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 356:
+#line 2535 "glslang.y" /* yacc.c:1646  */
     {
         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 7962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7979 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 356:
-#line 2535 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 357:
+#line 2541 "glslang.y" /* yacc.c:1646  */
     {
         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 7973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 7990 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 357:
-#line 2541 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 358:
+#line 2547 "glslang.y" /* yacc.c:1646  */
     {
         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 7984 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8001 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 358:
-#line 2547 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 359:
+#line 2553 "glslang.y" /* yacc.c:1646  */
     {
         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 7995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8012 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 359:
-#line 2553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 360:
+#line 2559 "glslang.y" /* yacc.c:1646  */
     {
         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 8006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8023 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 360:
-#line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 361:
+#line 2565 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D);
     }
-#line 8016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8033 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 361:
-#line 2565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 362:
+#line 2571 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D);
     }
-#line 8026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8043 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 362:
-#line 2570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 363:
+#line 2576 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd3D);
     }
-#line 8036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8053 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 363:
-#line 2575 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 364:
+#line 2581 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube);
     }
-#line 8046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8063 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 364:
-#line 2580 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 365:
+#line 2586 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
     }
-#line 8056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8073 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 365:
-#line 2585 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 366:
+#line 2591 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D);
     }
-#line 8066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8083 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 366:
-#line 2590 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 367:
+#line 2596 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd3D);
     }
-#line 8076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8093 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 367:
-#line 2595 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 368:
+#line 2601 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube);
     }
-#line 8086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8103 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 368:
-#line 2601 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 369:
+#line 2607 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
     }
-#line 8096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8113 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 369:
-#line 2606 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 370:
+#line 2612 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
     }
-#line 8106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8123 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 370:
-#line 2611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 371:
+#line 2617 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D);
     }
-#line 8116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8133 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 371:
-#line 2616 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 372:
+#line 2622 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
     }
-#line 8126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8143 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 372:
-#line 2621 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 373:
+#line 2627 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
     }
-#line 8136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8153 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 373:
-#line 2626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 374:
+#line 2632 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
     }
-#line 8146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8163 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 374:
-#line 2631 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 375:
+#line 2637 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true);
     }
-#line 8156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8173 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 375:
-#line 2636 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 376:
+#line 2642 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
     }
-#line 8166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8183 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 376:
-#line 2642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 377:
+#line 2648 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
     }
-#line 8176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8193 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 377:
-#line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 378:
+#line 2653 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
     }
-#line 8186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8203 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 378:
-#line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 379:
+#line 2658 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
     }
-#line 8196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8213 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 379:
-#line 2657 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 380:
+#line 2663 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
     }
-#line 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8223 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 380:
-#line 2662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 381:
+#line 2668 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
     }
-#line 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8233 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 381:
-#line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 382:
+#line 2673 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
     }
-#line 8226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8243 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 382:
-#line 2672 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 383:
+#line 2678 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
     }
-#line 8236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8253 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 383:
-#line 2677 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 384:
+#line 2683 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
     }
-#line 8246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8263 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 384:
-#line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 385:
+#line 2688 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
     }
-#line 8256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8273 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 385:
-#line 2687 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 386:
+#line 2693 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
     }
-#line 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8283 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 386:
-#line 2692 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 387:
+#line 2698 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
     }
-#line 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8293 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 387:
-#line 2697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 388:
+#line 2703 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
     }
-#line 8286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8303 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 388:
-#line 2702 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 389:
+#line 2708 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
     }
-#line 8296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8313 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 389:
-#line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 390:
+#line 2713 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(false);
     }
-#line 8306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8323 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 390:
-#line 2712 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 391:
+#line 2718 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setPureSampler(true);
     }
-#line 8316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8333 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 391:
-#line 2718 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 392:
+#line 2724 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
     }
-#line 8326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8343 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 392:
-#line 2723 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 393:
+#line 2729 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
     }
-#line 8336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8353 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 393:
-#line 2728 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 394:
+#line 2734 "glslang.y" /* yacc.c:1646  */
     {
         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 8347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8364 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 394:
-#line 2734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 395:
+#line 2740 "glslang.y" /* yacc.c:1646  */
     {
         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 8358 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8375 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 395:
-#line 2740 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 396:
+#line 2746 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdRect);
     }
-#line 8368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8385 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 396:
-#line 2745 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 397:
+#line 2751 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdRect);
     }
-#line 8378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8395 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 397:
-#line 2750 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 398:
+#line 2756 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
     }
-#line 8388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8405 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 398:
-#line 2755 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 399:
+#line 2761 "glslang.y" /* yacc.c:1646  */
     {
         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 8399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8416 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 399:
-#line 2761 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 400:
+#line 2767 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
     }
-#line 8409 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8426 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 400:
-#line 2766 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 401:
+#line 2772 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
     }
-#line 8419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8436 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 401:
-#line 2771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 402:
+#line 2777 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
     }
-#line 8429 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8446 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 402:
-#line 2776 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 403:
+#line 2782 "glslang.y" /* yacc.c:1646  */
     {
         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 8440 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8457 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 403:
-#line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 404:
+#line 2788 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
     }
-#line 8450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8467 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 404:
-#line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 405:
+#line 2793 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
     }
-#line 8460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8477 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 405:
-#line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 406:
+#line 2798 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
     }
-#line 8470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8487 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 406:
-#line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 407:
+#line 2803 "glslang.y" /* yacc.c:1646  */
     {
         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 8481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8498 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 407:
-#line 2803 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 408:
+#line 2809 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
     }
-#line 8491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8508 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 408:
-#line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 409:
+#line 2814 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
     }
-#line 8501 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8518 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 409:
-#line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 410:
+#line 2819 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
     }
-#line 8511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8528 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 410:
-#line 2818 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 411:
+#line 2824 "glslang.y" /* yacc.c:1646  */
     {
         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 8522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8539 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 411:
-#line 2824 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 412:
+#line 2830 "glslang.y" /* yacc.c:1646  */
     {
         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 8533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8550 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 412:
-#line 2830 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 413:
+#line 2836 "glslang.y" /* yacc.c:1646  */
     {
         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 8544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8561 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 413:
-#line 2836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 414:
+#line 2842 "glslang.y" /* yacc.c:1646  */
     {
         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 8555 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8572 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 414:
-#line 2842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 415:
+#line 2848 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
     }
-#line 8565 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8582 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 415:
-#line 2847 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 416:
+#line 2853 "glslang.y" /* yacc.c:1646  */
     {
         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 8576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8593 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 416:
-#line 2853 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 417:
+#line 2859 "glslang.y" /* yacc.c:1646  */
     {
         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 8587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8604 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 417:
-#line 2859 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 418:
+#line 2865 "glslang.y" /* yacc.c:1646  */
     {
         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 8598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8615 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 418:
-#line 2865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 419:
+#line 2871 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
     }
-#line 8608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8625 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 419:
-#line 2870 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 420:
+#line 2876 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
     }
-#line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8635 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 420:
-#line 2875 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 421:
+#line 2881 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
     }
-#line 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8645 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 421:
-#line 2880 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 422:
+#line 2886 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
     }
-#line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8655 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 422:
-#line 2885 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 423:
+#line 2891 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
     }
-#line 8648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8665 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 423:
-#line 2890 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 424:
+#line 2896 "glslang.y" /* yacc.c:1646  */
     {
         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 8659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8676 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 424:
-#line 2896 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 425:
+#line 2902 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
     }
-#line 8669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8686 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 425:
-#line 2901 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 426:
+#line 2907 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
     }
-#line 8679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8696 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 426:
-#line 2906 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 427:
+#line 2912 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
     }
-#line 8689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8706 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 427:
-#line 2911 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 428:
+#line 2917 "glslang.y" /* yacc.c:1646  */
     {
         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 8700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8717 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 428:
-#line 2917 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 429:
+#line 2923 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
     }
-#line 8710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8727 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 429:
-#line 2922 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 430:
+#line 2928 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
     }
-#line 8720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8737 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 430:
-#line 2927 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 431:
+#line 2933 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
     }
-#line 8730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8747 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 431:
-#line 2932 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 432:
+#line 2938 "glslang.y" /* yacc.c:1646  */
     {
         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 8741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8758 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 432:
-#line 2938 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 433:
+#line 2944 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
     }
-#line 8751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8768 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 433:
-#line 2943 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 434:
+#line 2949 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
     }
-#line 8761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8778 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 434:
-#line 2948 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 435:
+#line 2954 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
     }
-#line 8771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8788 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 435:
-#line 2953 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 436:
+#line 2959 "glslang.y" /* yacc.c:1646  */
     {
         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 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8799 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 436:
-#line 2959 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 437:
+#line 2965 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
     }
-#line 8792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8809 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 437:
-#line 2964 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 438:
+#line 2970 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
     }
-#line 8802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8819 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 438:
-#line 2969 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 439:
+#line 2975 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
     }
-#line 8812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8829 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 439:
-#line 2974 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 440:
+#line 2980 "glslang.y" /* yacc.c:1646  */
     {
         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 8823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8840 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 440:
-#line 2980 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 441:
+#line 2986 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
     }
-#line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8850 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 441:
-#line 2985 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 442:
+#line 2991 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
     }
-#line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8860 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 442:
-#line 2990 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 443:
+#line 2996 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
     }
-#line 8853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8870 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 443:
-#line 2995 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 444:
+#line 3001 "glslang.y" /* yacc.c:1646  */
     {
         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 8864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8881 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 444:
-#line 3001 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 445:
+#line 3007 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
     }
-#line 8874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8891 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 445:
-#line 3006 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 446:
+#line 3012 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
     }
-#line 8884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8901 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 446:
-#line 3011 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 447:
+#line 3017 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
     }
-#line 8894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8911 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 447:
-#line 3016 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 448:
+#line 3022 "glslang.y" /* yacc.c:1646  */
     {
         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 8905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8922 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 448:
-#line 3022 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 449:
+#line 3028 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
     }
-#line 8915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8932 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 449:
-#line 3027 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 450:
+#line 3033 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
     }
-#line 8925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8942 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 450:
-#line 3032 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 451:
+#line 3038 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
     }
-#line 8935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8952 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 451:
-#line 3037 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 452:
+#line 3043 "glslang.y" /* yacc.c:1646  */
     {
         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 8946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8963 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 452:
-#line 3043 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 453:
+#line 3049 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
     }
-#line 8956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8973 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 453:
-#line 3048 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 454:
+#line 3054 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
     }
-#line 8966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8983 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 454:
-#line 3053 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 455:
+#line 3059 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
     }
-#line 8976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 8993 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 455:
-#line 3058 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 456:
+#line 3064 "glslang.y" /* yacc.c:1646  */
     {
         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 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9004 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 456:
-#line 3064 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 457:
+#line 3070 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
     }
-#line 8997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9014 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 457:
-#line 3069 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 458:
+#line 3075 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
     }
-#line 9007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9024 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 458:
-#line 3074 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 459:
+#line 3080 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
     }
-#line 9017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9034 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 459:
-#line 3079 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 460:
+#line 3085 "glslang.y" /* yacc.c:1646  */
     {
         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 9028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9045 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 460:
-#line 3085 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 461:
+#line 3091 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
     }
-#line 9038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9055 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 461:
-#line 3090 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 462:
+#line 3096 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
     }
-#line 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9065 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 462:
-#line 3095 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 463:
+#line 3101 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
     }
-#line 9058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9075 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 463:
-#line 3100 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 464:
+#line 3106 "glslang.y" /* yacc.c:1646  */
     {
         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 9069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9086 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 464:
-#line 3106 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 465:
+#line 3112 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
     }
-#line 9079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9096 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 465:
-#line 3111 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 466:
+#line 3117 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
     }
-#line 9089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9106 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 466:
-#line 3116 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 467:
+#line 3122 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
     }
-#line 9099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9116 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 467:
-#line 3121 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 468:
+#line 3127 "glslang.y" /* yacc.c:1646  */
     {
         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 9110 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9127 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 468:
-#line 3127 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 469:
+#line 3133 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
     }
-#line 9120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9137 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 469:
-#line 3132 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 470:
+#line 3138 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
     }
-#line 9130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9147 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 470:
-#line 3137 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 471:
+#line 3143 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true);
     }
-#line 9140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9157 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 471:
-#line 3142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 472:
+#line 3148 "glslang.y" /* yacc.c:1646  */
     {
         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 9151 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9168 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 472:
-#line 3148 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 473:
+#line 3154 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
     }
-#line 9161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9178 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 473:
-#line 3153 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 474:
+#line 3159 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
     }
-#line 9171 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9188 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 474:
-#line 3158 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 475:
+#line 3164 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
     }
-#line 9181 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9198 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 475:
-#line 3163 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 476:
+#line 3169 "glslang.y" /* yacc.c:1646  */
     {
         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 9192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9209 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 476:
-#line 3169 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 477:
+#line 3175 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
     }
-#line 9202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9219 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 477:
-#line 3174 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 478:
+#line 3180 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
     }
-#line 9212 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9229 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 478:
-#line 3179 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 479:
+#line 3185 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
     }
-#line 9222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9239 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 479:
-#line 3184 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 480:
+#line 3190 "glslang.y" /* yacc.c:1646  */
     {
         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 9233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9250 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 480:
-#line 3190 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 481:
+#line 3196 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
     }
-#line 9243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9260 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 481:
-#line 3195 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 482:
+#line 3201 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
     }
-#line 9253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9270 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 482:
-#line 3200 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 483:
+#line 3206 "glslang.y" /* yacc.c:1646  */
     {  // GL_OES_EGL_image_external
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.external = true;
     }
-#line 9264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9281 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 483:
-#line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 484:
+#line 3212 "glslang.y" /* yacc.c:1646  */
     { // GL_EXT_YUV_target
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
         (yyval.interm.type).sampler.yuv = true;
     }
-#line 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9292 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 484:
-#line 3212 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 485:
+#line 3218 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat);
     }
-#line 9286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9303 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 485:
-#line 3218 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 486:
+#line 3224 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
     }
-#line 9297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9314 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 486:
-#line 3224 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 487:
+#line 3230 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -9305,11 +9322,11 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
     }
-#line 9309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9326 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 487:
-#line 3231 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 488:
+#line 3237 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
@@ -9317,98 +9334,98 @@ yyreduce:
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
     }
-#line 9321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9338 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 488:
-#line 3238 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 489:
+#line 3244 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt);
     }
-#line 9332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9349 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 489:
-#line 3244 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 490:
+#line 3250 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtInt, true);
     }
-#line 9343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9360 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 490:
-#line 3250 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 491:
+#line 3256 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint);
     }
-#line 9354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9371 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 491:
-#line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 492:
+#line 3262 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
         (yyval.interm.type).sampler.setSubpass(EbtUint, true);
     }
-#line 9365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9382 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 492:
-#line 3262 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 493:
+#line 3268 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
         (yyval.interm.type).coopmat = true;
     }
-#line 9376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9393 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 493:
-#line 3268 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 494:
+#line 3274 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
         (yyval.interm.type).coopmat = true;
     }
-#line 9387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9404 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 494:
-#line 3274 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 495:
+#line 3280 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel());
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtUint;
         (yyval.interm.type).coopmat = true;
     }
-#line 9398 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9415 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 495:
-#line 3281 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 496:
+#line 3287 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.type) = (yyvsp[0].interm.type);
         (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
     }
-#line 9408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9425 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 496:
-#line 3286 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 497:
+#line 3292 "glslang.y" /* yacc.c:1646  */
     {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -9422,47 +9439,47 @@ yyreduce:
         } else
             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
     }
-#line 9426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9443 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 497:
-#line 3302 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 498:
+#line 3308 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
     }
-#line 9436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9453 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 498:
-#line 3307 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 499:
+#line 3313 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
     }
-#line 9446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9463 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 499:
-#line 3312 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 500:
+#line 3318 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
     }
-#line 9456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9473 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 500:
-#line 3320 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 501:
+#line 3326 "glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
-#line 9462 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9479 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 501:
-#line 3320 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 502:
+#line 3326 "glslang.y" /* yacc.c:1646  */
     {
         TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
         parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
@@ -9474,17 +9491,17 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 9478 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9495 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 502:
-#line 3331 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 503:
+#line 3337 "glslang.y" /* yacc.c:1646  */
     { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
-#line 9484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9501 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 503:
-#line 3331 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 504:
+#line 3337 "glslang.y" /* yacc.c:1646  */
     {
         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[-4].lex).loc);
@@ -9492,19 +9509,19 @@ yyreduce:
         (yyval.interm.type).userDef = structure;
         --parseContext.structNestingLevel;
     }
-#line 9496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9513 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 504:
-#line 3341 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 505:
+#line 3347 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
     }
-#line 9504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9521 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 505:
-#line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 506:
+#line 3350 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
         for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
@@ -9515,11 +9532,11 @@ yyreduce:
             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
         }
     }
-#line 9519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9536 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 506:
-#line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 507:
+#line 3363 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -9542,11 +9559,11 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9563 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 507:
-#line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 508:
+#line 3385 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -9571,38 +9588,38 @@ yyreduce:
             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
         }
     }
-#line 9575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9592 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 508:
-#line 3406 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 509:
+#line 3412 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9601 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 509:
-#line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 510:
+#line 3416 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
     }
-#line 9592 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9609 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 510:
-#line 3416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 511:
+#line 3422 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.typeLine).type = new TType(EbtVoid);
         (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
     }
-#line 9602 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9619 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 511:
-#line 3421 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 512:
+#line 3427 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
 
@@ -9611,235 +9628,235 @@ yyreduce:
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
     }
-#line 9615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9632 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 512:
-#line 3432 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 513:
+#line 3438 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 9623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9640 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 513:
-#line 3436 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 514:
+#line 3442 "glslang.y" /* yacc.c:1646  */
     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
     }
-#line 9634 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9651 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 514:
-#line 3442 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 515:
+#line 3448 "glslang.y" /* yacc.c:1646  */
     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
         parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
         (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
     }
-#line 9645 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9662 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 515:
-#line 3453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 516:
+#line 3459 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
     }
-#line 9653 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9670 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 516:
-#line 3456 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 517:
+#line 3462 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
     }
-#line 9661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
-    break;
-
-  case 517:
-#line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
-    { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9667 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9678 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 518:
-#line 3467 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3469 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9684 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 519:
-#line 3468 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3473 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9690 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 520:
-#line 3474 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3474 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9685 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9696 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 521:
-#line 3475 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3480 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9702 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 522:
-#line 3476 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3481 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9708 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 523:
-#line 3477 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3482 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9714 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 524:
-#line 3478 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3483 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9720 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 525:
-#line 3479 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3484 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9726 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 526:
-#line 3480 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3485 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9732 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 527:
-#line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3486 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9738 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
   case 528:
-#line 3488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+#line 3488 "glslang.y" /* yacc.c:1646  */
+    { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
+#line 9744 "glslang_tab.cpp" /* yacc.c:1646  */
+    break;
+
+  case 529:
+#line 3494 "glslang.y" /* yacc.c:1646  */
     {
         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 9737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9754 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 529:
-#line 3497 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 530:
+#line 3503 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9760 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 530:
-#line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 531:
+#line 3504 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
-#line 9752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9769 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 531:
-#line 3502 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 532:
+#line 3508 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
-#line 9761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9778 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 532:
-#line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 533:
+#line 3512 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate())
             (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
     }
-#line 9771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9788 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 533:
-#line 3514 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 534:
+#line 3520 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9794 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 534:
-#line 3515 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 535:
+#line 3521 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
-#line 9783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9800 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 535:
-#line 3519 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 536:
+#line 3525 "glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9791 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9808 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 536:
-#line 3522 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 537:
+#line 3528 "glslang.y" /* yacc.c:1646  */
     {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9817 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 537:
-#line 3526 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 538:
+#line 3532 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 9810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9827 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 538:
-#line 3531 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 539:
+#line 3537 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9838 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 539:
-#line 3540 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 540:
+#line 3546 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9846 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 540:
-#line 3543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 541:
+#line 3549 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate())
             (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
         (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
     }
-#line 9839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9856 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 541:
-#line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 542:
+#line 3557 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
@@ -9848,11 +9865,11 @@ yyreduce:
             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
         }
     }
-#line 9852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9869 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 542:
-#line 3559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 543:
+#line 3565 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
@@ -9861,76 +9878,76 @@ yyreduce:
         } else
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
     }
-#line 9865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9882 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 543:
-#line 3570 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 544:
+#line 3576 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = 0; }
-#line 9871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9888 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 544:
-#line 3571 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 545:
+#line 3577 "glslang.y" /* yacc.c:1646  */
     { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
-#line 9877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9894 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 545:
-#line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 546:
+#line 3581 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9902 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 546:
-#line 3579 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 547:
+#line 3585 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9894 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9911 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 547:
-#line 3586 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 548:
+#line 3592 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
         (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
     }
-#line 9903 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9920 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 548:
-#line 3593 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 549:
+#line 3599 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
     }
-#line 9912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9929 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 549:
-#line 3597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 550:
+#line 3603 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 9921 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9938 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 550:
-#line 3605 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 551:
+#line 3611 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
         parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
     }
-#line 9930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9947 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 551:
-#line 3609 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 552:
+#line 3615 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
 
@@ -9941,28 +9958,28 @@ yyreduce:
         else
             (yyval.interm.intermTypedNode) = 0;
     }
-#line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9962 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 552:
-#line 3622 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 553:
+#line 3628 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9970 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 553:
-#line 3626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 554:
+#line 3632 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 9962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9979 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 554:
-#line 3633 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 555:
+#line 3639 "glslang.y" /* yacc.c:1646  */
     {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -9971,11 +9988,11 @@ yyreduce:
         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
         parseContext.symbolTable.push();
     }
-#line 9975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 9992 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 555:
-#line 3641 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 556:
+#line 3647 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
         delete parseContext.switchSequenceStack.back();
@@ -9985,27 +10002,27 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 9989 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10006 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 556:
-#line 3653 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 557:
+#line 3659 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
     }
-#line 9997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10014 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 557:
-#line 3656 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 558:
+#line 3662 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10022 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 558:
-#line 3662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 559:
+#line 3668 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -10018,11 +10035,11 @@ yyreduce:
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
         }
     }
-#line 10022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10039 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 559:
-#line 3674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 560:
+#line 3680 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -10032,28 +10049,28 @@ yyreduce:
         else
             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
     }
-#line 10036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10053 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 560:
-#line 3686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 561:
+#line 3692 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10061 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 561:
-#line 3690 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 562:
+#line 3696 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10070 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 562:
-#line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 563:
+#line 3703 "glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
@@ -10062,11 +10079,11 @@ yyreduce:
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10083 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 563:
-#line 3705 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 564:
+#line 3711 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc);
@@ -10074,21 +10091,21 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10095 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 564:
-#line 3712 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 565:
+#line 3718 "glslang.y" /* yacc.c:1646  */
     {
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10105 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 565:
-#line 3717 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 566:
+#line 3723 "glslang.y" /* yacc.c:1646  */
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
@@ -10100,22 +10117,22 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10104 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10121 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 566:
-#line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 567:
+#line 3734 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
         ++parseContext.controlFlowNestingLevel;
     }
-#line 10115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10132 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 567:
-#line 3734 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 568:
+#line 3740 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
@@ -10128,81 +10145,81 @@ yyreduce:
         --parseContext.statementNestingLevel;
         --parseContext.controlFlowNestingLevel;
     }
-#line 10132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10149 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 568:
-#line 3749 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 569:
+#line 3755 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10157 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 569:
-#line 3752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 570:
+#line 3758 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10165 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 570:
-#line 3758 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 571:
+#line 3764 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
     }
-#line 10156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10173 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 571:
-#line 3761 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 572:
+#line 3767 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermTypedNode) = 0;
     }
-#line 10164 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10181 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 572:
-#line 3767 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 573:
+#line 3773 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = 0;
     }
-#line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10190 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 573:
-#line 3771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 574:
+#line 3777 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
     }
-#line 10182 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10199 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 574:
-#line 3778 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 575:
+#line 3784 "glslang.y" /* yacc.c:1646  */
     {
         if (parseContext.loopNestingLevel <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
     }
-#line 10192 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10209 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 575:
-#line 3783 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 576:
+#line 3789 "glslang.y" /* yacc.c:1646  */
     {
         if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
             parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
     }
-#line 10202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10219 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 576:
-#line 3788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 577:
+#line 3794 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -10210,83 +10227,83 @@ yyreduce:
         if (parseContext.inMain)
             parseContext.postEntryPointReturn = true;
     }
-#line 10214 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10231 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 577:
-#line 3795 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 578:
+#line 3801 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 10222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10239 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 578:
-#line 3798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 579:
+#line 3804 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
     }
-#line 10231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10248 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 579:
-#line 3807 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 580:
+#line 3813 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
-#line 10240 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10257 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 580:
-#line 3811 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 581:
+#line 3817 "glslang.y" /* yacc.c:1646  */
     {
         if ((yyvsp[0].interm.intermNode) != nullptr) {
             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
             parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
         }
     }
-#line 10251 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10268 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 581:
-#line 3820 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 582:
+#line 3826 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10276 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 582:
-#line 3823 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 583:
+#line 3829 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
     }
-#line 10267 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10284 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 583:
-#line 3827 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 584:
+#line 3833 "glslang.y" /* yacc.c:1646  */
     {
         parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
         parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
         (yyval.interm.intermNode) = nullptr;
     }
-#line 10277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10294 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 584:
-#line 3836 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 585:
+#line 3842 "glslang.y" /* yacc.c:1646  */
     {
         (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
         (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
     }
-#line 10286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10303 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 585:
-#line 3840 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 586:
+#line 3846 "glslang.y" /* yacc.c:1646  */
     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -10302,52 +10319,52 @@ yyreduce:
         (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
         (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
     }
-#line 10306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10323 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 586:
-#line 3859 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 587:
+#line 3865 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
         parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute");
     }
-#line 10315 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10332 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 587:
-#line 3865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 588:
+#line 3871 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
     }
-#line 10323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10340 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 588:
-#line 3868 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 589:
+#line 3874 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
     }
-#line 10331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10348 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 589:
-#line 3873 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 590:
+#line 3879 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
     }
-#line 10339 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10356 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
-  case 590:
-#line 3876 "MachineIndependent/glslang.y" /* yacc.c:1646  */
+  case 591:
+#line 3882 "glslang.y" /* yacc.c:1646  */
     {
         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
     }
-#line 10347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10364 "glslang_tab.cpp" /* yacc.c:1646  */
     break;
 
 
-#line 10351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
+#line 10368 "glslang_tab.cpp" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -10575,5 +10592,6 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 3881 "MachineIndependent/glslang.y" /* yacc.c:1906  */
+#line 3887 "glslang.y" /* yacc.c:1906  */
+
 

diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
index 6f3dfb934baba464b175d7e113e3df1791edd44f..31c8f9024500ddf8b26e095aff34b8b3aafe6624 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -204,263 +204,264 @@ extern int yydebug;
     ATOMIC_UINT = 414,
     ACCSTRUCTNV = 415,
     ACCSTRUCTEXT = 416,
-    FCOOPMATNV = 417,
-    ICOOPMATNV = 418,
-    UCOOPMATNV = 419,
-    SAMPLERCUBEARRAY = 420,
-    SAMPLERCUBEARRAYSHADOW = 421,
-    ISAMPLERCUBEARRAY = 422,
-    USAMPLERCUBEARRAY = 423,
-    SAMPLER1D = 424,
-    SAMPLER1DARRAY = 425,
-    SAMPLER1DARRAYSHADOW = 426,
-    ISAMPLER1D = 427,
-    SAMPLER1DSHADOW = 428,
-    SAMPLER2DRECT = 429,
-    SAMPLER2DRECTSHADOW = 430,
-    ISAMPLER2DRECT = 431,
-    USAMPLER2DRECT = 432,
-    SAMPLERBUFFER = 433,
-    ISAMPLERBUFFER = 434,
-    USAMPLERBUFFER = 435,
-    SAMPLER2DMS = 436,
-    ISAMPLER2DMS = 437,
-    USAMPLER2DMS = 438,
-    SAMPLER2DMSARRAY = 439,
-    ISAMPLER2DMSARRAY = 440,
-    USAMPLER2DMSARRAY = 441,
-    SAMPLEREXTERNALOES = 442,
-    SAMPLEREXTERNAL2DY2YEXT = 443,
-    ISAMPLER1DARRAY = 444,
-    USAMPLER1D = 445,
-    USAMPLER1DARRAY = 446,
-    F16SAMPLER1D = 447,
-    F16SAMPLER2D = 448,
-    F16SAMPLER3D = 449,
-    F16SAMPLER2DRECT = 450,
-    F16SAMPLERCUBE = 451,
-    F16SAMPLER1DARRAY = 452,
-    F16SAMPLER2DARRAY = 453,
-    F16SAMPLERCUBEARRAY = 454,
-    F16SAMPLERBUFFER = 455,
-    F16SAMPLER2DMS = 456,
-    F16SAMPLER2DMSARRAY = 457,
-    F16SAMPLER1DSHADOW = 458,
-    F16SAMPLER2DSHADOW = 459,
-    F16SAMPLER1DARRAYSHADOW = 460,
-    F16SAMPLER2DARRAYSHADOW = 461,
-    F16SAMPLER2DRECTSHADOW = 462,
-    F16SAMPLERCUBESHADOW = 463,
-    F16SAMPLERCUBEARRAYSHADOW = 464,
-    IMAGE1D = 465,
-    IIMAGE1D = 466,
-    UIMAGE1D = 467,
-    IMAGE2D = 468,
-    IIMAGE2D = 469,
-    UIMAGE2D = 470,
-    IMAGE3D = 471,
-    IIMAGE3D = 472,
-    UIMAGE3D = 473,
-    IMAGE2DRECT = 474,
-    IIMAGE2DRECT = 475,
-    UIMAGE2DRECT = 476,
-    IMAGECUBE = 477,
-    IIMAGECUBE = 478,
-    UIMAGECUBE = 479,
-    IMAGEBUFFER = 480,
-    IIMAGEBUFFER = 481,
-    UIMAGEBUFFER = 482,
-    IMAGE1DARRAY = 483,
-    IIMAGE1DARRAY = 484,
-    UIMAGE1DARRAY = 485,
-    IMAGE2DARRAY = 486,
-    IIMAGE2DARRAY = 487,
-    UIMAGE2DARRAY = 488,
-    IMAGECUBEARRAY = 489,
-    IIMAGECUBEARRAY = 490,
-    UIMAGECUBEARRAY = 491,
-    IMAGE2DMS = 492,
-    IIMAGE2DMS = 493,
-    UIMAGE2DMS = 494,
-    IMAGE2DMSARRAY = 495,
-    IIMAGE2DMSARRAY = 496,
-    UIMAGE2DMSARRAY = 497,
-    F16IMAGE1D = 498,
-    F16IMAGE2D = 499,
-    F16IMAGE3D = 500,
-    F16IMAGE2DRECT = 501,
-    F16IMAGECUBE = 502,
-    F16IMAGE1DARRAY = 503,
-    F16IMAGE2DARRAY = 504,
-    F16IMAGECUBEARRAY = 505,
-    F16IMAGEBUFFER = 506,
-    F16IMAGE2DMS = 507,
-    F16IMAGE2DMSARRAY = 508,
-    TEXTURECUBEARRAY = 509,
-    ITEXTURECUBEARRAY = 510,
-    UTEXTURECUBEARRAY = 511,
-    TEXTURE1D = 512,
-    ITEXTURE1D = 513,
-    UTEXTURE1D = 514,
-    TEXTURE1DARRAY = 515,
-    ITEXTURE1DARRAY = 516,
-    UTEXTURE1DARRAY = 517,
-    TEXTURE2DRECT = 518,
-    ITEXTURE2DRECT = 519,
-    UTEXTURE2DRECT = 520,
-    TEXTUREBUFFER = 521,
-    ITEXTUREBUFFER = 522,
-    UTEXTUREBUFFER = 523,
-    TEXTURE2DMS = 524,
-    ITEXTURE2DMS = 525,
-    UTEXTURE2DMS = 526,
-    TEXTURE2DMSARRAY = 527,
-    ITEXTURE2DMSARRAY = 528,
-    UTEXTURE2DMSARRAY = 529,
-    F16TEXTURE1D = 530,
-    F16TEXTURE2D = 531,
-    F16TEXTURE3D = 532,
-    F16TEXTURE2DRECT = 533,
-    F16TEXTURECUBE = 534,
-    F16TEXTURE1DARRAY = 535,
-    F16TEXTURE2DARRAY = 536,
-    F16TEXTURECUBEARRAY = 537,
-    F16TEXTUREBUFFER = 538,
-    F16TEXTURE2DMS = 539,
-    F16TEXTURE2DMSARRAY = 540,
-    SUBPASSINPUT = 541,
-    SUBPASSINPUTMS = 542,
-    ISUBPASSINPUT = 543,
-    ISUBPASSINPUTMS = 544,
-    USUBPASSINPUT = 545,
-    USUBPASSINPUTMS = 546,
-    F16SUBPASSINPUT = 547,
-    F16SUBPASSINPUTMS = 548,
-    LEFT_OP = 549,
-    RIGHT_OP = 550,
-    INC_OP = 551,
-    DEC_OP = 552,
-    LE_OP = 553,
-    GE_OP = 554,
-    EQ_OP = 555,
-    NE_OP = 556,
-    AND_OP = 557,
-    OR_OP = 558,
-    XOR_OP = 559,
-    MUL_ASSIGN = 560,
-    DIV_ASSIGN = 561,
-    ADD_ASSIGN = 562,
-    MOD_ASSIGN = 563,
-    LEFT_ASSIGN = 564,
-    RIGHT_ASSIGN = 565,
-    AND_ASSIGN = 566,
-    XOR_ASSIGN = 567,
-    OR_ASSIGN = 568,
-    SUB_ASSIGN = 569,
-    STRING_LITERAL = 570,
-    LEFT_PAREN = 571,
-    RIGHT_PAREN = 572,
-    LEFT_BRACKET = 573,
-    RIGHT_BRACKET = 574,
-    LEFT_BRACE = 575,
-    RIGHT_BRACE = 576,
-    DOT = 577,
-    COMMA = 578,
-    COLON = 579,
-    EQUAL = 580,
-    SEMICOLON = 581,
-    BANG = 582,
-    DASH = 583,
-    TILDE = 584,
-    PLUS = 585,
-    STAR = 586,
-    SLASH = 587,
-    PERCENT = 588,
-    LEFT_ANGLE = 589,
-    RIGHT_ANGLE = 590,
-    VERTICAL_BAR = 591,
-    CARET = 592,
-    AMPERSAND = 593,
-    QUESTION = 594,
-    INVARIANT = 595,
-    HIGH_PRECISION = 596,
-    MEDIUM_PRECISION = 597,
-    LOW_PRECISION = 598,
-    PRECISION = 599,
-    PACKED = 600,
-    RESOURCE = 601,
-    SUPERP = 602,
-    FLOATCONSTANT = 603,
-    INTCONSTANT = 604,
-    UINTCONSTANT = 605,
-    BOOLCONSTANT = 606,
-    IDENTIFIER = 607,
-    TYPE_NAME = 608,
-    CENTROID = 609,
-    IN = 610,
-    OUT = 611,
-    INOUT = 612,
-    STRUCT = 613,
-    VOID = 614,
-    WHILE = 615,
-    BREAK = 616,
-    CONTINUE = 617,
-    DO = 618,
-    ELSE = 619,
-    FOR = 620,
-    IF = 621,
-    DISCARD = 622,
-    RETURN = 623,
-    SWITCH = 624,
-    CASE = 625,
-    DEFAULT = 626,
-    UNIFORM = 627,
-    SHARED = 628,
-    BUFFER = 629,
-    FLAT = 630,
-    SMOOTH = 631,
-    LAYOUT = 632,
-    DOUBLECONSTANT = 633,
-    INT16CONSTANT = 634,
-    UINT16CONSTANT = 635,
-    FLOAT16CONSTANT = 636,
-    INT32CONSTANT = 637,
-    UINT32CONSTANT = 638,
-    INT64CONSTANT = 639,
-    UINT64CONSTANT = 640,
-    SUBROUTINE = 641,
-    DEMOTE = 642,
-    PAYLOADNV = 643,
-    PAYLOADINNV = 644,
-    HITATTRNV = 645,
-    CALLDATANV = 646,
-    CALLDATAINNV = 647,
-    PAYLOADEXT = 648,
-    PAYLOADINEXT = 649,
-    HITATTREXT = 650,
-    CALLDATAEXT = 651,
-    CALLDATAINEXT = 652,
-    PATCH = 653,
-    SAMPLE = 654,
-    NONUNIFORM = 655,
-    COHERENT = 656,
-    VOLATILE = 657,
-    RESTRICT = 658,
-    READONLY = 659,
-    WRITEONLY = 660,
-    DEVICECOHERENT = 661,
-    QUEUEFAMILYCOHERENT = 662,
-    WORKGROUPCOHERENT = 663,
-    SUBGROUPCOHERENT = 664,
-    NONPRIVATE = 665,
-    SHADERCALLCOHERENT = 666,
-    NOPERSPECTIVE = 667,
-    EXPLICITINTERPAMD = 668,
-    PERVERTEXNV = 669,
-    PERPRIMITIVENV = 670,
-    PERVIEWNV = 671,
-    PERTASKNV = 672,
-    PRECISE = 673
+    RAYQUERYEXT = 417,
+    FCOOPMATNV = 418,
+    ICOOPMATNV = 419,
+    UCOOPMATNV = 420,
+    SAMPLERCUBEARRAY = 421,
+    SAMPLERCUBEARRAYSHADOW = 422,
+    ISAMPLERCUBEARRAY = 423,
+    USAMPLERCUBEARRAY = 424,
+    SAMPLER1D = 425,
+    SAMPLER1DARRAY = 426,
+    SAMPLER1DARRAYSHADOW = 427,
+    ISAMPLER1D = 428,
+    SAMPLER1DSHADOW = 429,
+    SAMPLER2DRECT = 430,
+    SAMPLER2DRECTSHADOW = 431,
+    ISAMPLER2DRECT = 432,
+    USAMPLER2DRECT = 433,
+    SAMPLERBUFFER = 434,
+    ISAMPLERBUFFER = 435,
+    USAMPLERBUFFER = 436,
+    SAMPLER2DMS = 437,
+    ISAMPLER2DMS = 438,
+    USAMPLER2DMS = 439,
+    SAMPLER2DMSARRAY = 440,
+    ISAMPLER2DMSARRAY = 441,
+    USAMPLER2DMSARRAY = 442,
+    SAMPLEREXTERNALOES = 443,
+    SAMPLEREXTERNAL2DY2YEXT = 444,
+    ISAMPLER1DARRAY = 445,
+    USAMPLER1D = 446,
+    USAMPLER1DARRAY = 447,
+    F16SAMPLER1D = 448,
+    F16SAMPLER2D = 449,
+    F16SAMPLER3D = 450,
+    F16SAMPLER2DRECT = 451,
+    F16SAMPLERCUBE = 452,
+    F16SAMPLER1DARRAY = 453,
+    F16SAMPLER2DARRAY = 454,
+    F16SAMPLERCUBEARRAY = 455,
+    F16SAMPLERBUFFER = 456,
+    F16SAMPLER2DMS = 457,
+    F16SAMPLER2DMSARRAY = 458,
+    F16SAMPLER1DSHADOW = 459,
+    F16SAMPLER2DSHADOW = 460,
+    F16SAMPLER1DARRAYSHADOW = 461,
+    F16SAMPLER2DARRAYSHADOW = 462,
+    F16SAMPLER2DRECTSHADOW = 463,
+    F16SAMPLERCUBESHADOW = 464,
+    F16SAMPLERCUBEARRAYSHADOW = 465,
+    IMAGE1D = 466,
+    IIMAGE1D = 467,
+    UIMAGE1D = 468,
+    IMAGE2D = 469,
+    IIMAGE2D = 470,
+    UIMAGE2D = 471,
+    IMAGE3D = 472,
+    IIMAGE3D = 473,
+    UIMAGE3D = 474,
+    IMAGE2DRECT = 475,
+    IIMAGE2DRECT = 476,
+    UIMAGE2DRECT = 477,
+    IMAGECUBE = 478,
+    IIMAGECUBE = 479,
+    UIMAGECUBE = 480,
+    IMAGEBUFFER = 481,
+    IIMAGEBUFFER = 482,
+    UIMAGEBUFFER = 483,
+    IMAGE1DARRAY = 484,
+    IIMAGE1DARRAY = 485,
+    UIMAGE1DARRAY = 486,
+    IMAGE2DARRAY = 487,
+    IIMAGE2DARRAY = 488,
+    UIMAGE2DARRAY = 489,
+    IMAGECUBEARRAY = 490,
+    IIMAGECUBEARRAY = 491,
+    UIMAGECUBEARRAY = 492,
+    IMAGE2DMS = 493,
+    IIMAGE2DMS = 494,
+    UIMAGE2DMS = 495,
+    IMAGE2DMSARRAY = 496,
+    IIMAGE2DMSARRAY = 497,
+    UIMAGE2DMSARRAY = 498,
+    F16IMAGE1D = 499,
+    F16IMAGE2D = 500,
+    F16IMAGE3D = 501,
+    F16IMAGE2DRECT = 502,
+    F16IMAGECUBE = 503,
+    F16IMAGE1DARRAY = 504,
+    F16IMAGE2DARRAY = 505,
+    F16IMAGECUBEARRAY = 506,
+    F16IMAGEBUFFER = 507,
+    F16IMAGE2DMS = 508,
+    F16IMAGE2DMSARRAY = 509,
+    TEXTURECUBEARRAY = 510,
+    ITEXTURECUBEARRAY = 511,
+    UTEXTURECUBEARRAY = 512,
+    TEXTURE1D = 513,
+    ITEXTURE1D = 514,
+    UTEXTURE1D = 515,
+    TEXTURE1DARRAY = 516,
+    ITEXTURE1DARRAY = 517,
+    UTEXTURE1DARRAY = 518,
+    TEXTURE2DRECT = 519,
+    ITEXTURE2DRECT = 520,
+    UTEXTURE2DRECT = 521,
+    TEXTUREBUFFER = 522,
+    ITEXTUREBUFFER = 523,
+    UTEXTUREBUFFER = 524,
+    TEXTURE2DMS = 525,
+    ITEXTURE2DMS = 526,
+    UTEXTURE2DMS = 527,
+    TEXTURE2DMSARRAY = 528,
+    ITEXTURE2DMSARRAY = 529,
+    UTEXTURE2DMSARRAY = 530,
+    F16TEXTURE1D = 531,
+    F16TEXTURE2D = 532,
+    F16TEXTURE3D = 533,
+    F16TEXTURE2DRECT = 534,
+    F16TEXTURECUBE = 535,
+    F16TEXTURE1DARRAY = 536,
+    F16TEXTURE2DARRAY = 537,
+    F16TEXTURECUBEARRAY = 538,
+    F16TEXTUREBUFFER = 539,
+    F16TEXTURE2DMS = 540,
+    F16TEXTURE2DMSARRAY = 541,
+    SUBPASSINPUT = 542,
+    SUBPASSINPUTMS = 543,
+    ISUBPASSINPUT = 544,
+    ISUBPASSINPUTMS = 545,
+    USUBPASSINPUT = 546,
+    USUBPASSINPUTMS = 547,
+    F16SUBPASSINPUT = 548,
+    F16SUBPASSINPUTMS = 549,
+    LEFT_OP = 550,
+    RIGHT_OP = 551,
+    INC_OP = 552,
+    DEC_OP = 553,
+    LE_OP = 554,
+    GE_OP = 555,
+    EQ_OP = 556,
+    NE_OP = 557,
+    AND_OP = 558,
+    OR_OP = 559,
+    XOR_OP = 560,
+    MUL_ASSIGN = 561,
+    DIV_ASSIGN = 562,
+    ADD_ASSIGN = 563,
+    MOD_ASSIGN = 564,
+    LEFT_ASSIGN = 565,
+    RIGHT_ASSIGN = 566,
+    AND_ASSIGN = 567,
+    XOR_ASSIGN = 568,
+    OR_ASSIGN = 569,
+    SUB_ASSIGN = 570,
+    STRING_LITERAL = 571,
+    LEFT_PAREN = 572,
+    RIGHT_PAREN = 573,
+    LEFT_BRACKET = 574,
+    RIGHT_BRACKET = 575,
+    LEFT_BRACE = 576,
+    RIGHT_BRACE = 577,
+    DOT = 578,
+    COMMA = 579,
+    COLON = 580,
+    EQUAL = 581,
+    SEMICOLON = 582,
+    BANG = 583,
+    DASH = 584,
+    TILDE = 585,
+    PLUS = 586,
+    STAR = 587,
+    SLASH = 588,
+    PERCENT = 589,
+    LEFT_ANGLE = 590,
+    RIGHT_ANGLE = 591,
+    VERTICAL_BAR = 592,
+    CARET = 593,
+    AMPERSAND = 594,
+    QUESTION = 595,
+    INVARIANT = 596,
+    HIGH_PRECISION = 597,
+    MEDIUM_PRECISION = 598,
+    LOW_PRECISION = 599,
+    PRECISION = 600,
+    PACKED = 601,
+    RESOURCE = 602,
+    SUPERP = 603,
+    FLOATCONSTANT = 604,
+    INTCONSTANT = 605,
+    UINTCONSTANT = 606,
+    BOOLCONSTANT = 607,
+    IDENTIFIER = 608,
+    TYPE_NAME = 609,
+    CENTROID = 610,
+    IN = 611,
+    OUT = 612,
+    INOUT = 613,
+    STRUCT = 614,
+    VOID = 615,
+    WHILE = 616,
+    BREAK = 617,
+    CONTINUE = 618,
+    DO = 619,
+    ELSE = 620,
+    FOR = 621,
+    IF = 622,
+    DISCARD = 623,
+    RETURN = 624,
+    SWITCH = 625,
+    CASE = 626,
+    DEFAULT = 627,
+    UNIFORM = 628,
+    SHARED = 629,
+    BUFFER = 630,
+    FLAT = 631,
+    SMOOTH = 632,
+    LAYOUT = 633,
+    DOUBLECONSTANT = 634,
+    INT16CONSTANT = 635,
+    UINT16CONSTANT = 636,
+    FLOAT16CONSTANT = 637,
+    INT32CONSTANT = 638,
+    UINT32CONSTANT = 639,
+    INT64CONSTANT = 640,
+    UINT64CONSTANT = 641,
+    SUBROUTINE = 642,
+    DEMOTE = 643,
+    PAYLOADNV = 644,
+    PAYLOADINNV = 645,
+    HITATTRNV = 646,
+    CALLDATANV = 647,
+    CALLDATAINNV = 648,
+    PAYLOADEXT = 649,
+    PAYLOADINEXT = 650,
+    HITATTREXT = 651,
+    CALLDATAEXT = 652,
+    CALLDATAINEXT = 653,
+    PATCH = 654,
+    SAMPLE = 655,
+    NONUNIFORM = 656,
+    COHERENT = 657,
+    VOLATILE = 658,
+    RESTRICT = 659,
+    READONLY = 660,
+    WRITEONLY = 661,
+    DEVICECOHERENT = 662,
+    QUEUEFAMILYCOHERENT = 663,
+    WORKGROUPCOHERENT = 664,
+    SUBGROUPCOHERENT = 665,
+    NONPRIVATE = 666,
+    SHADERCALLCOHERENT = 667,
+    NOPERSPECTIVE = 668,
+    EXPLICITINTERPAMD = 669,
+    PERVERTEXNV = 670,
+    PERPRIMITIVENV = 671,
+    PERVIEWNV = 672,
+    PERTASKNV = 673,
+    PRECISE = 674
   };
 #endif
 
@@ -469,7 +470,7 @@ extern int yydebug;
 
 union YYSTYPE
 {
-#line 96 "MachineIndependent/glslang.y" /* yacc.c:1909  */
+#line 97 "glslang.y" /* yacc.c:1909  */
 
     struct {
         glslang::TSourceLoc loc;
@@ -505,7 +506,7 @@ union YYSTYPE
         glslang::TArraySizes* typeParameters;
     } interm;
 
-#line 509 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
+#line 510 "glslang_tab.cpp.h" /* yacc.c:1909  */
 };
 
 typedef union YYSTYPE YYSTYPE;
@@ -517,4 +518,4 @@ typedef union YYSTYPE YYSTYPE;
 
 int yyparse (glslang::TParseContext* pParseContext);
 
-#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */

diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp
index 53dc35da8271acde1dca638c975c711e203f2696..c5417035b296f0b3f65400447a986fcf6c854f14 100644 (file)
--- a/glslang/MachineIndependent/intermOut.cpp
+++ b/glslang/MachineIndependent/intermOut.cpp
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -1085,6 +1086,30 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpExecuteCallable:                  out.debug << "executeCallableNV"; break;
     case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break;
 
+    case EOpRayQueryInitialize:                                            out.debug << "rayQueryInitializeEXT"; break;
+    case EOpRayQueryTerminate:                                             out.debug << "rayQueryTerminateEXT"; break;
+    case EOpRayQueryGenerateIntersection:                                  out.debug << "rayQueryGenerateIntersectionEXT"; break;
+    case EOpRayQueryConfirmIntersection:                                   out.debug << "rayQueryConfirmIntersectionEXT"; break;
+    case EOpRayQueryProceed:                                               out.debug << "rayQueryProceedEXT"; break;
+    case EOpRayQueryGetIntersectionType:                                   out.debug << "rayQueryGetIntersectionTypeEXT"; break;
+    case EOpRayQueryGetRayTMin:                                            out.debug << "rayQueryGetRayTMinEXT"; break;
+    case EOpRayQueryGetRayFlags:                                           out.debug << "rayQueryGetRayFlagsEXT"; break;
+    case EOpRayQueryGetIntersectionT:                                      out.debug << "rayQueryGetIntersectionTEXT"; break;
+    case EOpRayQueryGetIntersectionInstanceCustomIndex:                    out.debug << "rayQueryGetIntersectionInstanceCustomIndexEXT"; break;
+    case EOpRayQueryGetIntersectionInstanceId:                             out.debug << "rayQueryGetIntersectionInstanceIdEXT"; break;
+    case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: out.debug << "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT"; break;
+    case EOpRayQueryGetIntersectionGeometryIndex:                          out.debug << "rayQueryGetIntersectionGeometryIndexEXT"; break;
+    case EOpRayQueryGetIntersectionPrimitiveIndex:                         out.debug << "rayQueryGetIntersectionPrimitiveIndexEXT"; break;
+    case EOpRayQueryGetIntersectionBarycentrics:                           out.debug << "rayQueryGetIntersectionBarycentricsEXT"; break;
+    case EOpRayQueryGetIntersectionFrontFace:                              out.debug << "rayQueryGetIntersectionFrontFaceEXT"; break;
+    case EOpRayQueryGetIntersectionCandidateAABBOpaque:                    out.debug << "rayQueryGetIntersectionCandidateAABBOpaqueEXT"; break;
+    case EOpRayQueryGetIntersectionObjectRayDirection:                     out.debug << "rayQueryGetIntersectionObjectRayDirectionEXT"; break;
+    case EOpRayQueryGetIntersectionObjectRayOrigin:                        out.debug << "rayQueryGetIntersectionObjectRayOriginEXT"; break;
+    case EOpRayQueryGetWorldRayDirection:                                  out.debug << "rayQueryGetWorldRayDirectionEXT"; break;
+    case EOpRayQueryGetWorldRayOrigin:                                     out.debug << "rayQueryGetWorldRayOriginEXT"; break;
+    case EOpRayQueryGetIntersectionObjectToWorld:                          out.debug << "rayQueryGetIntersectionObjectToWorldEXT"; break;
+    case EOpRayQueryGetIntersectionWorldToObject:                          out.debug << "rayQueryGetIntersectionWorldToObjectEXT"; break;
+
     case EOpCooperativeMatrixLoad:  out.debug << "Load cooperative matrix";  break;
     case EOpCooperativeMatrixStore:  out.debug << "Store cooperative matrix";  break;
     case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices"; break;