diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h index 8a44b17a6c..fb73f25f8d 100644 --- a/SPIRV/GLSL.ext.KHR.h +++ b/SPIRV/GLSL.ext.KHR.h @@ -64,4 +64,6 @@ static const char* const E_SPV_KHR_expect_assume = "SPV_KHR_expec static const char* const E_SPV_EXT_replicated_composites = "SPV_EXT_replicated_composites"; static const char* const E_SPV_KHR_relaxed_extended_instruction = "SPV_KHR_relaxed_extended_instruction"; static const char* const E_SPV_KHR_integer_dot_product = "SPV_KHR_integer_dot_product"; +static const char* const E_SPV_NV_cooperative_vector = "SPV_NV_cooperative_vector"; + #endif // #ifndef GLSLextKHR_H diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp index 0fdec041f2..75f7dc6582 100644 --- a/SPIRV/GlslangToSpv.cpp +++ b/SPIRV/GlslangToSpv.cpp @@ -2572,6 +2572,9 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); length = builder.createCooperativeMatrixLengthNV(typeId); } + } else if (node->getOperand()->getType().isCoopVecNV()) { + spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType()); + length = builder.getCooperativeVectorNumComponents(typeId); } else { glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft(); block->traverse(this); @@ -3142,6 +3145,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructReference: case glslang::EOpConstructCooperativeMatrixNV: case glslang::EOpConstructCooperativeMatrixKHR: + case glslang::EOpConstructCooperativeVectorNV: { builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename()); std::vector arguments; @@ -3162,10 +3166,17 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt builder.addCapability(spv::CapabilityCooperativeMatrixConversionsNV); builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); constructed = builder.createCooperativeMatrixConversion(resultType(), arguments[0]); + } else if (node->getOp() == glslang::EOpConstructCooperativeVectorNV && + arguments.size() == 1 && + builder.getTypeId(arguments[0]) == resultType()) { + constructed = arguments[0]; } else if (node->getOp() == glslang::EOpConstructStruct || node->getOp() == glslang::EOpConstructCooperativeMatrixNV || node->getOp() == glslang::EOpConstructCooperativeMatrixKHR || - node->getType().isArray()) { + node->getType().isArray() || + // Handle constructing coopvec from one component here, to avoid the component + // getting smeared + (node->getOp() == glslang::EOpConstructCooperativeVectorNV && arguments.size() == 1 && builder.isScalar(arguments[0]))) { std::vector constituents; for (int c = 0; c < (int)arguments.size(); ++c) constituents.push_back(arguments[c]); @@ -3351,6 +3362,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpCooperativeMatrixReduceNV: case glslang::EOpCooperativeMatrixPerElementOpNV: case glslang::EOpCooperativeMatrixTransposeNV: + case glslang::EOpCooperativeVectorMatMulNV: + case glslang::EOpCooperativeVectorMatMulAddNV: + case glslang::EOpCooperativeVectorLoadNV: + case glslang::EOpCooperativeVectorStoreNV: + case glslang::EOpCooperativeVectorOuterProductAccumulateNV: + case glslang::EOpCooperativeVectorReduceSumAccumulateNV: noReturnValue = true; break; case glslang::EOpBeginInvocationInterlock: @@ -3598,12 +3615,30 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpCooperativeMatrixLoad: case glslang::EOpCooperativeMatrixLoadNV: case glslang::EOpCooperativeMatrixLoadTensorNV: + case glslang::EOpCooperativeVectorLoadNV: if (arg == 0 || arg == 1) lvalue = true; break; case glslang::EOpCooperativeMatrixStore: case glslang::EOpCooperativeMatrixStoreNV: case glslang::EOpCooperativeMatrixStoreTensorNV: + case glslang::EOpCooperativeVectorStoreNV: + if (arg == 1) + lvalue = true; + break; + case glslang::EOpCooperativeVectorMatMulNV: + if (arg == 0 || arg == 3) + lvalue = true; + break; + case glslang::EOpCooperativeVectorMatMulAddNV: + if (arg == 0 || arg == 3 || arg == 6) + lvalue = true; + break; + case glslang::EOpCooperativeVectorOuterProductAccumulateNV: + if (arg == 2) + lvalue = true; + break; + case glslang::EOpCooperativeVectorReduceSumAccumulateNV: if (arg == 1) lvalue = true; break; @@ -3635,39 +3670,51 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt else glslangOperands[arg]->traverse(this); - if (node->getOp() == glslang::EOpCooperativeMatrixLoad || - node->getOp() == glslang::EOpCooperativeMatrixStore || - node->getOp() == glslang::EOpCooperativeMatrixLoadNV || - node->getOp() == glslang::EOpCooperativeMatrixStoreNV || - node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV || - node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) { + bool isCoopMat = node->getOp() == glslang::EOpCooperativeMatrixLoad || + node->getOp() == glslang::EOpCooperativeMatrixStore || + node->getOp() == glslang::EOpCooperativeMatrixLoadNV || + node->getOp() == glslang::EOpCooperativeMatrixStoreNV || + node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV || + node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV; + bool isCoopVec = node->getOp() == glslang::EOpCooperativeVectorLoadNV || + node->getOp() == glslang::EOpCooperativeVectorStoreNV; + if (isCoopMat || isCoopVec) { if (arg == 1) { - // fold "element" parameter into the access chain - spv::Builder::AccessChain save = builder.getAccessChain(); - builder.clearAccessChain(); - glslangOperands[2]->traverse(this); - - spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType()); + spv::Builder::AccessChain::CoherentFlags coherentFlags {}; + unsigned int alignment {}; + if (isCoopMat) { + // fold "element" parameter into the access chain + spv::Builder::AccessChain save = builder.getAccessChain(); + builder.clearAccessChain(); + glslangOperands[2]->traverse(this); - builder.setAccessChain(save); + spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType()); - // Point to the first element of the array. - builder.accessChainPush(elementId, - TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()), - glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment()); + builder.setAccessChain(save); - spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags; - unsigned int alignment = builder.getAccessChain().alignment; + // Point to the first element of the array. + builder.accessChainPush(elementId, + TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()), + glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment()); + coherentFlags = builder.getAccessChain().coherentFlags; + alignment = builder.getAccessChain().alignment; + } else { + coherentFlags = builder.getAccessChain().coherentFlags; + coherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()); + alignment = 16; + } int memoryAccess = TranslateMemoryAccess(coherentFlags); if (node->getOp() == glslang::EOpCooperativeMatrixLoad || node->getOp() == glslang::EOpCooperativeMatrixLoadNV || - node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV) + node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV || + node->getOp() == glslang::EOpCooperativeVectorLoadNV) memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask; if (node->getOp() == glslang::EOpCooperativeMatrixStore || node->getOp() == glslang::EOpCooperativeMatrixStoreNV || - node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) + node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV || + node->getOp() == glslang::EOpCooperativeVectorStoreNV) memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask; if (builder.getStorageClass(builder.getAccessChain().base) == spv::StorageClassPhysicalStorageBufferEXT) { @@ -3685,7 +3732,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt memoryAccessOperands.push_back(spv::IdImmediate(true, builder.makeUintConstant(TranslateMemoryScope(coherentFlags)))); } - } else if (arg == 2) { + } else if (isCoopMat && arg == 2) { continue; } } @@ -3958,6 +4005,96 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt // store the result to the pointer builder.createStore(result, operands[0]); result = 0; + } else if (node->getOp() == glslang::EOpCooperativeVectorMatMulNV || + node->getOp() == glslang::EOpCooperativeVectorMatMulAddNV) { + uint32_t matrixOperands = 0; + + bool isMulAdd = node->getOp() == glslang::EOpCooperativeVectorMatMulAddNV; + + // Determine Cooperative Matrix Operands bits from the signedness of the types. + + if (isTypeSignedInt(glslangOperands[1]->getAsTyped()->getBasicType())) + matrixOperands |= spv::CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask; + if (isTypeSignedInt(glslangOperands[0]->getAsTyped()->getBasicType())) + matrixOperands |= spv::CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask; + + uint32_t opIdx = 1; + std::vector idImmOps; + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Input + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // InputInterpretation + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Matrix + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixOffset + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixInterpretation + if (isMulAdd) { + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Bias + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // BiasOffset + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // BiasInterpretation + } + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // M + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // K + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MemoryLayout + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Transpose + idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixStride + if (matrixOperands != 0) + idImmOps.push_back(spv::IdImmediate(false, matrixOperands)); // Cooperative Matrix Operands + + // get the pointee type + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeVectorType(typeId)); + // do the op + spv::Id result = builder.createOp(isMulAdd ? spv::OpCooperativeVectorMatrixMulAddNV : spv::OpCooperativeVectorMatrixMulNV, typeId, idImmOps); + // store the result to the pointer (out param 'res') + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeVectorLoadNV) { + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // offset + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); + // get the pointee type + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeVectorType(typeId)); + // do the op + spv::Id result = builder.createOp(spv::OpCooperativeVectorLoadNV, typeId, idImmOps); + // store the result to the pointer (out param 'v') + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeVectorStoreNV) { + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // offset + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); + builder.createNoResultOp(spv::OpCooperativeVectorStoreNV, idImmOps); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeVectorOuterProductAccumulateNV) { + builder.addCapability(spv::CapabilityCooperativeVectorTrainingNV); + builder.addExtension(spv::E_SPV_NV_cooperative_vector); + + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // Matrix + idImmOps.push_back(spv::IdImmediate(true, operands[3])); // Offset + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // A + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // B + idImmOps.push_back(spv::IdImmediate(true, operands[5])); // MemoryLayout + idImmOps.push_back(spv::IdImmediate(true, operands[6])); // MatrixInterpretation + idImmOps.push_back(spv::IdImmediate(true, operands[4])); // Stride + builder.createNoResultOp(spv::OpCooperativeVectorOuterProductAccumulateNV, idImmOps); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeVectorReduceSumAccumulateNV) { + builder.addCapability(spv::CapabilityCooperativeVectorTrainingNV); + builder.addExtension(spv::E_SPV_NV_cooperative_vector); + + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // Buf + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // Offset + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // A + builder.createNoResultOp(spv::OpCooperativeVectorReduceSumAccumulateNV, idImmOps); + result = 0; } else if (atomic) { // Handle all atomics glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore) @@ -4914,6 +5051,21 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty spvType = builder.makeCooperativeMatrixTypeKHR(spvType, scope, rows, cols, use); } + if (type.isCoopVecNV()) { + builder.addCapability(spv::CapabilityCooperativeVectorNV); + builder.addExtension(spv::E_SPV_NV_cooperative_vector); + + if (type.getBasicType() == glslang::EbtFloat16) + builder.addCapability(spv::CapabilityFloat16); + if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) { + builder.addCapability(spv::CapabilityInt8); + } + + spv::Id components = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0); + + spvType = builder.makeCooperativeVectorTypeNV(spvType, components); + } + if (type.isArray()) { int stride = 0; // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride @@ -6754,16 +6906,24 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD break; case glslang::EOpVectorTimesScalar: case glslang::EOpVectorTimesScalarAssign: - if (isFloat && (builder.isVector(left) || builder.isVector(right))) { - if (builder.isVector(right)) + if (isFloat && (builder.isVector(left) || builder.isVector(right) || builder.isCooperativeVector(left) || builder.isCooperativeVector(right))) { + if (builder.isVector(right) || builder.isCooperativeVector(right)) std::swap(left, right); assert(builder.isScalar(right)); needMatchingVectors = false; binOp = spv::OpVectorTimesScalar; - } else if (isFloat) + } else if (isFloat) { binOp = spv::OpFMul; - else + } else if (builder.isCooperativeVector(left) || builder.isCooperativeVector(right)) { + if (builder.isCooperativeVector(right)) + std::swap(left, right); + assert(builder.isScalar(right)); + // Construct a cooperative vector from the scalar + right = builder.createCompositeConstruct(builder.getTypeId(left), { right }); + binOp = spv::OpIMul; + } else { binOp = spv::OpIMul; + } break; case glslang::EOpVectorTimesMatrix: case glslang::EOpVectorTimesMatrixAssign: @@ -7681,7 +7841,9 @@ spv::Id TGlslangToSpvTraverser::createIntWidthConversion(spv::Id operand, int ve type = builder.makeUintType(width); } - if (vectorSize > 0) + if (builder.getOpCode(destType) == spv::OpTypeCooperativeVectorNV) { + type = builder.makeCooperativeVectorTypeNV(type, builder.getCooperativeVectorNumComponents(destType)); + } else if (vectorSize > 0) type = builder.makeVectorType(type, vectorSize); else if (builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixKHR || builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixNV) { @@ -10070,8 +10232,9 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla glslang::TVector::const_iterator iter; for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter) spvConsts.push_back(createSpvConstantFromConstUnionArray(*iter->type, consts, nextConst, false)); - } else if (glslangType.getVectorSize() > 1) { - for (unsigned int i = 0; i < (unsigned int)glslangType.getVectorSize(); ++i) { + } else if (glslangType.getVectorSize() > 1 || glslangType.isCoopVecNV()) { + unsigned int numComponents = glslangType.isCoopVecNV() ? glslangType.getTypeParameters()->arraySizes->getDimSize(0) : glslangType.getVectorSize(); + for (unsigned int i = 0; i < numComponents; ++i) { bool zero = nextConst >= consts.size(); switch (glslangType.getBasicType()) { case glslang::EbtInt: diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp index e23ccabe44..654f32e990 100644 --- a/SPIRV/SpvBuilder.cpp +++ b/SPIRV/SpvBuilder.cpp @@ -515,6 +515,28 @@ Id Builder::makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType) } } +Id Builder::makeCooperativeVectorTypeNV(Id componentType, Id components) +{ + // try to find it + Instruction* type; + for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeVectorNV].size(); ++t) { + type = groupedTypes[OpTypeCooperativeVectorNV][t]; + if (type->getIdOperand(0) == componentType && + type->getIdOperand(1) == components) + return type->getResultId(); + } + + // not found, make it + type = new Instruction(getUniqueId(), NoType, OpTypeCooperativeVectorNV); + type->addIdOperand(componentType); + type->addIdOperand(components); + groupedTypes[OpTypeCooperativeVectorNV].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + + return type->getResultId(); +} + Id Builder::makeGenericType(spv::Op opcode, std::vector& operands) { // try to find it @@ -1363,6 +1385,7 @@ unsigned int Builder::getNumTypeConstituents(Id typeId) const case OpTypeVector: case OpTypeMatrix: return instr->getImmediateOperand(1); + case OpTypeCooperativeVectorNV: case OpTypeArray: { Id lengthId = instr->getIdOperand(1); @@ -1401,6 +1424,7 @@ Id Builder::getScalarTypeId(Id typeId) const case OpTypeArray: case OpTypeRuntimeArray: case OpTypePointer: + case OpTypeCooperativeVectorNV: return getScalarTypeId(getContainedTypeId(typeId)); default: assert(0); @@ -1422,6 +1446,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const case OpTypeRuntimeArray: case OpTypeCooperativeMatrixKHR: case OpTypeCooperativeMatrixNV: + case OpTypeCooperativeVectorNV: return instr->getIdOperand(0); case OpTypePointer: return instr->getIdOperand(1); @@ -1804,7 +1829,7 @@ Id Builder::importNonSemanticShaderDebugInfoInstructions() return nonSemanticShaderDebugInfo; } -Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps) +Id Builder::findCompositeConstant(Op typeClass, Op opcode, Id typeId, const std::vector& comps, size_t numMembers) { Instruction* constant = nullptr; bool found = false; @@ -1814,6 +1839,13 @@ Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector if (constant->getTypeId() != typeId) continue; + if (constant->getOpCode() != opcode) { + continue; + } + + if (constant->getNumOperands() != (int)numMembers) + continue; + // same contents? bool mismatch = false; for (int op = 0; op < constant->getNumOperands(); ++op) { @@ -1863,7 +1895,7 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector& members, boo bool replicate = false; size_t numMembers = members.size(); - if (useReplicatedComposites) { + if (useReplicatedComposites || typeClass == OpTypeCooperativeVectorNV) { // use replicate if all members are the same replicate = numMembers > 0 && std::equal(members.begin() + 1, members.end(), members.begin()); @@ -1885,8 +1917,9 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector& members, boo case OpTypeMatrix: case OpTypeCooperativeMatrixKHR: case OpTypeCooperativeMatrixNV: + case OpTypeCooperativeVectorNV: if (! specConstant) { - Id existing = findCompositeConstant(typeClass, typeId, members); + Id existing = findCompositeConstant(typeClass, opcode, typeId, members, numMembers); if (existing) return existing; } @@ -3021,7 +3054,7 @@ Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType) assert(getTypeId(scalar) == getScalarTypeId(vectorType)); int numComponents = getNumTypeComponents(vectorType); - if (numComponents == 1) + if (numComponents == 1 && !isCooperativeVectorType(vectorType)) return scalar; Instruction* smear = nullptr; @@ -3038,7 +3071,7 @@ Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType) auto result_id = makeCompositeConstant(vectorType, members, isSpecConstant(scalar)); smear = module.getInstruction(result_id); } else { - bool replicate = useReplicatedComposites && (numComponents > 0); + bool replicate = (useReplicatedComposites || isCooperativeVectorType(vectorType)) && (numComponents > 0); if (replicate) { numComponents = 1; @@ -3425,7 +3458,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b Id Builder::createCompositeConstruct(Id typeId, const std::vector& constituents) { assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 && - getNumTypeConstituents(typeId) == constituents.size())); + getNumTypeConstituents(typeId) == constituents.size()) || + (isCooperativeVectorType(typeId) && constituents.size() == 1)); if (generatingOpCodeForSpecConst) { // Sometime, even in spec-constant-op mode, the constant composite to be @@ -3444,7 +3478,7 @@ Id Builder::createCompositeConstruct(Id typeId, const std::vector& constitue bool replicate = false; size_t numConstituents = constituents.size(); - if (useReplicatedComposites) { + if (useReplicatedComposites || isCooperativeVectorType(typeId)) { replicate = numConstituents > 0 && std::equal(constituents.begin() + 1, constituents.end(), constituents.begin()); } @@ -3510,7 +3544,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector& sourc // Special case: when calling a vector constructor with a single scalar // argument, smear the scalar - if (sources.size() == 1 && isScalar(sources[0]) && numTargetComponents > 1) + if (sources.size() == 1 && isScalar(sources[0]) && (numTargetComponents > 1 || isCooperativeVectorType(resultTypeId))) return smearScalar(precision, sources[0], resultTypeId); // Special case: 2 vectors of equal size @@ -3574,7 +3608,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector& sourc if (isScalar(sources[i]) || isPointer(sources[i])) latchResult(sources[i]); - else if (isVector(sources[i])) + else if (isVector(sources[i]) || isCooperativeVector(sources[i])) accumulateVectorConstituents(sources[i]); else if (isMatrix(sources[i])) accumulateMatrixConstituents(sources[i]); @@ -4021,6 +4055,9 @@ Id Builder::accessChainLoad(Decoration precision, Decoration l_nonUniform, if (constant) { id = createCompositeExtract(accessChain.base, swizzleBase, indexes); setPrecision(id, precision); + } else if (isCooperativeVector(accessChain.base)) { + assert(accessChain.indexChain.size() == 1); + id = createVectorExtractDynamic(accessChain.base, resultType, accessChain.indexChain[0]); } else { Id lValue = NoResult; if (spvVersion >= Spv_1_4 && isValidInitializer(accessChain.base)) { diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h index 44377acb2b..34fd93cae4 100644 --- a/SPIRV/SpvBuilder.h +++ b/SPIRV/SpvBuilder.h @@ -216,6 +216,7 @@ class Builder { Id makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id cols, Id use); Id makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols); Id makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType); + Id makeCooperativeVectorTypeNV(Id componentType, Id components); Id makeGenericType(spv::Op opcode, std::vector& operands); // SPIR-V NonSemantic Shader DebugInfo Instructions @@ -280,12 +281,14 @@ class Builder { { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); } Id getResultingAccessChainType() const; Id getIdOperand(Id resultId, int idx) { return module.getInstruction(resultId)->getIdOperand(idx); } + Id getCooperativeVectorNumComponents(Id typeId) const { return module.getInstruction(typeId)->getIdOperand(1); } bool isPointer(Id resultId) const { return isPointerType(getTypeId(resultId)); } bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); } bool isVector(Id resultId) const { return isVectorType(getTypeId(resultId)); } bool isMatrix(Id resultId) const { return isMatrixType(getTypeId(resultId)); } bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); } + bool isCooperativeVector(Id resultId)const { return isCooperativeVectorType(getTypeId(resultId)); } bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); } bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); } bool isTensorView(Id resultId)const { return isTensorViewType(getTypeId(resultId)); } @@ -310,6 +313,7 @@ class Builder { return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV; } bool isTensorViewType(Id typeId) const { return getTypeClass(typeId) == OpTypeTensorViewNV; } + bool isCooperativeVectorType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeVectorNV; } bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; } @@ -898,7 +902,7 @@ class Builder { protected: Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2); - Id findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps); + Id findCompositeConstant(Op typeClass, Op opcode, Id typeId, const std::vector& comps, size_t numMembers); Id findStructConstant(Id typeId, const std::vector& comps); Id collapseAccessChain(); void remapDynamicSwizzle(); diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp index 346a09f93e..c67aedbc72 100644 --- a/SPIRV/doc.cpp +++ b/SPIRV/doc.cpp @@ -1046,6 +1046,9 @@ const char* CapabilityString(int info) case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; + case CapabilityCooperativeVectorNV: return "CooperativeVectorNV"; + case CapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV"; + case CapabilityFragmentShaderSampleInterlockEXT: return "CapabilityFragmentShaderSampleInterlockEXT"; case CapabilityFragmentShaderPixelInterlockEXT: return "CapabilityFragmentShaderPixelInterlockEXT"; case CapabilityFragmentShaderShadingRateInterlockEXT: return "CapabilityFragmentShaderShadingRateInterlockEXT"; @@ -1579,6 +1582,14 @@ const char* OpcodeString(int op) case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV"; case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV"; + case OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV"; + case OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV"; + case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV"; + case OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV"; + case OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV"; + case OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV"; + case OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV"; + case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; @@ -1766,6 +1777,11 @@ void Parameterize() InstructionDesc[OpTypeTensorLayoutNV].setResultAndType(true, false); InstructionDesc[OpTypeTensorViewNV].setResultAndType(true, false); InstructionDesc[OpCooperativeMatrixStoreTensorNV].setResultAndType(false, false); + InstructionDesc[OpTypeCooperativeVectorNV].setResultAndType(true, false); + InstructionDesc[OpCooperativeVectorStoreNV].setResultAndType(false, false); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].setResultAndType(false, false); + InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].setResultAndType(false, false); + // Specific additional context-dependent operands ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <>'"); @@ -3272,6 +3288,61 @@ void Parameterize() InstructionDesc[OpCooperativeMatrixLengthKHR].operands.push(OperandId, "'Type'"); + InstructionDesc[OpTypeCooperativeVectorNV].operands.push(OperandId, "'Component Type'"); + InstructionDesc[OpTypeCooperativeVectorNV].operands.push(OperandId, "'Components'"); + + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Input'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'InputInterpretation'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Matrix'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixOffset'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixInterpretation'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'M'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'K'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MemoryLayout'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Transpose'"); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixStride'", true); + InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true); + + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Input'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'InputInterpretation'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Matrix'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixOffset'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixInterpretation'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Bias'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'BiasOffset'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'BiasInterpretation'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'M'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'K'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MemoryLayout'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Transpose'"); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixStride'", true); + InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true); + + InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "'Offset'"); + InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandLiteralNumber, "", true); + InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "", true); + + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Offset'"); + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Object'"); + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandLiteralNumber, "", true); + InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "", true); + + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'Offset'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'A'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'B'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MemoryLayout'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MatrixInterpretation'"); + InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MatrixStride'", true); + + InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'Offset'"); + InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'V'"); + InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false); InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'"); diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp index 0f28bb51c6..e0078abf17 100644 --- a/SPIRV/spirv.hpp +++ b/SPIRV/spirv.hpp @@ -1167,6 +1167,7 @@ enum Capability { CapabilityShaderInvocationReorderNV = 5383, CapabilityBindlessTextureNV = 5390, CapabilityRayQueryPositionFetchKHR = 5391, + CapabilityCooperativeVectorNV = 5394, CapabilityAtomicFloat16VectorNV = 5404, CapabilityRayTracingDisplacementMicromapNV = 5409, CapabilityRawAccessChainsNV = 5414, @@ -1175,6 +1176,7 @@ enum Capability { CapabilityCooperativeMatrixPerElementOperationsNV = 5432, CapabilityCooperativeMatrixTensorAddressingNV = 5433, CapabilityCooperativeMatrixBlockLoadsNV = 5434, + CapabilityCooperativeVectorTrainingNV = 5435, CapabilityTensorAddressingNV = 5439, CapabilitySubgroupShuffleINTEL = 5568, CapabilitySubgroupBufferBlockIOINTEL = 5569, @@ -1480,6 +1482,33 @@ enum FPEncoding { FPEncodingMax = 0x7fffffff, }; +enum CooperativeVectorMatrixLayout { + CooperativeVectorMatrixLayoutRowMajorNV = 0, + CooperativeVectorMatrixLayoutColumnMajorNV = 1, + CooperativeVectorMatrixLayoutInferencingOptimalNV = 2, + CooperativeVectorMatrixLayoutTrainingOptimalNV = 3, + CooperativeVectorMatrixLayoutMax = 0x7fffffff, +}; + +enum ComponentType { + ComponentTypeFloat16NV = 0, + ComponentTypeFloat32NV = 1, + ComponentTypeFloat64NV = 2, + ComponentTypeSignedInt8NV = 3, + ComponentTypeSignedInt16NV = 4, + ComponentTypeSignedInt32NV = 5, + ComponentTypeSignedInt64NV = 6, + ComponentTypeUnsignedInt8NV = 7, + ComponentTypeUnsignedInt16NV = 8, + ComponentTypeUnsignedInt32NV = 9, + ComponentTypeUnsignedInt64NV = 10, + ComponentTypeSignedInt8PackedNV = 1000491000, + ComponentTypeUnsignedInt8PackedNV = 1000491001, + ComponentTypeFloatE4M3NV = 1000491002, + ComponentTypeFloatE5M2NV = 1000491003, + ComponentTypeMax = 0x7fffffff, +}; + enum Op { OpNop = 0, OpUndef = 1, @@ -1940,6 +1969,11 @@ enum Op { OpReorderThreadWithHintNV = 5280, OpTypeHitObjectNV = 5281, OpImageSampleFootprintNV = 5283, + OpTypeCooperativeVectorNV = 5288, + OpCooperativeVectorMatrixMulNV = 5289, + OpCooperativeVectorOuterProductAccumulateNV = 5290, + OpCooperativeVectorReduceSumAccumulateNV = 5291, + OpCooperativeVectorMatrixMulAddNV = 5292, OpCooperativeMatrixConvertNV = 5293, OpEmitMeshTasksEXT = 5294, OpSetMeshOutputsEXT = 5295, @@ -1947,6 +1981,8 @@ enum Op { OpWritePackedPrimitiveIndices4x8NV = 5299, OpFetchMicroTriangleVertexPositionNV = 5300, OpFetchMicroTriangleVertexBarycentricNV = 5301, + OpCooperativeVectorLoadNV = 5302, + OpCooperativeVectorStoreNV = 5303, OpReportIntersectionKHR = 5334, OpReportIntersectionNV = 5334, OpIgnoreIntersectionNV = 5335, @@ -2715,6 +2751,11 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break; case OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break; case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; + case OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break; + case OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; case OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break; case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break; case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break; @@ -2722,6 +2763,8 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break; case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; @@ -3864,6 +3907,7 @@ inline const char* CapabilityToString(Capability value) { case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; case CapabilityBindlessTextureNV: return "BindlessTextureNV"; case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; + case CapabilityCooperativeVectorNV: return "CooperativeVectorNV"; case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; @@ -3872,6 +3916,7 @@ inline const char* CapabilityToString(Capability value) { case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV"; case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV"; case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV"; + case CapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV"; case CapabilityTensorAddressingNV: return "TensorAddressingNV"; case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; @@ -4104,6 +4149,37 @@ inline const char* FPEncodingToString(FPEncoding value) { } } +inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) { + switch (value) { + case CooperativeVectorMatrixLayoutRowMajorNV: return "RowMajorNV"; + case CooperativeVectorMatrixLayoutColumnMajorNV: return "ColumnMajorNV"; + case CooperativeVectorMatrixLayoutInferencingOptimalNV: return "InferencingOptimalNV"; + case CooperativeVectorMatrixLayoutTrainingOptimalNV: return "TrainingOptimalNV"; + default: return "Unknown"; + } +} + +inline const char* ComponentTypeToString(ComponentType value) { + switch (value) { + case ComponentTypeFloat16NV: return "Float16NV"; + case ComponentTypeFloat32NV: return "Float32NV"; + case ComponentTypeFloat64NV: return "Float64NV"; + case ComponentTypeSignedInt8NV: return "SignedInt8NV"; + case ComponentTypeSignedInt16NV: return "SignedInt16NV"; + case ComponentTypeSignedInt32NV: return "SignedInt32NV"; + case ComponentTypeSignedInt64NV: return "SignedInt64NV"; + case ComponentTypeUnsignedInt8NV: return "UnsignedInt8NV"; + case ComponentTypeUnsignedInt16NV: return "UnsignedInt16NV"; + case ComponentTypeUnsignedInt32NV: return "UnsignedInt32NV"; + case ComponentTypeUnsignedInt64NV: return "UnsignedInt64NV"; + case ComponentTypeSignedInt8PackedNV: return "SignedInt8PackedNV"; + case ComponentTypeUnsignedInt8PackedNV: return "UnsignedInt8PackedNV"; + case ComponentTypeFloatE4M3NV: return "FloatE4M3NV"; + case ComponentTypeFloatE5M2NV: return "FloatE5M2NV"; + default: return "Unknown"; + } +} + inline const char* OpToString(Op value) { switch (value) { case OpNop: return "OpNop"; @@ -4559,6 +4635,11 @@ inline const char* OpToString(Op value) { case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; + case OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV"; + case OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV"; + case OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV"; + case OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV"; + case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV"; case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV"; case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; @@ -4566,6 +4647,8 @@ inline const char* OpToString(Op value) { case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; + case OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV"; + case OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV"; case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; case OpTerminateRayNV: return "OpTerminateRayNV"; diff --git a/Test/baseResults/spv.coopmat.comp.out b/Test/baseResults/spv.coopmat.comp.out index b14ad59bd2..50e30519e9 100644 --- a/Test/baseResults/spv.coopmat.comp.out +++ b/Test/baseResults/spv.coopmat.comp.out @@ -24,9 +24,9 @@ spv.coopmat.comp SourceExtension "GL_KHR_memory_scope_semantics" SourceExtension "GL_NV_cooperative_matrix" Name 4 "main" - Name 14 "f16(f161;" + Name 14 "f16(f161<16><3><8><8>;" Name 13 "m" - Name 21 "f32(f1;" + Name 21 "f32(f1<32><3><8><8>;" Name 20 "m" Name 34 "m" Name 52 "m2" @@ -331,11 +331,11 @@ spv.coopmat.comp CooperativeMatrixStoreNV 164 163 74 76 MakePointerAvailableKHR NonPrivatePointerKHR 71 167: 10 Load 165(p1) Store 166(param) 167 - 168: 10 FunctionCall 14(f16(f161;) 166(param) + 168: 10 FunctionCall 14(f16(f161<16><3><8><8>;) 166(param) Store 165(p1) 168 171: 17 Load 169(p2) Store 170(param) 171 - 172: 17 FunctionCall 21(f32(f1;) 170(param) + 172: 17 FunctionCall 21(f32(f1<32><3><8><8>;) 170(param) Store 169(p2) 172 Store 165(p1) 173 Store 169(p2) 174 @@ -359,14 +359,14 @@ spv.coopmat.comp CooperativeMatrixStoreNV 197 196 190 76 MakePointerAvailableKHR NonPrivatePointerKHR 190 Return FunctionEnd - 14(f16(f161;): 10 Function None 12 +14(f16(f161<16><3><8><8>;): 10 Function None 12 13(m): 11(ptr) FunctionParameter 15: Label 23: 10 Load 13(m) 24: 10 FNegate 23 ReturnValue 24 FunctionEnd - 21(f32(f1;): 17 Function None 19 +21(f32(f1<32><3><8><8>;): 17 Function None 19 20(m): 18(ptr) FunctionParameter 22: Label 27: 17 Load 20(m) diff --git a/Test/baseResults/spv.coopmatKHR.comp.out b/Test/baseResults/spv.coopmatKHR.comp.out index 4d87d70a90..6b5c68b967 100644 --- a/Test/baseResults/spv.coopmatKHR.comp.out +++ b/Test/baseResults/spv.coopmatKHR.comp.out @@ -26,9 +26,9 @@ spv.coopmatKHR.comp SourceExtension "GL_KHR_cooperative_matrix" SourceExtension "GL_KHR_memory_scope_semantics" Name 4 "main" - Name 15 "f16(f161;" + Name 15 "f16(f161<3><8><8><2>;" Name 14 "m" - Name 22 "f32(f1;" + Name 22 "f32(f1<3><8><8><2>;" Name 21 "m" Name 35 "m" Name 53 "m2" @@ -343,11 +343,11 @@ spv.coopmatKHR.comp CooperativeMatrixStoreKHR 168 167 62 75 MakePointerAvailableKHR NonPrivatePointerKHR 72 171: 11 Load 169(p1) Store 170(param) 171 - 172: 11 FunctionCall 15(f16(f161;) 170(param) + 172: 11 FunctionCall 15(f16(f161<3><8><8><2>;) 170(param) Store 169(p1) 172 175: 18 Load 173(p2) Store 174(param) 175 - 176: 18 FunctionCall 22(f32(f1;) 174(param) + 176: 18 FunctionCall 22(f32(f1<3><8><8><2>;) 174(param) Store 173(p2) 176 Store 169(p1) 177 Store 173(p2) 178 @@ -386,14 +386,14 @@ spv.coopmatKHR.comp CooperativeMatrixStoreKHR 229 228 62 10 MakePointerAvailableKHR NonPrivatePointerKHR 10 Return FunctionEnd - 15(f16(f161;): 11 Function None 13 +15(f16(f161<3><8><8><2>;): 11 Function None 13 14(m): 12(ptr) FunctionParameter 16: Label 24: 11 Load 14(m) 25: 11 FNegate 24 ReturnValue 25 FunctionEnd - 22(f32(f1;): 18 Function None 20 +22(f32(f1<3><8><8><2>;): 18 Function None 20 21(m): 19(ptr) FunctionParameter 23: Label 28: 18 Load 21(m) diff --git a/Test/baseResults/spv.coopmat_armlayout.comp.out b/Test/baseResults/spv.coopmat_armlayout.comp.out index 8566f6ec5e..bc722fd780 100644 --- a/Test/baseResults/spv.coopmat_armlayout.comp.out +++ b/Test/baseResults/spv.coopmat_armlayout.comp.out @@ -28,9 +28,9 @@ spv.coopmat_armlayout.comp SourceExtension "GL_KHR_cooperative_matrix" SourceExtension "GL_KHR_memory_scope_semantics" Name 4 "main" - Name 15 "f16(f161;" + Name 15 "f16(f161<3><8><8><2>;" Name 14 "m" - Name 22 "f32(f1;" + Name 22 "f32(f1<3><8><8><2>;" Name 21 "m" Name 35 "m" Name 53 "m2" @@ -346,11 +346,11 @@ spv.coopmat_armlayout.comp CooperativeMatrixStoreKHR 169 168 76 75 MakePointerAvailableKHR NonPrivatePointerKHR 72 172: 11 Load 170(p1) Store 171(param) 172 - 173: 11 FunctionCall 15(f16(f161;) 171(param) + 173: 11 FunctionCall 15(f16(f161<3><8><8><2>;) 171(param) Store 170(p1) 173 176: 18 Load 174(p2) Store 175(param) 176 - 177: 18 FunctionCall 22(f32(f1;) 175(param) + 177: 18 FunctionCall 22(f32(f1<3><8><8><2>;) 175(param) Store 174(p2) 177 Store 170(p1) 178 Store 174(p2) 179 @@ -389,14 +389,14 @@ spv.coopmat_armlayout.comp CooperativeMatrixStoreKHR 230 229 76 10 MakePointerAvailableKHR NonPrivatePointerKHR 10 Return FunctionEnd - 15(f16(f161;): 11 Function None 13 +15(f16(f161<3><8><8><2>;): 11 Function None 13 14(m): 12(ptr) FunctionParameter 16: Label 24: 11 Load 14(m) 25: 11 FNegate 24 ReturnValue 25 FunctionEnd - 22(f32(f1;): 18 Function None 20 +22(f32(f1<3><8><8><2>;): 18 Function None 20 21(m): 19(ptr) FunctionParameter 23: Label 28: 18 Load 21(m) diff --git a/Test/baseResults/spv.coopvec.comp.out b/Test/baseResults/spv.coopvec.comp.out new file mode 100644 index 0000000000..9bc42993cf --- /dev/null +++ b/Test/baseResults/spv.coopvec.comp.out @@ -0,0 +1,383 @@ +spv.coopvec.comp +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 250 + + Capability Shader + Capability Float16 + Capability Int8 + Capability StorageUniformBufferBlock16 + Capability StorageBuffer8BitAccess + Capability VulkanMemoryModelKHR + Capability CooperativeVectorNV + Capability CapabilityReplicatedCompositesEXT + Extension "SPV_EXT_replicated_composites" + Extension "SPV_KHR_16bit_storage" + Extension "SPV_KHR_8bit_storage" + Extension "SPV_KHR_storage_buffer_storage_class" + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_vector" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_buffer_reference" + SourceExtension "GL_EXT_nonuniform_qualifier" + SourceExtension "GL_EXT_shader_explicit_arithmetic_types" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_vector" + Name 4 "main" + Name 13 "foo(coopvecf161<1>;" + Name 12 "x" + Name 20 "foo(coopvecf161<2>;" + Name 19 "x" + Name 26 "v" + Name 31 "x" + Name 34 "y" + Name 37 "v2" + Name 46 "v3" + Name 48 "x3" + Name 53 "y3" + Name 58 "v4" + Name 71 "v5" + Name 74 "v6" + Name 100 "f" + Name 108 "len" + Name 125 "tempArg" + Name 129 "v7" + Name 132 "MatrixBuf" + MemberName 132(MatrixBuf) 0 "matrixData" + Name 134 "matrixBuf" + Name 142 "v8" + Name 145 "matrixOffset" + Name 148 "tempArg" + Name 152 "v9" + Name 156 "MatrixBuf2" + MemberName 156(MatrixBuf2) 0 "matrixData" + Name 158 "matrixBuf2" + Name 165 "v10" + Name 167 "f162" + Name 171 "f161" + Name 173 "f16" + Name 179 "v11" + Name 181 "v12" + Name 192 "v13" + Name 207 "tempArg" + Name 214 "biasOffset" + Name 215 "tempArg" + Name 223 "tempArg" + Name 226 "v14" + Name 231 "matrixLayout" + Decorate 131 ArrayStride 2 + Decorate 132(MatrixBuf) Block + MemberDecorate 132(MatrixBuf) 0 Offset 0 + Decorate 134(matrixBuf) Binding 0 + Decorate 134(matrixBuf) DescriptorSet 0 + Decorate 155 ArrayStride 1 + Decorate 156(MatrixBuf2) Block + MemberDecorate 156(MatrixBuf2) 0 Offset 0 + Decorate 158(matrixBuf2) Binding 0 + Decorate 158(matrixBuf2) DescriptorSet 0 + Decorate 231(matrixLayout) SpecId 0 + Decorate 249 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 16 + 7: TypeInt 32 0 + 8: 7(int) Constant 1 + 9: TypeCooperativeVectorNV 6(float16_t) 8 + 10: TypePointer Function 9 + 11: TypeFunction 9 10(ptr) + 15: 7(int) Constant 2 + 16: TypeCooperativeVectorNV 6(float16_t) 15 + 17: TypePointer Function 16 + 18: TypeFunction 16 17(ptr) + 22: TypeFloat 32 + 23: 7(int) Constant 5 + 24: TypeCooperativeVectorNV 22(float) 23 + 25: TypePointer Function 24 + 27: 22(float) Constant 0 + 28: 24 ConstantCompositeReplicateEXT 27 + 29: TypeVector 22(float) 3 + 30: TypePointer Function 29(fvec3) + 32: 22(float) Constant 1065353216 + 33: 29(fvec3) ConstantComposite 32 32 32 + 35: 22(float) Constant 1073741824 + 36: 29(fvec3) ConstantComposite 35 35 35 + 47: 24 ConstantComposite 32 32 32 35 35 + 49: 22(float) Constant 1082130432 + 50: 22(float) Constant 1084227584 + 51: 22(float) Constant 1086324736 + 52: 29(fvec3) ConstantComposite 49 50 51 + 54: 22(float) Constant 1088421888 + 55: 22(float) Constant 1090519040 + 56: 22(float) Constant 1091567616 + 57: 29(fvec3) ConstantComposite 54 55 56 + 69: TypeCooperativeVectorNV 6(float16_t) 23 + 70: TypePointer Function 69 + 99: TypePointer Function 22(float) + 106: TypeInt 32 1 + 107: TypePointer Function 106(int) + 110: 106(int) Constant 0 + 113: 106(int) Constant 4 + 122: 7(int) Constant 100 + 123: TypeCooperativeVectorNV 22(float) 122 + 124: TypePointer Function 123 + 126: 7(int) Constant 20 + 127: TypeCooperativeVectorNV 22(float) 126 + 128: TypePointer Function 127 + 131: TypeRuntimeArray 6(float16_t) + 132(MatrixBuf): TypeStruct 131 + 133: TypePointer StorageBuffer 132(MatrixBuf) + 134(matrixBuf): 133(ptr) Variable StorageBuffer + 135: TypePointer StorageBuffer 131 + 137: 7(int) Constant 11 + 138: TypeBool + 139: 138(bool) ConstantFalse + 140: 7(int) Constant 300 + 144: TypePointer Function 7(int) + 146: TypeCooperativeVectorNV 106(int) 122 + 147: TypePointer Function 146 + 149: TypeInt 8 1 + 150: TypeCooperativeVectorNV 149(int8_t) 126 + 151: TypePointer Function 150 + 154: 106(int) Constant 3 + 155: TypeRuntimeArray 149(int8_t) + 156(MatrixBuf2): TypeStruct 155 + 157: TypePointer StorageBuffer 156(MatrixBuf2) + 158(matrixBuf2): 157(ptr) Variable StorageBuffer + 159: TypePointer StorageBuffer 155 + 162: 106(int) Constant 1 + 163: 138(bool) ConstantTrue + 172: TypePointer Function 6(float16_t) + 176: 7(int) Constant 7 + 177: TypeCooperativeVectorNV 6(float16_t) 176 + 178: TypePointer Function 177 + 211: 7(int) Constant 50 + 224: TypeCooperativeVectorNV 7(int) 126 + 225: TypePointer Function 224 + 228: 106(int) Constant 1000491000 +231(matrixLayout): 106(int) SpecConstant 1 + 247: TypeVector 7(int) 3 + 248: 7(int) Constant 64 + 249: 247(ivec3) ConstantComposite 248 8 8 + 4(main): 2 Function None 3 + 5: Label + 26(v): 25(ptr) Variable Function + 31(x): 30(ptr) Variable Function + 34(y): 30(ptr) Variable Function + 37(v2): 25(ptr) Variable Function + 46(v3): 25(ptr) Variable Function + 48(x3): 30(ptr) Variable Function + 53(y3): 30(ptr) Variable Function + 58(v4): 25(ptr) Variable Function + 71(v5): 70(ptr) Variable Function + 74(v6): 25(ptr) Variable Function + 100(f): 99(ptr) Variable Function + 108(len): 107(ptr) Variable Function + 125(tempArg): 124(ptr) Variable Function + 129(v7): 128(ptr) Variable Function + 142(v8): 124(ptr) Variable Function +145(matrixOffset): 144(ptr) Variable Function + 148(tempArg): 147(ptr) Variable Function + 152(v9): 151(ptr) Variable Function + 165(v10): 147(ptr) Variable Function + 167(f162): 17(ptr) Variable Function + 171(f161): 10(ptr) Variable Function + 173(f16): 172(ptr) Variable Function + 179(v11): 178(ptr) Variable Function + 181(v12): 178(ptr) Variable Function + 192(v13): 178(ptr) Variable Function + 207(tempArg): 124(ptr) Variable Function + 214(biasOffset): 144(ptr) Variable Function + 215(tempArg): 147(ptr) Variable Function + 223(tempArg): 147(ptr) Variable Function + 226(v14): 225(ptr) Variable Function + Store 26(v) 28 + Store 31(x) 33 + Store 34(y) 36 + 38: 29(fvec3) Load 31(x) + 39: 29(fvec3) Load 34(y) + 40: 22(float) CompositeExtract 38 0 + 41: 22(float) CompositeExtract 38 1 + 42: 22(float) CompositeExtract 38 2 + 43: 22(float) CompositeExtract 39 0 + 44: 22(float) CompositeExtract 39 1 + 45: 24 CompositeConstruct 40 41 42 43 44 + Store 37(v2) 45 + Store 46(v3) 47 + Store 48(x3) 52 + Store 53(y3) 57 + 59: 29(fvec3) Load 48(x3) + 60: 29(fvec3) VectorShuffle 59 59 2 1 0 + 61: 29(fvec3) Load 53(y3) + 62: 29(fvec3) VectorShuffle 61 61 2 2 1 + 63: 22(float) CompositeExtract 60 0 + 64: 22(float) CompositeExtract 60 1 + 65: 22(float) CompositeExtract 60 2 + 66: 22(float) CompositeExtract 62 0 + 67: 22(float) CompositeExtract 62 1 + 68: 24 CompositeConstruct 63 64 65 66 67 + Store 58(v4) 68 + 72: 24 Load 58(v4) + 73: 69 FConvert 72 + Store 71(v5) 73 + 75: 24 Load 26(v) + 76: 24 Load 37(v2) + 77: 24 FAdd 75 76 + Store 74(v6) 77 + 78: 24 Load 26(v) + 79: 24 Load 37(v2) + 80: 24 FSub 78 79 + Store 74(v6) 80 + 81: 24 Load 26(v) + 82: 24 Load 37(v2) + 83: 24 FMul 81 82 + Store 74(v6) 83 + 84: 24 Load 26(v) + 85: 24 Load 37(v2) + 86: 24 FDiv 84 85 + Store 74(v6) 86 + 87: 24 Load 26(v) + 88: 24 Load 74(v6) + 89: 24 FAdd 88 87 + Store 74(v6) 89 + 90: 24 Load 26(v) + 91: 24 Load 74(v6) + 92: 24 FSub 91 90 + Store 74(v6) 92 + 93: 24 Load 26(v) + 94: 24 Load 74(v6) + 95: 24 FMul 94 93 + Store 74(v6) 95 + 96: 24 Load 26(v) + 97: 24 Load 74(v6) + 98: 24 FDiv 97 96 + Store 74(v6) 98 + 101: 22(float) Load 100(f) + 102: 24 Load 74(v6) + 103: 24 VectorTimesScalar 102 101 + Store 74(v6) 103 + 104: 24 Load 74(v6) + 105: 24 VectorTimesScalar 104 50 + Store 74(v6) 105 + 109: 106(int) Bitcast 23 + Store 108(len) 109 + 111: 22(float) Load 100(f) + 112: 99(ptr) AccessChain 74(v6) 110 + Store 112 111 + 114: 99(ptr) AccessChain 74(v6) 113 + Store 114 50 + 115: 24 Load 26(v) + 116: 24 Load 26(v) + 117: 24 FAdd 116 115 + Store 26(v) 117 + 118: 22(float) CompositeExtract 117 4 + 119: 22(float) Load 100(f) + 120: 22(float) FAdd 119 118 + Store 100(f) 120 + 121: 24 Load 26(v) + Store 74(v6) 121 + 130: 127 Load 129(v7) + 136: 135(ptr) AccessChain 134(matrixBuf) 110 + 141: 123 CooperativeVectorMatrixMulNV 130 110 136 137 110 122 126 110 139 140 + Store 125(tempArg) 141 + 143: 123 Load 125(tempArg) + Store 142(v8) 143 + Store 145(matrixOffset) 137 + 153: 150 Load 152(v9) + 160: 159(ptr) AccessChain 158(matrixBuf2) 110 + 161: 7(int) Load 145(matrixOffset) + 164: 146 CooperativeVectorMatrixMulNV 153 154 160 161 154 122 126 162 163 140 BSignedComponentsKHR ResultSignedComponentsKHR + Store 148(tempArg) 164 + 166: 146 Load 148(tempArg) + Store 165(v10) 166 + 168: 106(int) Bitcast 126 + 169:6(float16_t) ConvertSToF 168 + 170: 16 CompositeConstructReplicateEXT 169 + Store 167(f162) 170 + 174:6(float16_t) Load 173(f16) + 175: 9 CompositeConstructReplicateEXT 174 + Store 171(f161) 175 + 180: 177 Load 179(v11) + 182: 177 Load 181(v12) + 183: 177 ExtInst 1(GLSL.std.450) 40(FMax) 180 182 + Store 179(v11) 183 + 184: 177 Load 179(v11) + 185: 177 Load 181(v12) + 186: 177 ExtInst 1(GLSL.std.450) 37(FMin) 184 185 + Store 179(v11) 186 + 187: 177 Load 179(v11) + 188: 177 Load 181(v12) + 189: 177 ExtInst 1(GLSL.std.450) 48(Step) 187 188 + Store 179(v11) 189 + 190: 177 Load 179(v11) + 191: 177 Load 181(v12) + 193: 177 Load 192(v13) + 194: 177 ExtInst 1(GLSL.std.450) 43(FClamp) 190 191 193 + Store 179(v11) 194 + 195: 177 Load 179(v11) + 196: 177 ExtInst 1(GLSL.std.450) 27(Exp) 195 + Store 179(v11) 196 + 197: 177 Load 179(v11) + 198: 177 ExtInst 1(GLSL.std.450) 28(Log) 197 + Store 179(v11) 198 + 199: 177 Load 179(v11) + 200: 177 ExtInst 1(GLSL.std.450) 21(Tanh) 199 + Store 179(v11) 200 + 201: 177 Load 179(v11) + 202: 177 ExtInst 1(GLSL.std.450) 18(Atan) 201 + Store 179(v11) 202 + 203: 177 Load 179(v11) + 204: 177 Load 181(v12) + 205: 177 Load 192(v13) + 206: 177 ExtInst 1(GLSL.std.450) 50(Fma) 203 204 205 + Store 179(v11) 206 + 208: 127 Load 129(v7) + 209: 135(ptr) AccessChain 134(matrixBuf) 110 + 210: 135(ptr) AccessChain 134(matrixBuf) 110 + 212: 123 CooperativeVectorMatrixMulAddNV 208 110 209 137 110 210 211 110 122 126 110 139 140 + Store 207(tempArg) 212 + 213: 123 Load 207(tempArg) + Store 142(v8) 213 + Store 214(biasOffset) 137 + 216: 150 Load 152(v9) + 217: 159(ptr) AccessChain 158(matrixBuf2) 110 + 218: 7(int) Load 145(matrixOffset) + 219: 159(ptr) AccessChain 158(matrixBuf2) 110 + 220: 7(int) Load 214(biasOffset) + 221: 146 CooperativeVectorMatrixMulAddNV 216 154 217 218 154 219 220 154 122 126 162 163 140 BSignedComponentsKHR ResultSignedComponentsKHR + Store 215(tempArg) 221 + 222: 146 Load 215(tempArg) + Store 165(v10) 222 + 227: 224 Load 226(v14) + 229: 159(ptr) AccessChain 158(matrixBuf2) 110 + 230: 7(int) Load 145(matrixOffset) + 232: 146 CooperativeVectorMatrixMulNV 227 228 229 230 154 122 126 231(matrixLayout) 163 140 ResultSignedComponentsKHR + Store 223(tempArg) 232 + 233: 146 Load 223(tempArg) + Store 165(v10) 233 + 234: 24 Load 26(v) + 235: 24 Load 26(v) + 236: 24 FAdd 235 234 + Store 26(v) 236 + 237: 106(int) Load 108(len) + 238: 22(float) VectorExtractDynamic 236 237 + 239: 22(float) Load 100(f) + 240: 22(float) FAdd 239 238 + Store 100(f) 240 + Return + FunctionEnd +13(foo(coopvecf161<1>;): 9 Function None 11 + 12(x): 10(ptr) FunctionParameter + 14: Label + 241: 9 Load 12(x) + ReturnValue 241 + FunctionEnd +20(foo(coopvecf161<2>;): 16 Function None 18 + 19(x): 17(ptr) FunctionParameter + 21: Label + 244: 16 Load 19(x) + ReturnValue 244 + FunctionEnd diff --git a/Test/baseResults/spv.coopvec2.comp.out b/Test/baseResults/spv.coopvec2.comp.out new file mode 100644 index 0000000000..e1f31976e6 --- /dev/null +++ b/Test/baseResults/spv.coopvec2.comp.out @@ -0,0 +1,196 @@ +spv.coopvec2.comp +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 122 + + Capability Shader + Capability Float16 + Capability Int8 + Capability VulkanMemoryModelKHR + Capability CooperativeVectorNV + Capability CapabilityReplicatedCompositesEXT + Extension "SPV_EXT_replicated_composites" + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_vector" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_buffer_reference" + SourceExtension "GL_EXT_nonuniform_qualifier" + SourceExtension "GL_EXT_shader_explicit_arithmetic_types" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_vector" + Name 4 "main" + Name 13 "foo(coopvecf1<4>;" + Name 12 "v" + Name 17 "f1" + Name 19 "f2" + Name 21 "f3" + Name 23 "N" + Name 26 "v" + Name 28 "v2" + Name 31 "v3" + Name 33 "v4" + Name 38 "v5" + Name 39 "v6" + Name 42 "v7" + Name 50 "v8" + Name 57 "v9" + Name 61 "v10" + Name 100 "v11" + Name 110 "v12" + Name 116 "v13" + Decorate 23(N) SpecId 0 + Decorate 121 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypeInt 32 0 + 8: 7(int) Constant 4 + 9: TypeCooperativeVectorNV 6(float) 8 + 10: TypePointer Function 9 + 11: TypeFunction 2 10(ptr) + 15: TypeFloat 16 + 16: TypePointer Function 15(float16_t) + 18:15(float16_t) Constant 15360 + 20:15(float16_t) Constant 16384 + 22:15(float16_t) Constant 16896 + 23(N): 7(int) SpecConstant 3 + 24: TypeCooperativeVectorNV 15(float16_t) 23(N) + 25: TypePointer Function 24 + 27: 24 ConstantCompositeReplicateEXT 18 + 32: 24 ConstantComposite 18 20 22 + 40: TypeCooperativeVectorNV 6(float) 23(N) + 41: TypePointer Function 40 + 43: 6(float) Constant 1065353216 + 44: 40 ConstantCompositeReplicateEXT 43 + 45: 6(float) Constant 1073741824 + 48: TypeCooperativeVectorNV 7(int) 23(N) + 49: TypePointer Function 48 + 51: 7(int) Constant 1 + 52: 48 ConstantCompositeReplicateEXT 51 + 53: 7(int) Constant 2 + 97: TypeInt 32 1 + 98: TypeCooperativeVectorNV 97(int) 51 + 99: TypePointer Function 98 + 102: TypeInt 8 0 + 103: TypeCooperativeVectorNV 102(int8_t) 51 + 104: TypeInt 8 1 + 105: TypeCooperativeVectorNV 104(int8_t) 51 + 108: TypeCooperativeVectorNV 97(int) 8 + 109: TypePointer Function 108 + 112: TypeCooperativeVectorNV 102(int8_t) 8 + 113: TypeCooperativeVectorNV 104(int8_t) 8 + 119: TypeVector 7(int) 3 + 120: 7(int) Constant 64 + 121: 119(ivec3) ConstantComposite 120 51 51 + 4(main): 2 Function None 3 + 5: Label + 17(f1): 16(ptr) Variable Function + 19(f2): 16(ptr) Variable Function + 21(f3): 16(ptr) Variable Function + 26(v): 25(ptr) Variable Function + 28(v2): 25(ptr) Variable Function + 31(v3): 25(ptr) Variable Function + 33(v4): 25(ptr) Variable Function + 38(v5): 25(ptr) Variable Function + 39(v6): 25(ptr) Variable Function + 42(v7): 41(ptr) Variable Function + 50(v8): 49(ptr) Variable Function + 57(v9): 49(ptr) Variable Function + 61(v10): 49(ptr) Variable Function + 100(v11): 99(ptr) Variable Function + 110(v12): 109(ptr) Variable Function + 116(v13): 10(ptr) Variable Function + Store 17(f1) 18 + Store 19(f2) 20 + Store 21(f3) 22 + Store 26(v) 27 + 29:15(float16_t) Load 19(f2) + 30: 24 CompositeConstructReplicateEXT 29 + Store 28(v2) 30 + Store 31(v3) 32 + 34:15(float16_t) Load 17(f1) + 35:15(float16_t) Load 19(f2) + 36:15(float16_t) Load 21(f3) + 37: 24 CompositeConstruct 34 35 36 + Store 33(v4) 37 + Store 38(v5) 27 + Store 39(v6) 32 + Store 42(v7) 44 + 46: 40 Load 42(v7) + 47: 40 VectorTimesScalar 46 45 + Store 42(v7) 47 + Store 50(v8) 52 + 54: 48 Load 50(v8) + 55: 48 CompositeConstructReplicateEXT 53 + 56: 48 IMul 54 55 + Store 50(v8) 56 + 58: 48 Load 50(v8) + 59: 48 CompositeConstructReplicateEXT 53 + 60: 48 IMul 58 59 + Store 57(v9) 60 + 62: 48 Load 50(v8) + 63: 48 CompositeConstructReplicateEXT 53 + 64: 48 IMul 62 63 + Store 61(v10) 64 + 65: 48 Load 50(v8) + 66: 48 Load 57(v9) + 67: 48 BitwiseAnd 65 66 + Store 50(v8) 67 + 68: 48 Load 50(v8) + 69: 48 Load 57(v9) + 70: 48 BitwiseOr 68 69 + Store 50(v8) 70 + 71: 48 Load 50(v8) + 72: 48 Load 57(v9) + 73: 48 Not 72 + 74: 48 BitwiseXor 71 73 + Store 50(v8) 74 + 75: 48 Load 50(v8) + 76: 48 Load 57(v9) + 77: 48 ShiftRightLogical 75 76 + Store 50(v8) 77 + 78: 48 Load 50(v8) + 79: 48 Load 57(v9) + 80: 48 ShiftLeftLogical 78 79 + Store 50(v8) 80 + 81: 48 Load 57(v9) + 82: 48 Load 50(v8) + 83: 48 BitwiseAnd 82 81 + Store 50(v8) 83 + 84: 48 Load 57(v9) + 85: 48 Load 50(v8) + 86: 48 BitwiseOr 85 84 + Store 50(v8) 86 + 87: 48 Load 57(v9) + 88: 48 Load 50(v8) + 89: 48 BitwiseXor 88 87 + Store 50(v8) 89 + 90: 48 Load 57(v9) + 91: 48 Load 50(v8) + 92: 48 ShiftRightLogical 91 90 + Store 50(v8) 92 + 93: 48 Load 57(v9) + 94: 48 Load 50(v8) + 95: 48 ShiftLeftLogical 94 93 + Store 50(v8) 95 + 96: 24 Load 26(v) + Store 26(v) 96 + 101: 98 Load 100(v11) + 106: 105 SConvert 101 + 107: 103 Bitcast 106 + 111: 108 Load 110(v12) + 114: 113 SConvert 111 + 115: 112 Bitcast 114 + 117: 9 Load 116(v13) + 118: 113 ConvertFToS 117 + Return + FunctionEnd +13(foo(coopvecf1<4>;): 2 Function None 11 + 12(v): 10(ptr) FunctionParameter + 14: Label + Return + FunctionEnd diff --git a/Test/baseResults/spv.coopvecTraining.comp.out b/Test/baseResults/spv.coopvecTraining.comp.out new file mode 100644 index 0000000000..47838b2de3 --- /dev/null +++ b/Test/baseResults/spv.coopvecTraining.comp.out @@ -0,0 +1,101 @@ +spv.coopvecTraining.comp +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 47 + + Capability Shader + Capability Float16 + Capability Int8 + Capability StorageUniformBufferBlock16 + Capability StorageBuffer8BitAccess + Capability VulkanMemoryModelKHR + Capability CooperativeVectorNV + Capability CooperativeVectorTrainingNV + Extension "SPV_KHR_16bit_storage" + Extension "SPV_KHR_8bit_storage" + Extension "SPV_KHR_storage_buffer_storage_class" + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_vector" + 1: ExtInstImport "GLSL.std.450" + MemoryModel Logical VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_buffer_reference" + SourceExtension "GL_EXT_nonuniform_qualifier" + SourceExtension "GL_EXT_shader_explicit_arithmetic_types" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_vector" + Name 4 "main" + Name 11 "v0" + Name 16 "v1" + Name 19 "MatrixBuf" + MemberName 19(MatrixBuf) 0 "matrixData" + Name 21 "matrixBuf" + Name 28 "matrixLayout" + Name 33 "MatrixBuf2" + MemberName 33(MatrixBuf2) 0 "matrixData" + Name 35 "matrixBuf2" + Decorate 18 ArrayStride 2 + Decorate 19(MatrixBuf) Block + MemberDecorate 19(MatrixBuf) 0 Offset 0 + Decorate 21(matrixBuf) Binding 0 + Decorate 21(matrixBuf) DescriptorSet 0 + Decorate 28(matrixLayout) SpecId 0 + Decorate 32 ArrayStride 1 + Decorate 33(MatrixBuf2) Block + MemberDecorate 33(MatrixBuf2) 0 Offset 0 + Decorate 35(matrixBuf2) Binding 0 + Decorate 35(matrixBuf2) DescriptorSet 0 + Decorate 46 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 16 + 7: TypeInt 32 0 + 8: 7(int) Constant 8 + 9: TypeCooperativeVectorNV 6(float16_t) 8 + 10: TypePointer Function 9 + 13: 7(int) Constant 5 + 14: TypeCooperativeVectorNV 6(float16_t) 13 + 15: TypePointer Function 14 + 18: TypeRuntimeArray 6(float16_t) + 19(MatrixBuf): TypeStruct 18 + 20: TypePointer StorageBuffer 19(MatrixBuf) + 21(matrixBuf): 20(ptr) Variable StorageBuffer + 22: TypeInt 32 1 + 23: 22(int) Constant 0 + 24: TypePointer StorageBuffer 18 + 26: 7(int) Constant 100 + 27: 7(int) Constant 128 +28(matrixLayout): 22(int) SpecConstant 2 + 31: TypeInt 8 1 + 32: TypeRuntimeArray 31(int8_t) + 33(MatrixBuf2): TypeStruct 32 + 34: TypePointer StorageBuffer 33(MatrixBuf2) + 35(matrixBuf2): 34(ptr) Variable StorageBuffer + 36: TypePointer StorageBuffer 32 + 38: 22(int) Constant 2 + 43: TypeVector 7(int) 3 + 44: 7(int) Constant 64 + 45: 7(int) Constant 1 + 46: 43(ivec3) ConstantComposite 44 45 45 + 4(main): 2 Function None 3 + 5: Label + 11(v0): 10(ptr) Variable Function + 16(v1): 15(ptr) Variable Function + 12: 9 Load 11(v0) + 17: 14 Load 16(v1) + 25: 24(ptr) AccessChain 21(matrixBuf) 23 + CooperativeVectorOuterProductAccumulateNV 25 26 12 17 28(matrixLayout) 23 27 + 29: 9 Load 11(v0) + 30: 14 Load 16(v1) + 37: 36(ptr) AccessChain 35(matrixBuf2) 23 + CooperativeVectorOuterProductAccumulateNV 37 26 29 30 38 23 27 + 39: 9 Load 11(v0) + 40: 24(ptr) AccessChain 21(matrixBuf) 23 + CooperativeVectorReduceSumAccumulateNV 40 26 39 + 41: 9 Load 11(v0) + 42: 36(ptr) AccessChain 35(matrixBuf2) 23 + CooperativeVectorReduceSumAccumulateNV 42 26 41 + Return + FunctionEnd diff --git a/Test/baseResults/spv.coopvecTraining_Error.comp.out b/Test/baseResults/spv.coopvecTraining_Error.comp.out new file mode 100644 index 0000000000..3fad407694 --- /dev/null +++ b/Test/baseResults/spv.coopvecTraining_Error.comp.out @@ -0,0 +1,8 @@ +spv.coopvecTraining_Error.comp +ERROR: 0:19: 'coopVecOuterProductAccumulateNV' : cooperative vector basic types must match +ERROR: 0:20: 'coopVecOuterProductAccumulateNV' : no matching overloaded function found +ERROR: 0:21: 'coopVecReduceSumAccumulateNV' : no matching overloaded function found +ERROR: 3 compilation errors. No code generated. + + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.coopvec_Error.comp.out b/Test/baseResults/spv.coopvec_Error.comp.out new file mode 100644 index 0000000000..ad79d2c7da --- /dev/null +++ b/Test/baseResults/spv.coopvec_Error.comp.out @@ -0,0 +1,18 @@ +spv.coopvec_Error.comp +ERROR: 0:25: 'inputInterpretation' : argument must be compile-time constant +ERROR: 0:25: 'matrixInterpretation' : argument must be compile-time constant +ERROR: 0:25: 'M' : argument must be compile-time constant +ERROR: 0:25: 'K' : argument must be compile-time constant +ERROR: 0:25: 'matrixLayout' : argument must be compile-time constant +ERROR: 0:25: 'transpose' : argument must be compile-time constant +ERROR: 0:28: 'x' : does not apply to this type: temp coopvecNV<5> float +ERROR: 0:29: '[' : cooperative vector index out of range '5' +ERROR: 0:31: 'v2' : expected two type parameters +ERROR: 0:32: 'v3' : expected positive number of components +ERROR: 0:33: '' : type parameter must be a non-negative integer +ERROR: 0:33: 'v4' : expected positive number of components +ERROR: 0:34: '' : syntax error, unexpected RIGHT_ANGLE, expecting LEFT_PAREN +ERROR: 13 compilation errors. No code generated. + + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.coopvecloadstore.comp.out b/Test/baseResults/spv.coopvecloadstore.comp.out new file mode 100644 index 0000000000..486bc6080b --- /dev/null +++ b/Test/baseResults/spv.coopvecloadstore.comp.out @@ -0,0 +1,162 @@ +spv.coopvecloadstore.comp +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 79 + + Capability Shader + Capability Float16 + Capability Int64 + Capability StorageUniformBufferBlock16 + Capability VulkanMemoryModelKHR + Capability PhysicalStorageBufferAddressesEXT + Capability CooperativeVectorNV + Extension "SPV_KHR_16bit_storage" + Extension "SPV_KHR_physical_storage_buffer" + Extension "SPV_KHR_storage_buffer_storage_class" + Extension "SPV_KHR_vulkan_memory_model" + Extension "SPV_NV_cooperative_vector" + 1: ExtInstImport "GLSL.std.450" + MemoryModel PhysicalStorageBuffer64EXT VulkanKHR + EntryPoint GLCompute 4 "main" + ExecutionMode 4 LocalSize 64 1 1 + Source GLSL 450 + SourceExtension "GL_EXT_buffer_reference" + SourceExtension "GL_EXT_nonuniform_qualifier" + SourceExtension "GL_EXT_shader_explicit_arithmetic_types" + SourceExtension "GL_KHR_memory_scope_semantics" + SourceExtension "GL_NV_cooperative_vector" + Name 4 "main" + Name 11 "tempArg" + Name 15 "MatrixBuf" + MemberName 15(MatrixBuf) 0 "matrixData" + Name 17 "matrixBuf" + Name 24 "v" + Name 29 "tempArg" + Name 32 "MatrixBuf2" + MemberName 32(MatrixBuf2) 0 "matrixData" + Name 34 "matrixBuf2" + Name 41 "tempArg" + Name 43 "MatrixBuf3" + MemberName 43(MatrixBuf3) 0 "matrixData" + Name 45 "matrixBuf3" + Name 52 "tempArg" + Name 55 "MatrixBuf4" + MemberName 55(MatrixBuf4) 0 "matrixData" + Name 57 "matrixBuf4" + Name 66 "tempArg" + Name 70 "matrixShmem" + Decorate 14 ArrayStride 32 + Decorate 15(MatrixBuf) Block + MemberDecorate 15(MatrixBuf) 0 Offset 0 + Decorate 17(matrixBuf) Binding 0 + Decorate 17(matrixBuf) DescriptorSet 0 + Decorate 31 ArrayStride 2 + Decorate 32(MatrixBuf2) Block + MemberDecorate 32(MatrixBuf2) 0 Offset 0 + Decorate 34(matrixBuf2) Binding 0 + Decorate 34(matrixBuf2) DescriptorSet 0 + Decorate 42 ArrayStride 4 + Decorate 43(MatrixBuf3) Block + MemberDecorate 43(MatrixBuf3) 0 Offset 0 + Decorate 45(matrixBuf3) Binding 0 + Decorate 45(matrixBuf3) DescriptorSet 0 + Decorate 54 ArrayStride 2 + Decorate 55(MatrixBuf4) Block + MemberDecorate 55(MatrixBuf4) 0 Offset 0 + Decorate 57(matrixBuf4) DecorationAliasedPointerEXT + Decorate 78 BuiltIn WorkgroupSize + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypeInt 32 0 + 8: 7(int) Constant 5 + 9: TypeCooperativeVectorNV 6(float) 8 + 10: TypePointer Function 9 + 12: TypeInt 64 0 + 13: TypeVector 12(int64_t) 3 + 14: TypeRuntimeArray 13(i64vec3) + 15(MatrixBuf): TypeStruct 14 + 16: TypePointer StorageBuffer 15(MatrixBuf) + 17(matrixBuf): 16(ptr) Variable StorageBuffer + 18: TypeInt 32 1 + 19: 18(int) Constant 0 + 20: TypePointer StorageBuffer 14 + 22: 7(int) Constant 128 + 28: 7(int) Constant 144 + 30: TypeFloat 16 + 31: TypeRuntimeArray 30(float16_t) + 32(MatrixBuf2): TypeStruct 31 + 33: TypePointer StorageBuffer 32(MatrixBuf2) + 34(matrixBuf2): 33(ptr) Variable StorageBuffer + 35: TypePointer StorageBuffer 31 + 42: TypeRuntimeArray 6(float) + 43(MatrixBuf3): TypeStruct 42 + 44: TypePointer StorageBuffer 43(MatrixBuf3) + 45(matrixBuf3): 44(ptr) Variable StorageBuffer + 46: TypePointer StorageBuffer 42 + TypeForwardPointer 53 PhysicalStorageBufferEXT + 54: TypeRuntimeArray 30(float16_t) + 55(MatrixBuf4): TypeStruct 54 + 53: TypePointer PhysicalStorageBufferEXT 55(MatrixBuf4) + 56: TypePointer Function 53(ptr) + 59: TypePointer PhysicalStorageBufferEXT 54 + 67: 7(int) Constant 100 + 68: TypeArray 7(int) 67 + 69: TypePointer Workgroup 68 + 70(matrixShmem): 69(ptr) Variable Workgroup + 71: 7(int) Constant 2 + 75: TypeVector 7(int) 3 + 76: 7(int) Constant 64 + 77: 7(int) Constant 1 + 78: 75(ivec3) ConstantComposite 76 77 77 + 4(main): 2 Function None 3 + 5: Label + 11(tempArg): 10(ptr) Variable Function + 24(v): 10(ptr) Variable Function + 29(tempArg): 10(ptr) Variable Function + 41(tempArg): 10(ptr) Variable Function + 52(tempArg): 10(ptr) Variable Function + 57(matrixBuf4): 56(ptr) Variable Function + 66(tempArg): 10(ptr) Variable Function + 21: 20(ptr) AccessChain 17(matrixBuf) 19 + 23: 9 CooperativeVectorLoadNV 21 22 None + Store 11(tempArg) 23 + 25: 9 Load 11(tempArg) + Store 24(v) 25 + 26: 9 Load 24(v) + 27: 20(ptr) AccessChain 17(matrixBuf) 19 + CooperativeVectorStoreNV 27 28 26 None + 36: 35(ptr) AccessChain 34(matrixBuf2) 19 + 37: 9 CooperativeVectorLoadNV 36 22 MakePointerVisibleKHR NonPrivatePointerKHR 8 + Store 29(tempArg) 37 + 38: 9 Load 29(tempArg) + Store 24(v) 38 + 39: 9 Load 24(v) + 40: 35(ptr) AccessChain 34(matrixBuf2) 19 + CooperativeVectorStoreNV 40 28 39 MakePointerAvailableKHR NonPrivatePointerKHR 8 + 47: 46(ptr) AccessChain 45(matrixBuf3) 19 + 48: 9 CooperativeVectorLoadNV 47 22 Volatile MakePointerVisibleKHR NonPrivatePointerKHR 8 + Store 41(tempArg) 48 + 49: 9 Load 41(tempArg) + Store 24(v) 49 + 50: 9 Load 24(v) + 51: 46(ptr) AccessChain 45(matrixBuf3) 19 + CooperativeVectorStoreNV 51 28 50 Volatile MakePointerAvailableKHR NonPrivatePointerKHR 8 + 58: 53(ptr) Load 57(matrixBuf4) + 60: 59(ptr) AccessChain 58 19 + 61: 9 CooperativeVectorLoadNV 60 22 Aligned MakePointerVisibleKHR NonPrivatePointerKHR 16 8 + Store 52(tempArg) 61 + 62: 9 Load 52(tempArg) + Store 24(v) 62 + 63: 9 Load 24(v) + 64: 53(ptr) Load 57(matrixBuf4) + 65: 59(ptr) AccessChain 64 19 + CooperativeVectorStoreNV 65 28 63 Aligned MakePointerAvailableKHR NonPrivatePointerKHR 16 8 + 72: 9 CooperativeVectorLoadNV 70(matrixShmem) 22 MakePointerVisibleKHR NonPrivatePointerKHR 71 + Store 66(tempArg) 72 + 73: 9 Load 66(tempArg) + Store 24(v) 73 + 74: 9 Load 24(v) + CooperativeVectorStoreNV 70(matrixShmem) 28 74 MakePointerAvailableKHR NonPrivatePointerKHR 71 + Return + FunctionEnd diff --git a/Test/baseResults/spv.intcoopmat.comp.out b/Test/baseResults/spv.intcoopmat.comp.out index 593880757c..dc62aa1b5c 100644 --- a/Test/baseResults/spv.intcoopmat.comp.out +++ b/Test/baseResults/spv.intcoopmat.comp.out @@ -27,9 +27,9 @@ spv.intcoopmat.comp SourceExtension "GL_NV_cooperative_matrix" SourceExtension "GL_NV_integer_cooperative_matrix" Name 4 "main" - Name 14 "ineg(i81;" + Name 14 "ineg(i81<8><3><8><8>;" Name 13 "m" - Name 21 "umul(u81;" + Name 21 "umul(u81<8><3><8><8>;" Name 20 "m" Name 35 "mu" Name 39 "mi" @@ -391,11 +391,11 @@ spv.intcoopmat.comp CooperativeMatrixStoreNV 187 186 91 93 MakePointerAvailableKHR NonPrivatePointerKHR 88 190: 10 Load 188(p1) Store 189(param) 190 - 191: 10 FunctionCall 14(ineg(i81;) 189(param) + 191: 10 FunctionCall 14(ineg(i81<8><3><8><8>;) 189(param) Store 188(p1) 191 194: 17 Load 192(p2) Store 193(param) 194 - 195: 17 FunctionCall 21(umul(u81;) 193(param) + 195: 17 FunctionCall 21(umul(u81<8><3><8><8>;) 193(param) Store 192(p2) 195 196: 10 Load 188(p1) 197: 10 Load 188(p1) @@ -439,14 +439,14 @@ spv.intcoopmat.comp CooperativeMatrixStoreNV 244 243 213 93 MakePointerAvailableKHR NonPrivatePointerKHR 213 Return FunctionEnd - 14(ineg(i81;): 10 Function None 12 +14(ineg(i81<8><3><8><8>;): 10 Function None 12 13(m): 11(ptr) FunctionParameter 15: Label 23: 10 Load 13(m) 24: 10 SNegate 23 ReturnValue 24 FunctionEnd - 21(umul(u81;): 17 Function None 19 +21(umul(u81<8><3><8><8>;): 17 Function None 19 20(m): 18(ptr) FunctionParameter 22: Label 27: 17 Load 20(m) diff --git a/Test/spv.coopvec.comp b/Test/spv.coopvec.comp new file mode 100644 index 0000000000..4b9645363d --- /dev/null +++ b/Test/spv.coopvec.comp @@ -0,0 +1,96 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable +#extension GL_EXT_nonuniform_qualifier : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(set = 0, binding = 0) buffer MatrixBuf { + float16_t matrixData[]; +} matrixBuf; + +layout(set = 0, binding = 0) buffer MatrixBuf2 { + int8_t matrixData[]; +} matrixBuf2; + +layout(constant_id = 0) const int matrixLayout = gl_CooperativeVectorMatrixLayoutColumnMajorNV; + +void main() +{ + coopvecNV v = coopvecNV(0.0); + + vec3 x = vec3(1.0), y = vec3(2.0); + coopvecNV v2 = coopvecNV(x, y); + + const vec3 x2 = vec3(1.0), y2 = vec3(2.0); + coopvecNV v3 = coopvecNV(x2, y2); + + vec3 x3 = vec3(4, 5, 6), y3 = vec3(7, 8, 9); + + coopvecNV v4 = coopvecNV(x3.zyx, y3.zzy); + + coopvecNV v5 = coopvecNV(v4); + + coopvecNV v6; + + v6 = v + v2; + v6 = v - v2; + v6 = v * v2; + v6 = v / v2; + + v6 += v; + v6 -= v; + v6 *= v; + v6 /= v; + + float f; + v6 *= f; + v6 *= 5.0; + + int len = v6.length(); + + v6[0] = f; + v6[4] = 5.0; + + f += (v += v)[4]; + v6 = v; + + coopvecNV v7; + coopvecNV v8; + coopVecMatMulNV(v8, v7, gl_ComponentTypeFloat16NV, matrixBuf.matrixData, 11, gl_ComponentTypeFloat16NV, 100, 20, gl_CooperativeVectorMatrixLayoutRowMajorNV, false, 300); + coopvecNV v9; + coopvecNV v10; + uint32_t matrixOffset = 11; + coopVecMatMulNV(v10, v9, gl_ComponentTypeSignedInt8NV, matrixBuf2.matrixData, matrixOffset, gl_ComponentTypeSignedInt8NV, 100, 20, gl_CooperativeVectorMatrixLayoutColumnMajorNV, true, 300); + + coopvecNV f162 = coopvecNV(v7.length()); + + float16_t f16; + coopvecNV f161 = coopvecNV(f16); + + coopvecNV v11, v12, v13; + + v11 = max(v11, v12); + v11 = min(v11, v12); + v11 = step(v11, v12); + v11 = clamp(v11, v12, v13); + v11 = exp(v11); + v11 = log(v11); + v11 = tanh(v11); + v11 = atan(v11); + v11 = fma(v11, v12, v13); + + coopVecMatMulAddNV(v8, v7, gl_ComponentTypeFloat16NV, matrixBuf.matrixData, 11, gl_ComponentTypeFloat16NV, matrixBuf.matrixData, 50, gl_ComponentTypeFloat16NV, 100, 20, gl_CooperativeVectorMatrixLayoutRowMajorNV, false, 300); + uint32_t biasOffset = 11; + coopVecMatMulAddNV(v10, v9, gl_ComponentTypeSignedInt8NV, matrixBuf2.matrixData, matrixOffset, gl_ComponentTypeSignedInt8NV, matrixBuf2.matrixData, biasOffset, gl_ComponentTypeSignedInt8NV, 100, 20, gl_CooperativeVectorMatrixLayoutColumnMajorNV, true, 300); + + coopvecNV v14; + coopVecMatMulNV(v10, v14, gl_ComponentTypeSignedInt8PackedNV, matrixBuf2.matrixData, matrixOffset, gl_ComponentTypeSignedInt8NV, 100, 20, matrixLayout, true, 300); + + f += (v += v)[len]; +} + +coopvecNV foo(coopvecNV x) { return x; } +coopvecNV foo(coopvecNV x) { return x; } diff --git a/Test/spv.coopvec2.comp b/Test/spv.coopvec2.comp new file mode 100644 index 0000000000..0ce3c4a762 --- /dev/null +++ b/Test/spv.coopvec2.comp @@ -0,0 +1,60 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable +#extension GL_EXT_nonuniform_qualifier : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(constant_id = 0) const uint N = 3; + +void main() +{ + float16_t f1 = float16_t(1.0); + float16_t f2 = float16_t(2.0); + float16_t f3 = float16_t(3.0); + + coopvecNV v = coopvecNV(1.0); + coopvecNV v2 = coopvecNV(f2); + coopvecNV v3 = coopvecNV(1.0, 2.0, 3.0); + coopvecNV v4 = coopvecNV(f1, f2, f3); + coopvecNV v5 = coopvecNV(1.0); + coopvecNV v6 = coopvecNV(1.0, 2.0, 3.0); + + coopvecNV v7 = coopvecNV(1); + v7 *= 2.0; + + coopvecNV v8 = coopvecNV(1); + v8 *= 2; + + coopvecNV v9 = v8 * 2; + coopvecNV v10 = 2 * v8; + + v8 = v8 & v9; + v8 = v8 | v9; + v8 = v8 ^ ~v9; + v8 = v8 >> v9; + v8 = v8 << v9; + + v8 &= v9; + v8 |= v9; + v8 ^= v9; + v8 >>= v9; + v8 <<= v9; + + v = coopvecNV(v); + + coopvecNV v11; + coopvecNV(v11); + + coopvecNV v12; + coopvecNV(v12); + + coopvecNV v13; + coopvecNV(v13); +} + +void foo(coopvecNV v) +{ +} diff --git a/Test/spv.coopvecTraining.comp b/Test/spv.coopvecTraining.comp new file mode 100644 index 0000000000..33a37020ba --- /dev/null +++ b/Test/spv.coopvecTraining.comp @@ -0,0 +1,30 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable +#extension GL_EXT_nonuniform_qualifier : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(set = 0, binding = 0) buffer MatrixBuf { + float16_t matrixData[]; +} matrixBuf; + +layout(set = 0, binding = 0) buffer MatrixBuf2 { + int8_t matrixData[]; +} matrixBuf2; + +layout(constant_id = 0) const int matrixLayout = gl_CooperativeVectorMatrixLayoutInferencingOptimalNV; + +void main() +{ + coopvecNV v0; + coopvecNV v1; + + coopVecOuterProductAccumulateNV(v0, v1, matrixBuf.matrixData, 100, 128, matrixLayout, gl_ComponentTypeFloat16NV); + coopVecOuterProductAccumulateNV(v0, v1, matrixBuf2.matrixData, 100, 128, gl_CooperativeVectorMatrixLayoutInferencingOptimalNV, gl_ComponentTypeFloat16NV); + + coopVecReduceSumAccumulateNV(v0, matrixBuf.matrixData, 100); + coopVecReduceSumAccumulateNV(v0, matrixBuf2.matrixData, 100); +} diff --git a/Test/spv.coopvecTraining_Error.comp b/Test/spv.coopvecTraining_Error.comp new file mode 100644 index 0000000000..0f7e782fcb --- /dev/null +++ b/Test/spv.coopvecTraining_Error.comp @@ -0,0 +1,22 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(set = 0, binding = 0) buffer MatrixBuf { + float16_t matrixData[]; +} matrixBuf; + +void main() +{ + coopvecNV v0; + coopvecNV v1; + vec4 v2; + + coopVecOuterProductAccumulateNV(v0, v1, matrixBuf.matrixData, 100, 128, gl_CooperativeVectorMatrixLayoutInferencingOptimalNV, gl_ComponentTypeFloat16NV); + coopVecOuterProductAccumulateNV(v0, v2, matrixBuf.matrixData, 100, 128, gl_CooperativeVectorMatrixLayoutInferencingOptimalNV, gl_ComponentTypeFloat16NV); + coopVecReduceSumAccumulateNV(v2, matrixBuf.matrixData, 100); +} diff --git a/Test/spv.coopvec_Error.comp b/Test/spv.coopvec_Error.comp new file mode 100644 index 0000000000..b18e527e63 --- /dev/null +++ b/Test/spv.coopvec_Error.comp @@ -0,0 +1,35 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +coopvecNV foo(coopvecNV x) { return x; } +coopvecNV foo2(coopvecNV x) { return -x; } + +layout(set = 0, binding = 0) buffer MatrixBuf { + float16_t matrixData[]; +} matrixBuf; + +void main() +{ + + uint M=1, K=1; + bool transpose = false; + int interp = gl_ComponentTypeFloat16NV; + int matrixlayout = 0; + coopvecNV v7; + coopvecNV v8; + coopVecMatMulNV(v8, v7, interp, matrixBuf.matrixData, 11, interp, M, K, matrixlayout, transpose, 300); + + coopvecNV v; + v.x; + v[5] = 0.0; + + coopvecNV v2; + coopvecNV v3; + coopvecNV v4; + coopvecNV v5; +} diff --git a/Test/spv.coopvecloadstore.comp b/Test/spv.coopvecloadstore.comp new file mode 100644 index 0000000000..383c036e9d --- /dev/null +++ b/Test/spv.coopvecloadstore.comp @@ -0,0 +1,50 @@ +#version 450 core +#extension GL_KHR_memory_scope_semantics : enable +#extension GL_NV_cooperative_vector : enable +#extension GL_EXT_shader_explicit_arithmetic_types : enable +#extension GL_EXT_buffer_reference : enable +#extension GL_EXT_nonuniform_qualifier : enable + +layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in; + +layout(set = 0, binding = 0) buffer MatrixBuf { + u64vec3 matrixData[]; +} matrixBuf; + +layout(set = 0, binding = 0) buffer MatrixBuf2 { + coherent float16_t matrixData[]; +} matrixBuf2; + +layout(set = 0, binding = 0) coherent buffer MatrixBuf3 { + volatile float32_t matrixData[]; +} matrixBuf3; + +layout(set = 0, binding = 0, buffer_reference) buffer MatrixBuf4 { + coherent float16_t matrixData[]; +}; + + +shared uint32_t matrixShmem[100]; + + +void main() +{ + coopvecNV v; + + coopVecLoadNV(v, matrixBuf.matrixData, 128); + coopVecStoreNV(v, matrixBuf.matrixData, 144); + + coopVecLoadNV(v, matrixBuf2.matrixData, 128); + coopVecStoreNV(v, matrixBuf2.matrixData, 144); + + coopVecLoadNV(v, matrixBuf3.matrixData, 128); + coopVecStoreNV(v, matrixBuf3.matrixData, 144); + + MatrixBuf4 matrixBuf4; + + coopVecLoadNV(v, matrixBuf4.matrixData, 128); + coopVecStoreNV(v, matrixBuf4.matrixData, 144); + + coopVecLoadNV(v, matrixShmem, 128); + coopVecStoreNV(v, matrixShmem, 144); +} diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index 8586707910..fd7af61709 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -70,6 +70,7 @@ enum TBasicType { EbtFunction, EbtTensorLayoutNV, EbtTensorViewNV, + EbtCoopvecNV, // SPIR-V type defined by spirv_type EbtSpirvType, diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h index 465fb4642b..4cc5ef6329 100644 --- a/glslang/Include/Types.h +++ b/glslang/Include/Types.h @@ -1460,6 +1460,7 @@ class TPublicType { uint32_t matrixRows : 4; bool coopmatNV : 1; bool coopmatKHR : 1; + bool coopvecNV : 1; TArraySizes* arraySizes; const TType* userDef; TSourceLoc loc; @@ -1470,6 +1471,8 @@ class TPublicType { bool isCoopmat() const { return coopmatNV || coopmatKHR; } bool isCoopmatNV() const { return coopmatNV; } bool isCoopmatKHR() const { return coopmatKHR; } + bool isCoopvecNV() const { return coopvecNV; } + bool isCoopmatOrvec() const { return isCoopmat() || isCoopvecNV(); } bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; } bool isTensorViewNV() const { return basicType == EbtTensorViewNV; } @@ -1486,6 +1489,7 @@ class TPublicType { typeParameters = nullptr; coopmatNV = false; coopmatKHR = false; + coopvecNV = false; spirvType = nullptr; } @@ -1545,7 +1549,7 @@ class TType { // for "empty" type (no args) or simple scalar/vector/matrix explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : - basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), + basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), spirvType(nullptr) { @@ -1561,7 +1565,7 @@ class TType { // for explicit precision qualifier TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : - basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), + basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), spirvType(nullptr) { @@ -1579,7 +1583,7 @@ class TType { // for turning a TPublicType into a TType, using a shallow copy explicit TType(const TPublicType& p) : basicType(p.basicType), - vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), + vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters), spirvType(p.spirvType) { @@ -1630,10 +1634,13 @@ class TType { coopmatKHRUseValid = true; } } + if (p.isCoopvecNV() && p.typeParameters) { + basicType = p.typeParameters->basicType; + } } // for construction of sampler types TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) : - basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), + basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr), sampler(sampler), typeParameters(nullptr), spirvType(nullptr) { @@ -1676,18 +1683,19 @@ class TType { // dereference from vector to scalar vectorSize = 1; vector1 = false; - } else if (isCoopMat()) { + } else if (isCoopMat() || isCoopVecNV()) { coopmatNV = false; coopmatKHR = false; coopmatKHRuse = 0; coopmatKHRUseValid = false; + coopvecNV = false; typeParameters = nullptr; } } } // for making structures, ... TType(TTypeList* userDef, const TString& n) : - basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), + basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), spirvType(nullptr) { @@ -1697,7 +1705,7 @@ class TType { } // For interface blocks TType(TTypeList* userDef, const TString& n, const TQualifier& q) : - basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), + basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), spirvType(nullptr) { @@ -1745,6 +1753,7 @@ class TType { coopmatKHR = copyOf.isCoopMatKHR(); coopmatKHRuse = copyOf.coopmatKHRuse; coopmatKHRUseValid = copyOf.coopmatKHRUseValid; + coopvecNV = copyOf.isCoopVecNV(); } // Make complete copy of the whole type graph rooted at 'copyOf'. @@ -1828,7 +1837,7 @@ class TType { virtual const TTypeParameters* getTypeParameters() const { return typeParameters; } virtual TTypeParameters* getTypeParameters() { return typeParameters; } - virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); } + virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray() && ! isCoopVecNV(); } virtual bool isScalarOrVec1() const { return isScalar() || vector1; } virtual bool isScalarOrVector() const { return !isMatrix() && !isStruct() && !isArray(); } virtual bool isVector() const { return vectorSize > 1u || vector1; } @@ -1879,6 +1888,8 @@ class TType { bool isCoopMat() const { return coopmatNV || coopmatKHR; } bool isCoopMatNV() const { return coopmatNV; } bool isCoopMatKHR() const { return coopmatKHR; } + bool isCoopVecNV() const { return coopvecNV; } + bool isCoopMatOrVec() const { return isCoopMat() || isCoopVecNV(); } bool isReference() const { return getBasicType() == EbtReference; } bool isSpirvType() const { return getBasicType() == EbtSpirvType; } int getCoopMatKHRuse() const { return static_cast(coopmatKHRuse); } @@ -1994,6 +2005,10 @@ class TType { { return contains([](const TType* t) { return t->coopmatNV || t->coopmatKHR; } ); } + bool containsCoopVec() const + { + return contains([](const TType* t) { return t->coopvecNV; } ); + } bool containsReference() const { return containsBasicType(EbtReference); @@ -2113,6 +2128,7 @@ class TType { case EbtCoopmat: return "coopmat"; case EbtTensorLayoutNV: return "tensorLayoutNV"; case EbtTensorViewNV: return "tensorViewNV"; + case EbtCoopvecNV: return "coopvecNV"; default: return "unknown type"; } } @@ -2431,6 +2447,10 @@ class TType { appendStr(" "); appendStr("tensorViewNV"); } + if (isCoopVecNV()) { + appendStr(" "); + appendStr("coopvecNV"); + } appendStr("<"); for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) { @@ -2512,7 +2532,9 @@ class TType { { uint32_t components = 0; - if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) { + if (isCoopVecNV()) { + components = typeParameters->arraySizes->getDimSize(0); + } else if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) { for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++) components += ((*tl).type)->computeNumComponents(); } else if (matrixCols) @@ -2716,6 +2738,7 @@ class TType { vector1 == right.vector1 && isCoopMatNV() == right.isCoopMatNV() && isCoopMatKHR() == right.isCoopMatKHR() && + isCoopVecNV() == right.isCoopVecNV() && sameStructType(right, lpidx, rpidx) && sameReferenceType(right); } @@ -2737,6 +2760,18 @@ class TType { return false; } + // See if a cooperative vector type parameter with unspecified parameters is + // an OK function parameter + bool coopVecParameterOK(const TType& right) const + { + if (isCoopVecNV() && right.isCoopVecNV()) { + return ((getBasicType() == right.getBasicType()) || (getBasicType() == EbtCoopvecNV) || + (right.getBasicType() == EbtCoopvecNV)) && + typeParameters == nullptr && right.typeParameters != nullptr; + } + return false; + } + bool sameCoopMatBaseType(const TType &right) const { bool rv = false; @@ -2774,6 +2809,22 @@ class TType { return false; } + bool sameCoopVecBaseType(const TType &right) const { + bool rv = false; + + if (isCoopVecNV() && right.isCoopVecNV()) { + if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16) + rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtCoopvecNV; + else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16) + rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopvecNV; + else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16) + rv = right.getBasicType() == EbtInt || right.getBasicType() == EbtInt8 || right.getBasicType() == EbtInt16 || right.getBasicType() == EbtCoopvecNV; + else + rv = false; + } + return rv; + } + bool sameCoopMatUse(const TType &right) const { return coopmatKHRuse == right.coopmatKHRuse; } @@ -2903,6 +2954,7 @@ class TType { bool coopmatKHR : 1; uint32_t coopmatKHRuse : 3; // Accepts one of three values: 0, 1, 2 (gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator) bool coopmatKHRUseValid : 1; // True if coopmatKHRuse has been set + bool coopvecNV : 1; TQualifier qualifier; TArraySizes* arraySizes; // nullptr unless an array; can be shared across types diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h index 1294a6d26a..e6cab0f1cf 100644 --- a/glslang/Include/intermediate.h +++ b/glslang/Include/intermediate.h @@ -472,6 +472,13 @@ enum TOperator { EOpTensorViewSetStrideNV, EOpTensorViewSetClipNV, + EOpCooperativeVectorMatMulNV, + EOpCooperativeVectorMatMulAddNV, + EOpCooperativeVectorLoadNV, + EOpCooperativeVectorStoreNV, + EOpCooperativeVectorOuterProductAccumulateNV, + EOpCooperativeVectorReduceSumAccumulateNV, + EOpBeginInvocationInterlock, // Fragment only EOpEndInvocationInterlock, // Fragment only @@ -610,6 +617,7 @@ enum TOperator { EOpConstructReference, EOpConstructCooperativeMatrixNV, EOpConstructCooperativeMatrixKHR, + EOpConstructCooperativeVectorNV, EOpConstructAccStruct, EOpConstructGuardEnd, diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp index 0fc75d885d..a3d37f390e 100644 --- a/glslang/MachineIndependent/Initialize.cpp +++ b/glslang/MachineIndependent/Initialize.cpp @@ -4737,6 +4737,161 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV ); } + if (profile != EEsProfile && version >= 450) { + const char *basicTypes[] = { + "int8_t", + "int16_t", + "int32_t", + "int64_t", + "uint8_t", + "uint16_t", + "uint32_t", + "uint64_t", + "float16_t", + "float32_t", + "float64_t", + }; + for (uint32_t i = 0; i < sizeof(basicTypes)/sizeof(basicTypes[0]); ++i) { + std::string func = std::string("void coopVecMatMulNV(out coopvecNV result, ") + + std::string("coopvecNV v, ") + + std::string("int inputInterpretation, ") + + std::string(basicTypes[i]) + std::string("[] matrix, ") + + std::string("uint matrixOffset, ") + + std::string("int matrixInterpretation, ") + + std::string("uint M, ") + + std::string("uint K, ") + + std::string("int matrixLayout, ") + + std::string("bool transpose, ") + + std::string("uint matrixStride);\n"); + commonBuiltins.append(func.c_str()); + + for (uint32_t j = 0; j < sizeof(basicTypes)/sizeof(basicTypes[0]); ++j) { + func = std::string("void coopVecMatMulAddNV(out coopvecNV result, ") + + std::string("coopvecNV v, ") + + std::string("int inputInterpretation, ") + + std::string(basicTypes[i]) + std::string("[] matrix, ") + + std::string("uint matrixOffset, ") + + std::string("int matrixInterpretation, ") + + std::string(basicTypes[j]) + std::string("[] bias, ") + + std::string("uint biasOffset, ") + + std::string("int biasInterpretation, ") + + std::string("uint M, ") + + std::string("uint K, ") + + std::string("int matrixLayout, ") + + std::string("bool transpose, ") + + std::string("uint matrixStride);\n"); + commonBuiltins.append(func.c_str()); + } + + func = std::string("void coopVecOuterProductAccumulateNV(coopvecNV v1, coopvecNV v2, ") + + std::string(basicTypes[i]) + + std::string("[] buf, uint offset, uint stride, int matrixLayout, int matrixInterpretation);\n"); + commonBuiltins.append(func.c_str()); + + func = std::string("void coopVecReduceSumAccumulateNV(coopvecNV v, ") + + std::string(basicTypes[i]) + + std::string("[] buf, uint offset);\n"); + commonBuiltins.append(func.c_str()); + } + + std::string cooperativeVectorFuncs = + "coopvecNV fma(coopvecNV, coopvecNV, coopvecNV);\n" + "coopvecNV min(coopvecNV, coopvecNV);\n" + "coopvecNV max(coopvecNV, coopvecNV);\n" + "coopvecNV step(coopvecNV, coopvecNV);\n" + "coopvecNV exp(coopvecNV);\n" + "coopvecNV log(coopvecNV);\n" + "coopvecNV tanh(coopvecNV);\n" + "coopvecNV atan(coopvecNV);\n" + "coopvecNV clamp(coopvecNV, coopvecNV, coopvecNV);\n" + "\n" + ; + + commonBuiltins.append(cooperativeVectorFuncs.c_str()); + + const char *scalarAndVectorTypes[] = { + "int8_t", + "int16_t", + "int32_t", + "int64_t", + "uint8_t", + "uint16_t", + "uint32_t", + "uint64_t", + "float16_t", + "float32_t", + "float64_t", + "i8vec2", + "i16vec2", + "i32vec2", + "i64vec2", + "u8vec2", + "u16vec2", + "u32vec2", + "u64vec2", + "f16vec2", + "f32vec2", + "f64vec2", + "i8vec3", + "i16vec3", + "i32vec3", + "i64vec3", + "u8vec3", + "u16vec3", + "u32vec3", + "u64vec3", + "f16vec3", + "f32vec3", + "f64vec3", + "i8vec4", + "i16vec4", + "i32vec4", + "i64vec4", + "u8vec4", + "u16vec4", + "u32vec4", + "u64vec4", + "f16vec4", + "f32vec4", + "f64vec4", + }; + for (uint32_t i = 0; i < sizeof(scalarAndVectorTypes)/sizeof(scalarAndVectorTypes[0]); ++i) { + std::string load = std::string("void coopVecLoadNV(out coopvecNV v, volatile coherent ") + + std::string(scalarAndVectorTypes[i]) + std::string("[] buf, uint offset);"); + std::string store = std::string("void coopVecStoreNV(coopvecNV v, volatile coherent ") + + std::string(scalarAndVectorTypes[i]) + std::string("[] buf, uint offset);"); + commonBuiltins.append(load.c_str()); + commonBuiltins.append(store.c_str()); + } + + commonBuiltins.append( + "const int gl_CooperativeVectorMatrixLayoutRowMajorNV = 0;\n" + "const int gl_CooperativeVectorMatrixLayoutColumnMajorNV = 1;\n" + "const int gl_CooperativeVectorMatrixLayoutInferencingOptimalNV = 2;\n" + "const int gl_CooperativeVectorMatrixLayoutTrainingOptimalNV = 3;\n" + "\n" + ); + + commonBuiltins.append( + "const int gl_ComponentTypeFloat16NV = 0;\n" + "const int gl_ComponentTypeFloat32NV = 1;\n" + "const int gl_ComponentTypeFloat64NV = 2;\n" + "const int gl_ComponentTypeSignedInt8NV = 3;\n" + "const int gl_ComponentTypeSignedInt16NV = 4;\n" + "const int gl_ComponentTypeSignedInt32NV = 5;\n" + "const int gl_ComponentTypeSignedInt64NV = 6;\n" + "const int gl_ComponentTypeUnsignedInt8NV = 7;\n" + "const int gl_ComponentTypeUnsignedInt16NV = 8;\n" + "const int gl_ComponentTypeUnsignedInt32NV = 9;\n" + "const int gl_ComponentTypeUnsignedInt64NV = 10;\n" + "const int gl_ComponentTypeSignedInt8PackedNV = 1000491000;\n" + "const int gl_ComponentTypeUnsignedInt8PackedNV = 1000491001;\n" + "const int gl_ComponentTypeFloatE4M3NV = 1000491002;\n" + "const int gl_ComponentTypeFloatE5M2NV = 1000491003;\n" + "\n" + ); + } + //============================================================================ // // Prototypes for built-in functions seen by fragment shaders only. @@ -9257,6 +9412,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("setTensorViewClipNV", 1, &E_GL_NV_cooperative_matrix2); } + { + symbolTable.setFunctionExtensions("coopVecMatMulNV", 1, &E_GL_NV_cooperative_vector); + symbolTable.setFunctionExtensions("coopVecMatMulAddNV", 1, &E_GL_NV_cooperative_vector); + symbolTable.setFunctionExtensions("coopVecOuterProductAccumulateNV", 1, &E_GL_NV_cooperative_vector); + symbolTable.setFunctionExtensions("coopVecReduceSumAccumulateNV", 1, &E_GL_NV_cooperative_vector); + } + if ((profile != EEsProfile && version >= 450) || (profile == EEsProfile && version >= 320)) { symbolTable.setFunctionExtensions("dFdx", 1, &E_GL_NV_compute_shader_derivatives); symbolTable.setFunctionExtensions("dFdy", 1, &E_GL_NV_compute_shader_derivatives); @@ -10356,6 +10518,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("texture2DArrayLod", EOpTextureLod); symbolTable.relateToOperator("shadow1DArrayLod", EOpTextureLod); } + + symbolTable.relateToOperator("coopVecMatMulNV", EOpCooperativeVectorMatMulNV); + symbolTable.relateToOperator("coopVecMatMulAddNV", EOpCooperativeVectorMatMulAddNV); + symbolTable.relateToOperator("coopVecLoadNV", EOpCooperativeVectorLoadNV); + symbolTable.relateToOperator("coopVecStoreNV", EOpCooperativeVectorStoreNV); + symbolTable.relateToOperator("coopVecOuterProductAccumulateNV", EOpCooperativeVectorOuterProductAccumulateNV); + symbolTable.relateToOperator("coopVecReduceSumAccumulateNV", EOpCooperativeVectorReduceSumAccumulateNV); } switch(language) { diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp index 7f707c8a3e..a174855acf 100644 --- a/glslang/MachineIndependent/Intermediate.cpp +++ b/glslang/MachineIndependent/Intermediate.cpp @@ -829,6 +829,11 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt node->getType().isTensorViewNV()) return nullptr; + // Reject implicit conversions to cooperative vector types + if (node->getType().isCoopVecNV() && + op != EOpConstructCooperativeVectorNV) + return nullptr; + // Note: callers are responsible for other aspects of shape, // like vector and matrix sizes. @@ -896,6 +901,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpConstructStruct: case EOpConstructCooperativeMatrixNV: case EOpConstructCooperativeMatrixKHR: + case EOpConstructCooperativeVectorNV: if (type.isReference() || node->getType().isReference()) { // types must match to assign a reference @@ -1772,6 +1778,9 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const if (type.isCoopMatKHR()) return EOpConstructCooperativeMatrixKHR; + if (type.isCoopVecNV()) + return EOpConstructCooperativeVectorNV; + switch (type.getBasicType()) { case EbtStruct: op = EOpConstructStruct; @@ -3301,6 +3310,43 @@ bool TIntermediate::promoteBinary(TIntermBinary& node) return false; } + if (left->getType().isCoopVecNV() || right->getType().isCoopVecNV()) { + // Operations on two cooperative vectors must have identical types + if (left->getType().isCoopVecNV() && right->getType().isCoopVecNV() && + left->getType() != right->getType()) { + return false; + } + switch (op) { + case EOpMul: + case EOpMulAssign: + // Use VectorTimesScalar if either operand is not a vector. Otherwise use Mul. + if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) { + node.setOp(op == EOpMulAssign ? EOpVectorTimesScalarAssign : EOpVectorTimesScalar); + } + // In case of scalar*vector, take the result type from the vector. + if (right->getType().isCoopVecNV()) { + node.setType(right->getType()); + } + return true; + case EOpLeftShift: + case EOpLeftShiftAssign: + case EOpRightShift: + case EOpRightShiftAssign: + case EOpAdd: + case EOpSub: + case EOpDiv: + case EOpAssign: + // These require both to be cooperative vectors + if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) { + return false; + } + return true; + default: + break; + } + return false; + } + // Finish handling the case, for all ops, where both operands are scalars. if (left->isScalar() && right->isScalar()) return true; diff --git a/glslang/MachineIndependent/ParseContextBase.cpp b/glslang/MachineIndependent/ParseContextBase.cpp index f7895d9799..986b94194a 100644 --- a/glslang/MachineIndependent/ParseContextBase.cpp +++ b/glslang/MachineIndependent/ParseContextBase.cpp @@ -305,6 +305,11 @@ void TParseContextBase::checkIndex(const TSourceLoc& loc, const TType& type, int error(loc, "", "[", "matrix index out of range '%d'", index); index = type.getMatrixCols() - 1; } + } else if (type.isCoopVecNV()) { + if (index >= type.computeNumComponents()) { + error(loc, "", "[", "cooperative vector index out of range '%d'", index); + index = type.computeNumComponents() - 1; + } } } diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index cb7d8367b7..3a8a18650d 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -550,7 +550,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn variableCheck(base); if (! base->isArray() && ! base->isMatrix() && ! base->isVector() && ! base->getType().isCoopMat() && - ! base->isReference()) { + ! base->isReference() && ! base->getType().isCoopVecNV()) { if (base->getAsSymbolNode()) error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), ""); else @@ -971,7 +971,7 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm const char* feature = ".length() on vectors and matrices"; requireProfile(loc, ~EEsProfile, feature); profileRequires(loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, feature); - } else if (!base->getType().isCoopMat()) { + } else if (!base->getType().isCoopMat() && !base->getType().isCoopVecNV()) { bool enhanced = intermediate.getEnhancedMsgs(); error(loc, "does not operate on this type:", field.c_str(), base->getType().getCompleteString(enhanced).c_str()); return base; @@ -1183,19 +1183,23 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct if (prevDec) { if (prevDec->isPrototyped() && prototype) profileRequires(loc, EEsProfile, 300, nullptr, "multiple prototypes for same function"); - if (prevDec->getType() != function.getType()) - error(loc, "overloaded functions must have the same return type", function.getName().c_str(), ""); if (prevDec->getSpirvInstruction() != function.getSpirvInstruction()) { error(loc, "overloaded functions must have the same qualifiers", function.getName().c_str(), "spirv_instruction"); } + bool parameterTypesDiffer = false; for (int i = 0; i < prevDec->getParamCount(); ++i) { if ((*prevDec)[i].type->getQualifier().storage != function[i].type->getQualifier().storage) error(loc, "overloaded functions must have the same parameter storage qualifiers for argument", function[i].type->getStorageQualifierString(), "%d", i+1); if ((*prevDec)[i].type->getQualifier().precision != function[i].type->getQualifier().precision) error(loc, "overloaded functions must have the same parameter precision qualifiers for argument", function[i].type->getPrecisionQualifierString(), "%d", i+1); + + if (*(*prevDec)[i].type != *function[i].type) + parameterTypesDiffer = true; } + if (!parameterTypesDiffer && prevDec->getType() != function.getType()) + error(loc, "overloaded functions must have the same return type", function.getName().c_str(), ""); } arrayObjectCheck(loc, function.getType(), "array in function return type"); @@ -1446,6 +1450,11 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction if (builtIn && arg->getAsTyped()->getType().contains8BitInt()) requireInt8Arithmetic(arguments->getLoc(), "built-in function", "(u)int8 types can only be in uniform block or buffer storage"); + // Check that coopVecOuterProductAccumulateNV vector component types match + if (builtIn && fnCandidate->getBuiltInOp() == EOpCooperativeVectorOuterProductAccumulateNV && + i == 1 && arg->getAsTyped()->getType().getBasicType() != aggregate->getSequence()[0]->getAsTyped()->getType().getBasicType()) + error(arguments->getLoc(), "cooperative vector basic types must match", fnCandidate->getName().c_str(), ""); + // TODO 4.5 functionality: A shader will fail to compile // if the value passed to the memargument of an atomic memory function does not correspond to a buffer or // shared variable. It is acceptable to pass an element of an array or a single component of a vector to the @@ -1501,6 +1510,14 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction } handleCoopMat2FunctionCall(loc, fnCandidate, result, arguments); + + if (result->getAsTyped()->getType().isCoopVecNV() && + !result->getAsTyped()->getType().isParameterized()) { + if (auto unaryNode = result->getAsUnaryNode()) + result->setType(unaryNode->getOperand()->getAsTyped()->getType()); + else + result->setType(result->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()); + } } } @@ -2022,7 +2039,7 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction length = type.getMatrixCols(); else if (type.isVector()) length = type.getVectorSize(); - else if (type.isCoopMat()) + else if (type.isCoopMat() || type.isCoopVecNV()) return intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, intermNode, TType(EbtInt)); else { // we should not get here, because earlier semantic checking should have prevented this path @@ -3027,7 +3044,41 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan } break; - + case EOpCooperativeVectorMatMulNV: + case EOpCooperativeVectorMatMulAddNV: + { + int inputInterpIdx = 2; + int matrixInterpIdx = 5; + int biasInterpIdx = 8; + int MIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 9 : 6; + int KIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 10 : 7; + int matrixLayoutIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 11 : 8; + int transposeIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 12 : 9; + + if (!(*argp)[inputInterpIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "inputInterpretation", ""); + if (!(*argp)[matrixInterpIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "matrixInterpretation", ""); + if (callNode.getOp() == EOpCooperativeVectorMatMulAddNV) { + if (!(*argp)[biasInterpIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "biasInterpretation", ""); + } + if (!(*argp)[MIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "M", ""); + if (!(*argp)[KIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "K", ""); + if (!(*argp)[matrixLayoutIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "matrixLayout", ""); + if (!(*argp)[transposeIdx]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "transpose", ""); + } + break; + case EOpCooperativeVectorOuterProductAccumulateNV: + if (!(*argp)[5]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "matrixLayout", ""); + if (!(*argp)[6]->getAsTyped()->getType().getQualifier().isConstant()) + error(loc, "argument must be compile-time constant", "matrixInterpretation", ""); + break; default: break; } @@ -4660,7 +4711,7 @@ TPrecisionQualifier TParseContext::getDefaultPrecision(TPublicType& publicType) return defaultPrecision[publicType.basicType]; } -void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool isCoopMat) +void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool isCoopMatOrVec) { // Built-in symbols are allowed some ambiguous precisions, to be pinned down // later by context. @@ -4670,7 +4721,7 @@ void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType ba if (baseType == EbtAtomicUint && qualifier.precision != EpqNone && qualifier.precision != EpqHigh) error(loc, "atomic counters can only be highp", "atomic_uint", ""); - if (isCoopMat) + if (isCoopMatOrVec) return; if (baseType == EbtFloat || baseType == EbtUint || baseType == EbtInt || baseType == EbtSampler || baseType == EbtAtomicUint) { @@ -7486,6 +7537,8 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu return true; if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction) return true; + if (from.coopVecParameterOK(to)) + return true; // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions if (builtIn && from.isArray() && to.isUnsizedArray()) { TType fromElementType(from, 0); @@ -7503,6 +7556,8 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu return false; if (from.isCoopMat() && to.isCoopMat()) return from.sameCoopMatBaseType(to); + if (from.isCoopVecNV() && to.isCoopVecNV()) + return from.sameCoopVecBaseType(to); return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); }; @@ -7572,6 +7627,8 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, return true; if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction) return true; + if (from.coopVecParameterOK(to)) + return true; // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions if (builtIn && from.isArray() && to.isUnsizedArray()) { TType fromElementType(from, 0); @@ -7589,6 +7646,8 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, return false; if (from.isCoopMat() && to.isCoopMat()) return from.sameCoopMatBaseType(to); + if (from.isCoopVecNV() && to.isCoopVecNV()) + return from.sameCoopVecBaseType(to); return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); }; @@ -7724,7 +7783,7 @@ void TParseContext::declareTypeDefaults(const TSourceLoc& loc, const TPublicType warn(loc, "useless application of layout qualifier", "layout", ""); } -void TParseContext::coopMatTypeParametersCheck(const TSourceLoc& loc, const TPublicType& publicType) +void TParseContext::typeParametersCheck(const TSourceLoc& loc, const TPublicType& publicType) { if (parsingBuiltins) return; @@ -8181,10 +8240,9 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden intermediate.setUseVulkanMemoryModel(); intermediate.setUseStorageBuffer(); - if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() != 4) { + if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 4) { error(loc, "expected four type parameters", identifier.c_str(), ""); - } - if (publicType.typeParameters) { + } else { if (isTypeFloat(publicType.basicType) && publicType.typeParameters->arraySizes->getDimSize(0) != 16 && publicType.typeParameters->arraySizes->getDimSize(0) != 32 && @@ -8206,6 +8264,15 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() > 7) { error(loc, "expected 1-7 type parameters", identifier.c_str(), ""); } + } else if (type.isCoopVecNV()) { + intermediate.setUseVulkanMemoryModel(); + intermediate.setUseStorageBuffer(); + + if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 1) { + error(loc, "expected two type parameters", identifier.c_str(), ""); + } else if (publicType.typeParameters->arraySizes->getDimSize(0) <= 0) { + error(loc, "expected positive number of components", identifier.c_str(), ""); + } } else { if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() != 0) { error(loc, "unexpected type parameters", identifier.c_str(), ""); @@ -9049,6 +9116,27 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T return nullptr; } + case EOpConstructCooperativeVectorNV: + if (!node->getType().isCoopVecNV()) { + if (type.getBasicType() != node->getType().getBasicType()) { + node = intermediate.addConversion(type.getBasicType(), node); + if (node == nullptr) + return nullptr; + } + } + if (type.getBasicType() != node->getType().getBasicType()) { + intermediate.buildConvertOp(type.getBasicType(), node->getType().getBasicType(), op); + node = intermediate.addUnaryNode(op, node, node->getLoc(), type); + return node; + } + if (subset) { + return node; + } + + node = intermediate.setAggregateOperator(node, op, type, node->getLoc()); + + return node; + case EOpConstructCooperativeMatrixNV: case EOpConstructCooperativeMatrixKHR: if (node->getType() == type) { @@ -9230,6 +9318,9 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con if (memberType.containsCoopMat()) error(memberLoc, "member of block cannot be or contain a cooperative matrix type", typeList[member].type->getFieldName().c_str(), ""); + + if (memberType.containsCoopVec()) + error(memberLoc, "member of block cannot be or contain a cooperative vector type", typeList[member].type->getFieldName().c_str(), ""); } // This might be a redeclaration of a built-in block. If so, redeclareBuiltinBlock() will diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h index 5b192c11ab..47a72999fb 100644 --- a/glslang/MachineIndependent/ParseHelper.h +++ b/glslang/MachineIndependent/ParseHelper.h @@ -407,7 +407,7 @@ class TParseContext : public TParseContextBase { void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier); int computeSamplerTypeIndex(TSampler&); TPrecisionQualifier getDefaultPrecision(TPublicType&); - void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMat); + void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMatOrVec); void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type); bool containsFieldWithBasicType(const TType& type ,TBasicType basicType); TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&); @@ -425,7 +425,7 @@ class TParseContext : public TParseContextBase { void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop); void arrayLimitCheck(const TSourceLoc&, const TString&, int size); void limitCheck(const TSourceLoc&, int value, const char* limit, const char* feature); - void coopMatTypeParametersCheck(const TSourceLoc&, const TPublicType&); + void typeParametersCheck(const TSourceLoc&, const TPublicType&); void inductiveLoopBodyCheck(TIntermNode*, long long loopIndexId, TSymbolTable&); void constantIndexExpressionCheck(TIntermNode*); diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 414251e67b..102302a0cb 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -756,6 +756,8 @@ const std::unordered_map KeywordMap { {"__function",FUNCTION}, {"tensorLayoutNV",TENSORLAYOUTNV}, {"tensorViewNV",TENSORVIEWNV}, + + {"coopvecNV",COOPVECNV}, }; const std::unordered_set ReservedSet { "common", @@ -1776,6 +1778,13 @@ int TScanContext::tokenizeIdentifier() return keyword; return identifierOrType(); + case COOPVECNV: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_NV_cooperative_vector)) + return keyword; + return identifierOrType(); + case DEMOTE: if (parseContext.extensionTurnedOn(E_GL_EXT_demote_to_helper_invocation)) return keyword; diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index 803626000b..ec53fe378c 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -60,6 +60,9 @@ void TType::buildMangledName(TString& mangledName) const else if (isVector()) mangledName += 'v'; + if (isCoopVecNV()) + mangledName += "coopvec"; + switch (basicType) { case EbtFloat: mangledName += 'f'; break; case EbtInt: mangledName += 'i'; break; @@ -163,6 +166,23 @@ void TType::buildMangledName(TString& mangledName) const mangledName += static_cast('0' + getMatrixRows()); } + if (typeParameters) { + const int maxSize = 11; + char buf[maxSize]; + for (int i = 0; i < typeParameters->arraySizes->getNumDims(); ++i) { + if (typeParameters->arraySizes->getDimNode(i)) { + if (typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode()) + snprintf(buf, maxSize, "s%lld", typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode()->getId()); + else + snprintf(buf, maxSize, "s%p", typeParameters->arraySizes->getDimNode(i)); + } else + snprintf(buf, maxSize, "%d", typeParameters->arraySizes->getDimSize(i)); + mangledName += '<'; + mangledName += buf; + mangledName += '>'; + } + } + if (arraySizes) { const int maxSize = 11; char buf[maxSize]; diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp index bee9042b5b..dd523fa8d8 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -269,6 +269,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_EXT_spec_constant_composites] = EBhDisable; extensionBehavior[E_GL_KHR_cooperative_matrix] = EBhDisable; + extensionBehavior[E_GL_NV_cooperative_vector] = EBhDisable; // #line and #include extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive] = EBhDisable; @@ -1404,6 +1405,14 @@ void TParseVersions::tensorLayoutViewCheck(const TSourceLoc& loc, const char* op } } +void TParseVersions::coopvecCheck(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = {E_GL_NV_cooperative_vector}; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + // Call for any operation removed because SPIR-V is in use. void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op) { diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 504c62bd62..bd3201d528 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -285,6 +285,7 @@ const char* const E_GL_EXT_ray_tracing_position_fetch = "GL_EXT_ray_tr const char* const E_GL_NV_displacement_micromap = "GL_NV_displacement_micromap"; const char* const E_GL_NV_shader_atomic_fp16_vector = "GL_NV_shader_atomic_fp16_vector"; const char* const E_GL_NV_cooperative_matrix2 = "GL_NV_cooperative_matrix2"; +const char* const E_GL_NV_cooperative_vector = "GL_NV_cooperative_vector"; // ARM const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader_core_builtins"; diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index 90ac3c83e3..09d88141d0 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -178,6 +178,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token RAYQUERYEXT %token FCOOPMATNV ICOOPMATNV UCOOPMATNV %token COOPMAT +%token COOPVECNV %token HITOBJECTNV HITOBJECTATTRNV %token TENSORLAYOUTNV TENSORVIEWNV @@ -1105,7 +1106,7 @@ parameter_declaration $$ = $2; if ($1.qualifier.precision != EpqNone) $$.param.type->getQualifier().precision = $1.qualifier.precision; - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type); @@ -1117,7 +1118,7 @@ parameter_declaration parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type); parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type); - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); } // // Without name @@ -1126,7 +1127,7 @@ parameter_declaration $$ = $2; if ($1.qualifier.precision != EpqNone) $$.param.type->getQualifier().precision = $1.qualifier.precision; - parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat()); + parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type); @@ -1137,7 +1138,7 @@ parameter_declaration parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type); parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type); - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); } ; @@ -1212,7 +1213,7 @@ fully_specified_type parseContext.profileRequires($1.loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); parseContext.profileRequires($1.loc, EEsProfile, 300, 0, "arrayed type"); } - parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.isCoopmat()); + parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.isCoopmatOrvec()); } | type_qualifier type_specifier { parseContext.globalQualifierFixCheck($1.loc, $1.qualifier, false, &$2); @@ -1229,7 +1230,7 @@ fully_specified_type parseContext.checkNoShaderLayouts($2.loc, $1.shaderQualifiers); $2.shaderQualifiers.merge($1.shaderQualifiers); parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true); - parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmat()); + parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec()); $$ = $2; @@ -1701,7 +1702,7 @@ type_specifier $$ = $1; $$.qualifier.precision = parseContext.getDefaultPrecision($$); $$.typeParameters = $2; - parseContext.coopMatTypeParametersCheck($1.loc, $$); + parseContext.typeParametersCheck($1.loc, $$); } | type_specifier_nonarray type_parameter_specifier_opt array_specifier { @@ -1710,7 +1711,7 @@ type_specifier $$.qualifier.precision = parseContext.getDefaultPrecision($$); $$.typeParameters = $2; $$.arraySizes = $3.arraySizes; - parseContext.coopMatTypeParametersCheck($1.loc, $$); + parseContext.typeParametersCheck($1.loc, $$); } ; @@ -3550,6 +3551,12 @@ type_specifier_nonarray $$.init($1.loc); $$.basicType = EbtFunction; } + | COOPVECNV { + parseContext.coopvecCheck($1.loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtCoopvecNV; + $$.coopvecNV = true; + } | spirv_type_specifier { parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); $$ = $1; @@ -3651,7 +3658,7 @@ struct_declaration $$ = $2; parseContext.voidErrorCheck($1.loc, (*$2)[0].type->getFieldName(), $1.basicType); - parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.isCoopmat()); + parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.isCoopmatOrvec()); for (unsigned int i = 0; i < $$->size(); ++i) { TType type($1); @@ -3675,7 +3682,7 @@ struct_declaration parseContext.memberQualifierCheck($1); parseContext.voidErrorCheck($2.loc, (*$3)[0].type->getFieldName(), $2.basicType); parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true); - parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmat()); + parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec()); for (unsigned int i = 0; i < $$->size(); ++i) { TType type($2); diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index 56e568bb0d..45a37c8e6b 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -288,439 +288,440 @@ enum yysymbol_kind_t YYSYMBOL_ICOOPMATNV = 164, /* ICOOPMATNV */ YYSYMBOL_UCOOPMATNV = 165, /* UCOOPMATNV */ YYSYMBOL_COOPMAT = 166, /* COOPMAT */ - YYSYMBOL_HITOBJECTNV = 167, /* HITOBJECTNV */ - YYSYMBOL_HITOBJECTATTRNV = 168, /* HITOBJECTATTRNV */ - YYSYMBOL_TENSORLAYOUTNV = 169, /* TENSORLAYOUTNV */ - YYSYMBOL_TENSORVIEWNV = 170, /* TENSORVIEWNV */ - YYSYMBOL_SAMPLERCUBEARRAY = 171, /* SAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 172, /* SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_ISAMPLERCUBEARRAY = 173, /* ISAMPLERCUBEARRAY */ - YYSYMBOL_USAMPLERCUBEARRAY = 174, /* USAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLER1D = 175, /* SAMPLER1D */ - YYSYMBOL_SAMPLER1DARRAY = 176, /* SAMPLER1DARRAY */ - YYSYMBOL_SAMPLER1DARRAYSHADOW = 177, /* SAMPLER1DARRAYSHADOW */ - YYSYMBOL_ISAMPLER1D = 178, /* ISAMPLER1D */ - YYSYMBOL_SAMPLER1DSHADOW = 179, /* SAMPLER1DSHADOW */ - YYSYMBOL_SAMPLER2DRECT = 180, /* SAMPLER2DRECT */ - YYSYMBOL_SAMPLER2DRECTSHADOW = 181, /* SAMPLER2DRECTSHADOW */ - YYSYMBOL_ISAMPLER2DRECT = 182, /* ISAMPLER2DRECT */ - YYSYMBOL_USAMPLER2DRECT = 183, /* USAMPLER2DRECT */ - YYSYMBOL_SAMPLERBUFFER = 184, /* SAMPLERBUFFER */ - YYSYMBOL_ISAMPLERBUFFER = 185, /* ISAMPLERBUFFER */ - YYSYMBOL_USAMPLERBUFFER = 186, /* USAMPLERBUFFER */ - YYSYMBOL_SAMPLER2DMS = 187, /* SAMPLER2DMS */ - YYSYMBOL_ISAMPLER2DMS = 188, /* ISAMPLER2DMS */ - YYSYMBOL_USAMPLER2DMS = 189, /* USAMPLER2DMS */ - YYSYMBOL_SAMPLER2DMSARRAY = 190, /* SAMPLER2DMSARRAY */ - YYSYMBOL_ISAMPLER2DMSARRAY = 191, /* ISAMPLER2DMSARRAY */ - YYSYMBOL_USAMPLER2DMSARRAY = 192, /* USAMPLER2DMSARRAY */ - YYSYMBOL_SAMPLEREXTERNALOES = 193, /* SAMPLEREXTERNALOES */ - YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 194, /* SAMPLEREXTERNAL2DY2YEXT */ - YYSYMBOL_ISAMPLER1DARRAY = 195, /* ISAMPLER1DARRAY */ - YYSYMBOL_USAMPLER1D = 196, /* USAMPLER1D */ - YYSYMBOL_USAMPLER1DARRAY = 197, /* USAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER1D = 198, /* F16SAMPLER1D */ - YYSYMBOL_F16SAMPLER2D = 199, /* F16SAMPLER2D */ - YYSYMBOL_F16SAMPLER3D = 200, /* F16SAMPLER3D */ - YYSYMBOL_F16SAMPLER2DRECT = 201, /* F16SAMPLER2DRECT */ - YYSYMBOL_F16SAMPLERCUBE = 202, /* F16SAMPLERCUBE */ - YYSYMBOL_F16SAMPLER1DARRAY = 203, /* F16SAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER2DARRAY = 204, /* F16SAMPLER2DARRAY */ - YYSYMBOL_F16SAMPLERCUBEARRAY = 205, /* F16SAMPLERCUBEARRAY */ - YYSYMBOL_F16SAMPLERBUFFER = 206, /* F16SAMPLERBUFFER */ - YYSYMBOL_F16SAMPLER2DMS = 207, /* F16SAMPLER2DMS */ - YYSYMBOL_F16SAMPLER2DMSARRAY = 208, /* F16SAMPLER2DMSARRAY */ - YYSYMBOL_F16SAMPLER1DSHADOW = 209, /* F16SAMPLER1DSHADOW */ - YYSYMBOL_F16SAMPLER2DSHADOW = 210, /* F16SAMPLER2DSHADOW */ - YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 211, /* F16SAMPLER1DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 212, /* F16SAMPLER2DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DRECTSHADOW = 213, /* F16SAMPLER2DRECTSHADOW */ - YYSYMBOL_F16SAMPLERCUBESHADOW = 214, /* F16SAMPLERCUBESHADOW */ - YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 215, /* F16SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_IMAGE1D = 216, /* IMAGE1D */ - YYSYMBOL_IIMAGE1D = 217, /* IIMAGE1D */ - YYSYMBOL_UIMAGE1D = 218, /* UIMAGE1D */ - YYSYMBOL_IMAGE2D = 219, /* IMAGE2D */ - YYSYMBOL_IIMAGE2D = 220, /* IIMAGE2D */ - YYSYMBOL_UIMAGE2D = 221, /* UIMAGE2D */ - YYSYMBOL_IMAGE3D = 222, /* IMAGE3D */ - YYSYMBOL_IIMAGE3D = 223, /* IIMAGE3D */ - YYSYMBOL_UIMAGE3D = 224, /* UIMAGE3D */ - YYSYMBOL_IMAGE2DRECT = 225, /* IMAGE2DRECT */ - YYSYMBOL_IIMAGE2DRECT = 226, /* IIMAGE2DRECT */ - YYSYMBOL_UIMAGE2DRECT = 227, /* UIMAGE2DRECT */ - YYSYMBOL_IMAGECUBE = 228, /* IMAGECUBE */ - YYSYMBOL_IIMAGECUBE = 229, /* IIMAGECUBE */ - YYSYMBOL_UIMAGECUBE = 230, /* UIMAGECUBE */ - YYSYMBOL_IMAGEBUFFER = 231, /* IMAGEBUFFER */ - YYSYMBOL_IIMAGEBUFFER = 232, /* IIMAGEBUFFER */ - YYSYMBOL_UIMAGEBUFFER = 233, /* UIMAGEBUFFER */ - YYSYMBOL_IMAGE1DARRAY = 234, /* IMAGE1DARRAY */ - YYSYMBOL_IIMAGE1DARRAY = 235, /* IIMAGE1DARRAY */ - YYSYMBOL_UIMAGE1DARRAY = 236, /* UIMAGE1DARRAY */ - YYSYMBOL_IMAGE2DARRAY = 237, /* IMAGE2DARRAY */ - YYSYMBOL_IIMAGE2DARRAY = 238, /* IIMAGE2DARRAY */ - YYSYMBOL_UIMAGE2DARRAY = 239, /* UIMAGE2DARRAY */ - YYSYMBOL_IMAGECUBEARRAY = 240, /* IMAGECUBEARRAY */ - YYSYMBOL_IIMAGECUBEARRAY = 241, /* IIMAGECUBEARRAY */ - YYSYMBOL_UIMAGECUBEARRAY = 242, /* UIMAGECUBEARRAY */ - YYSYMBOL_IMAGE2DMS = 243, /* IMAGE2DMS */ - YYSYMBOL_IIMAGE2DMS = 244, /* IIMAGE2DMS */ - YYSYMBOL_UIMAGE2DMS = 245, /* UIMAGE2DMS */ - YYSYMBOL_IMAGE2DMSARRAY = 246, /* IMAGE2DMSARRAY */ - YYSYMBOL_IIMAGE2DMSARRAY = 247, /* IIMAGE2DMSARRAY */ - YYSYMBOL_UIMAGE2DMSARRAY = 248, /* UIMAGE2DMSARRAY */ - YYSYMBOL_F16IMAGE1D = 249, /* F16IMAGE1D */ - YYSYMBOL_F16IMAGE2D = 250, /* F16IMAGE2D */ - YYSYMBOL_F16IMAGE3D = 251, /* F16IMAGE3D */ - YYSYMBOL_F16IMAGE2DRECT = 252, /* F16IMAGE2DRECT */ - YYSYMBOL_F16IMAGECUBE = 253, /* F16IMAGECUBE */ - YYSYMBOL_F16IMAGE1DARRAY = 254, /* F16IMAGE1DARRAY */ - YYSYMBOL_F16IMAGE2DARRAY = 255, /* F16IMAGE2DARRAY */ - YYSYMBOL_F16IMAGECUBEARRAY = 256, /* F16IMAGECUBEARRAY */ - YYSYMBOL_F16IMAGEBUFFER = 257, /* F16IMAGEBUFFER */ - YYSYMBOL_F16IMAGE2DMS = 258, /* F16IMAGE2DMS */ - YYSYMBOL_F16IMAGE2DMSARRAY = 259, /* F16IMAGE2DMSARRAY */ - YYSYMBOL_I64IMAGE1D = 260, /* I64IMAGE1D */ - YYSYMBOL_U64IMAGE1D = 261, /* U64IMAGE1D */ - YYSYMBOL_I64IMAGE2D = 262, /* I64IMAGE2D */ - YYSYMBOL_U64IMAGE2D = 263, /* U64IMAGE2D */ - YYSYMBOL_I64IMAGE3D = 264, /* I64IMAGE3D */ - YYSYMBOL_U64IMAGE3D = 265, /* U64IMAGE3D */ - YYSYMBOL_I64IMAGE2DRECT = 266, /* I64IMAGE2DRECT */ - YYSYMBOL_U64IMAGE2DRECT = 267, /* U64IMAGE2DRECT */ - YYSYMBOL_I64IMAGECUBE = 268, /* I64IMAGECUBE */ - YYSYMBOL_U64IMAGECUBE = 269, /* U64IMAGECUBE */ - YYSYMBOL_I64IMAGEBUFFER = 270, /* I64IMAGEBUFFER */ - YYSYMBOL_U64IMAGEBUFFER = 271, /* U64IMAGEBUFFER */ - YYSYMBOL_I64IMAGE1DARRAY = 272, /* I64IMAGE1DARRAY */ - YYSYMBOL_U64IMAGE1DARRAY = 273, /* U64IMAGE1DARRAY */ - YYSYMBOL_I64IMAGE2DARRAY = 274, /* I64IMAGE2DARRAY */ - YYSYMBOL_U64IMAGE2DARRAY = 275, /* U64IMAGE2DARRAY */ - YYSYMBOL_I64IMAGECUBEARRAY = 276, /* I64IMAGECUBEARRAY */ - YYSYMBOL_U64IMAGECUBEARRAY = 277, /* U64IMAGECUBEARRAY */ - YYSYMBOL_I64IMAGE2DMS = 278, /* I64IMAGE2DMS */ - YYSYMBOL_U64IMAGE2DMS = 279, /* U64IMAGE2DMS */ - YYSYMBOL_I64IMAGE2DMSARRAY = 280, /* I64IMAGE2DMSARRAY */ - YYSYMBOL_U64IMAGE2DMSARRAY = 281, /* U64IMAGE2DMSARRAY */ - YYSYMBOL_TEXTURECUBEARRAY = 282, /* TEXTURECUBEARRAY */ - YYSYMBOL_ITEXTURECUBEARRAY = 283, /* ITEXTURECUBEARRAY */ - YYSYMBOL_UTEXTURECUBEARRAY = 284, /* UTEXTURECUBEARRAY */ - YYSYMBOL_TEXTURE1D = 285, /* TEXTURE1D */ - YYSYMBOL_ITEXTURE1D = 286, /* ITEXTURE1D */ - YYSYMBOL_UTEXTURE1D = 287, /* UTEXTURE1D */ - YYSYMBOL_TEXTURE1DARRAY = 288, /* TEXTURE1DARRAY */ - YYSYMBOL_ITEXTURE1DARRAY = 289, /* ITEXTURE1DARRAY */ - YYSYMBOL_UTEXTURE1DARRAY = 290, /* UTEXTURE1DARRAY */ - YYSYMBOL_TEXTURE2DRECT = 291, /* TEXTURE2DRECT */ - YYSYMBOL_ITEXTURE2DRECT = 292, /* ITEXTURE2DRECT */ - YYSYMBOL_UTEXTURE2DRECT = 293, /* UTEXTURE2DRECT */ - YYSYMBOL_TEXTUREBUFFER = 294, /* TEXTUREBUFFER */ - YYSYMBOL_ITEXTUREBUFFER = 295, /* ITEXTUREBUFFER */ - YYSYMBOL_UTEXTUREBUFFER = 296, /* UTEXTUREBUFFER */ - YYSYMBOL_TEXTURE2DMS = 297, /* TEXTURE2DMS */ - YYSYMBOL_ITEXTURE2DMS = 298, /* ITEXTURE2DMS */ - YYSYMBOL_UTEXTURE2DMS = 299, /* UTEXTURE2DMS */ - YYSYMBOL_TEXTURE2DMSARRAY = 300, /* TEXTURE2DMSARRAY */ - YYSYMBOL_ITEXTURE2DMSARRAY = 301, /* ITEXTURE2DMSARRAY */ - YYSYMBOL_UTEXTURE2DMSARRAY = 302, /* UTEXTURE2DMSARRAY */ - YYSYMBOL_F16TEXTURE1D = 303, /* F16TEXTURE1D */ - YYSYMBOL_F16TEXTURE2D = 304, /* F16TEXTURE2D */ - YYSYMBOL_F16TEXTURE3D = 305, /* F16TEXTURE3D */ - YYSYMBOL_F16TEXTURE2DRECT = 306, /* F16TEXTURE2DRECT */ - YYSYMBOL_F16TEXTURECUBE = 307, /* F16TEXTURECUBE */ - YYSYMBOL_F16TEXTURE1DARRAY = 308, /* F16TEXTURE1DARRAY */ - YYSYMBOL_F16TEXTURE2DARRAY = 309, /* F16TEXTURE2DARRAY */ - YYSYMBOL_F16TEXTURECUBEARRAY = 310, /* F16TEXTURECUBEARRAY */ - YYSYMBOL_F16TEXTUREBUFFER = 311, /* F16TEXTUREBUFFER */ - YYSYMBOL_F16TEXTURE2DMS = 312, /* F16TEXTURE2DMS */ - YYSYMBOL_F16TEXTURE2DMSARRAY = 313, /* F16TEXTURE2DMSARRAY */ - YYSYMBOL_SUBPASSINPUT = 314, /* SUBPASSINPUT */ - YYSYMBOL_SUBPASSINPUTMS = 315, /* SUBPASSINPUTMS */ - YYSYMBOL_ISUBPASSINPUT = 316, /* ISUBPASSINPUT */ - YYSYMBOL_ISUBPASSINPUTMS = 317, /* ISUBPASSINPUTMS */ - YYSYMBOL_USUBPASSINPUT = 318, /* USUBPASSINPUT */ - YYSYMBOL_USUBPASSINPUTMS = 319, /* USUBPASSINPUTMS */ - YYSYMBOL_F16SUBPASSINPUT = 320, /* F16SUBPASSINPUT */ - YYSYMBOL_F16SUBPASSINPUTMS = 321, /* F16SUBPASSINPUTMS */ - YYSYMBOL_SPIRV_INSTRUCTION = 322, /* SPIRV_INSTRUCTION */ - YYSYMBOL_SPIRV_EXECUTION_MODE = 323, /* SPIRV_EXECUTION_MODE */ - YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 324, /* SPIRV_EXECUTION_MODE_ID */ - YYSYMBOL_SPIRV_DECORATE = 325, /* SPIRV_DECORATE */ - YYSYMBOL_SPIRV_DECORATE_ID = 326, /* SPIRV_DECORATE_ID */ - YYSYMBOL_SPIRV_DECORATE_STRING = 327, /* SPIRV_DECORATE_STRING */ - YYSYMBOL_SPIRV_TYPE = 328, /* SPIRV_TYPE */ - YYSYMBOL_SPIRV_STORAGE_CLASS = 329, /* SPIRV_STORAGE_CLASS */ - YYSYMBOL_SPIRV_BY_REFERENCE = 330, /* SPIRV_BY_REFERENCE */ - YYSYMBOL_SPIRV_LITERAL = 331, /* SPIRV_LITERAL */ - YYSYMBOL_ATTACHMENTEXT = 332, /* ATTACHMENTEXT */ - YYSYMBOL_IATTACHMENTEXT = 333, /* IATTACHMENTEXT */ - YYSYMBOL_UATTACHMENTEXT = 334, /* UATTACHMENTEXT */ - YYSYMBOL_LEFT_OP = 335, /* LEFT_OP */ - YYSYMBOL_RIGHT_OP = 336, /* RIGHT_OP */ - YYSYMBOL_INC_OP = 337, /* INC_OP */ - YYSYMBOL_DEC_OP = 338, /* DEC_OP */ - YYSYMBOL_LE_OP = 339, /* LE_OP */ - YYSYMBOL_GE_OP = 340, /* GE_OP */ - YYSYMBOL_EQ_OP = 341, /* EQ_OP */ - YYSYMBOL_NE_OP = 342, /* NE_OP */ - YYSYMBOL_AND_OP = 343, /* AND_OP */ - YYSYMBOL_OR_OP = 344, /* OR_OP */ - YYSYMBOL_XOR_OP = 345, /* XOR_OP */ - YYSYMBOL_MUL_ASSIGN = 346, /* MUL_ASSIGN */ - YYSYMBOL_DIV_ASSIGN = 347, /* DIV_ASSIGN */ - YYSYMBOL_ADD_ASSIGN = 348, /* ADD_ASSIGN */ - YYSYMBOL_MOD_ASSIGN = 349, /* MOD_ASSIGN */ - YYSYMBOL_LEFT_ASSIGN = 350, /* LEFT_ASSIGN */ - YYSYMBOL_RIGHT_ASSIGN = 351, /* RIGHT_ASSIGN */ - YYSYMBOL_AND_ASSIGN = 352, /* AND_ASSIGN */ - YYSYMBOL_XOR_ASSIGN = 353, /* XOR_ASSIGN */ - YYSYMBOL_OR_ASSIGN = 354, /* OR_ASSIGN */ - YYSYMBOL_SUB_ASSIGN = 355, /* SUB_ASSIGN */ - YYSYMBOL_STRING_LITERAL = 356, /* STRING_LITERAL */ - YYSYMBOL_LEFT_PAREN = 357, /* LEFT_PAREN */ - YYSYMBOL_RIGHT_PAREN = 358, /* RIGHT_PAREN */ - YYSYMBOL_LEFT_BRACKET = 359, /* LEFT_BRACKET */ - YYSYMBOL_RIGHT_BRACKET = 360, /* RIGHT_BRACKET */ - YYSYMBOL_LEFT_BRACE = 361, /* LEFT_BRACE */ - YYSYMBOL_RIGHT_BRACE = 362, /* RIGHT_BRACE */ - YYSYMBOL_DOT = 363, /* DOT */ - YYSYMBOL_COMMA = 364, /* COMMA */ - YYSYMBOL_COLON = 365, /* COLON */ - YYSYMBOL_EQUAL = 366, /* EQUAL */ - YYSYMBOL_SEMICOLON = 367, /* SEMICOLON */ - YYSYMBOL_BANG = 368, /* BANG */ - YYSYMBOL_DASH = 369, /* DASH */ - YYSYMBOL_TILDE = 370, /* TILDE */ - YYSYMBOL_PLUS = 371, /* PLUS */ - YYSYMBOL_STAR = 372, /* STAR */ - YYSYMBOL_SLASH = 373, /* SLASH */ - YYSYMBOL_PERCENT = 374, /* PERCENT */ - YYSYMBOL_LEFT_ANGLE = 375, /* LEFT_ANGLE */ - YYSYMBOL_RIGHT_ANGLE = 376, /* RIGHT_ANGLE */ - YYSYMBOL_VERTICAL_BAR = 377, /* VERTICAL_BAR */ - YYSYMBOL_CARET = 378, /* CARET */ - YYSYMBOL_AMPERSAND = 379, /* AMPERSAND */ - YYSYMBOL_QUESTION = 380, /* QUESTION */ - YYSYMBOL_INVARIANT = 381, /* INVARIANT */ - YYSYMBOL_HIGH_PRECISION = 382, /* HIGH_PRECISION */ - YYSYMBOL_MEDIUM_PRECISION = 383, /* MEDIUM_PRECISION */ - YYSYMBOL_LOW_PRECISION = 384, /* LOW_PRECISION */ - YYSYMBOL_PRECISION = 385, /* PRECISION */ - YYSYMBOL_PACKED = 386, /* PACKED */ - YYSYMBOL_RESOURCE = 387, /* RESOURCE */ - YYSYMBOL_SUPERP = 388, /* SUPERP */ - YYSYMBOL_FLOATCONSTANT = 389, /* FLOATCONSTANT */ - YYSYMBOL_INTCONSTANT = 390, /* INTCONSTANT */ - YYSYMBOL_UINTCONSTANT = 391, /* UINTCONSTANT */ - YYSYMBOL_BOOLCONSTANT = 392, /* BOOLCONSTANT */ - YYSYMBOL_IDENTIFIER = 393, /* IDENTIFIER */ - YYSYMBOL_TYPE_NAME = 394, /* TYPE_NAME */ - YYSYMBOL_CENTROID = 395, /* CENTROID */ - YYSYMBOL_IN = 396, /* IN */ - YYSYMBOL_OUT = 397, /* OUT */ - YYSYMBOL_INOUT = 398, /* INOUT */ - YYSYMBOL_STRUCT = 399, /* STRUCT */ - YYSYMBOL_VOID = 400, /* VOID */ - YYSYMBOL_WHILE = 401, /* WHILE */ - YYSYMBOL_BREAK = 402, /* BREAK */ - YYSYMBOL_CONTINUE = 403, /* CONTINUE */ - YYSYMBOL_DO = 404, /* DO */ - YYSYMBOL_ELSE = 405, /* ELSE */ - YYSYMBOL_FOR = 406, /* FOR */ - YYSYMBOL_IF = 407, /* IF */ - YYSYMBOL_DISCARD = 408, /* DISCARD */ - YYSYMBOL_RETURN = 409, /* RETURN */ - YYSYMBOL_SWITCH = 410, /* SWITCH */ - YYSYMBOL_CASE = 411, /* CASE */ - YYSYMBOL_DEFAULT = 412, /* DEFAULT */ - YYSYMBOL_TERMINATE_INVOCATION = 413, /* TERMINATE_INVOCATION */ - YYSYMBOL_TERMINATE_RAY = 414, /* TERMINATE_RAY */ - YYSYMBOL_IGNORE_INTERSECTION = 415, /* IGNORE_INTERSECTION */ - YYSYMBOL_UNIFORM = 416, /* UNIFORM */ - YYSYMBOL_SHARED = 417, /* SHARED */ - YYSYMBOL_BUFFER = 418, /* BUFFER */ - YYSYMBOL_TILEIMAGEEXT = 419, /* TILEIMAGEEXT */ - YYSYMBOL_FLAT = 420, /* FLAT */ - YYSYMBOL_SMOOTH = 421, /* SMOOTH */ - YYSYMBOL_LAYOUT = 422, /* LAYOUT */ - YYSYMBOL_DOUBLECONSTANT = 423, /* DOUBLECONSTANT */ - YYSYMBOL_INT16CONSTANT = 424, /* INT16CONSTANT */ - YYSYMBOL_UINT16CONSTANT = 425, /* UINT16CONSTANT */ - YYSYMBOL_FLOAT16CONSTANT = 426, /* FLOAT16CONSTANT */ - YYSYMBOL_INT32CONSTANT = 427, /* INT32CONSTANT */ - YYSYMBOL_UINT32CONSTANT = 428, /* UINT32CONSTANT */ - YYSYMBOL_INT64CONSTANT = 429, /* INT64CONSTANT */ - YYSYMBOL_UINT64CONSTANT = 430, /* UINT64CONSTANT */ - YYSYMBOL_SUBROUTINE = 431, /* SUBROUTINE */ - YYSYMBOL_DEMOTE = 432, /* DEMOTE */ - YYSYMBOL_FUNCTION = 433, /* FUNCTION */ - YYSYMBOL_PAYLOADNV = 434, /* PAYLOADNV */ - YYSYMBOL_PAYLOADINNV = 435, /* PAYLOADINNV */ - YYSYMBOL_HITATTRNV = 436, /* HITATTRNV */ - YYSYMBOL_CALLDATANV = 437, /* CALLDATANV */ - YYSYMBOL_CALLDATAINNV = 438, /* CALLDATAINNV */ - YYSYMBOL_PAYLOADEXT = 439, /* PAYLOADEXT */ - YYSYMBOL_PAYLOADINEXT = 440, /* PAYLOADINEXT */ - YYSYMBOL_HITATTREXT = 441, /* HITATTREXT */ - YYSYMBOL_CALLDATAEXT = 442, /* CALLDATAEXT */ - YYSYMBOL_CALLDATAINEXT = 443, /* CALLDATAINEXT */ - YYSYMBOL_PATCH = 444, /* PATCH */ - YYSYMBOL_SAMPLE = 445, /* SAMPLE */ - YYSYMBOL_NONUNIFORM = 446, /* NONUNIFORM */ - YYSYMBOL_COHERENT = 447, /* COHERENT */ - YYSYMBOL_VOLATILE = 448, /* VOLATILE */ - YYSYMBOL_RESTRICT = 449, /* RESTRICT */ - YYSYMBOL_READONLY = 450, /* READONLY */ - YYSYMBOL_WRITEONLY = 451, /* WRITEONLY */ - YYSYMBOL_DEVICECOHERENT = 452, /* DEVICECOHERENT */ - YYSYMBOL_QUEUEFAMILYCOHERENT = 453, /* QUEUEFAMILYCOHERENT */ - YYSYMBOL_WORKGROUPCOHERENT = 454, /* WORKGROUPCOHERENT */ - YYSYMBOL_SUBGROUPCOHERENT = 455, /* SUBGROUPCOHERENT */ - YYSYMBOL_NONPRIVATE = 456, /* NONPRIVATE */ - YYSYMBOL_SHADERCALLCOHERENT = 457, /* SHADERCALLCOHERENT */ - YYSYMBOL_NOPERSPECTIVE = 458, /* NOPERSPECTIVE */ - YYSYMBOL_EXPLICITINTERPAMD = 459, /* EXPLICITINTERPAMD */ - YYSYMBOL_PERVERTEXEXT = 460, /* PERVERTEXEXT */ - YYSYMBOL_PERVERTEXNV = 461, /* PERVERTEXNV */ - YYSYMBOL_PERPRIMITIVENV = 462, /* PERPRIMITIVENV */ - YYSYMBOL_PERVIEWNV = 463, /* PERVIEWNV */ - YYSYMBOL_PERTASKNV = 464, /* PERTASKNV */ - YYSYMBOL_PERPRIMITIVEEXT = 465, /* PERPRIMITIVEEXT */ - YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 466, /* TASKPAYLOADWORKGROUPEXT */ - YYSYMBOL_PRECISE = 467, /* PRECISE */ - YYSYMBOL_YYACCEPT = 468, /* $accept */ - YYSYMBOL_variable_identifier = 469, /* variable_identifier */ - YYSYMBOL_primary_expression = 470, /* primary_expression */ - YYSYMBOL_postfix_expression = 471, /* postfix_expression */ - YYSYMBOL_integer_expression = 472, /* integer_expression */ - YYSYMBOL_function_call = 473, /* function_call */ - YYSYMBOL_function_call_or_method = 474, /* function_call_or_method */ - YYSYMBOL_function_call_generic = 475, /* function_call_generic */ - YYSYMBOL_function_call_header_no_parameters = 476, /* function_call_header_no_parameters */ - YYSYMBOL_function_call_header_with_parameters = 477, /* function_call_header_with_parameters */ - YYSYMBOL_function_call_header = 478, /* function_call_header */ - YYSYMBOL_function_identifier = 479, /* function_identifier */ - YYSYMBOL_unary_expression = 480, /* unary_expression */ - YYSYMBOL_unary_operator = 481, /* unary_operator */ - YYSYMBOL_multiplicative_expression = 482, /* multiplicative_expression */ - YYSYMBOL_additive_expression = 483, /* additive_expression */ - YYSYMBOL_shift_expression = 484, /* shift_expression */ - YYSYMBOL_relational_expression = 485, /* relational_expression */ - YYSYMBOL_equality_expression = 486, /* equality_expression */ - YYSYMBOL_and_expression = 487, /* and_expression */ - YYSYMBOL_exclusive_or_expression = 488, /* exclusive_or_expression */ - YYSYMBOL_inclusive_or_expression = 489, /* inclusive_or_expression */ - YYSYMBOL_logical_and_expression = 490, /* logical_and_expression */ - YYSYMBOL_logical_xor_expression = 491, /* logical_xor_expression */ - YYSYMBOL_logical_or_expression = 492, /* logical_or_expression */ - YYSYMBOL_conditional_expression = 493, /* conditional_expression */ - YYSYMBOL_494_1 = 494, /* $@1 */ - YYSYMBOL_assignment_expression = 495, /* assignment_expression */ - YYSYMBOL_assignment_operator = 496, /* assignment_operator */ - YYSYMBOL_expression = 497, /* expression */ - YYSYMBOL_constant_expression = 498, /* constant_expression */ - YYSYMBOL_declaration = 499, /* declaration */ - YYSYMBOL_block_structure = 500, /* block_structure */ - YYSYMBOL_501_2 = 501, /* $@2 */ - YYSYMBOL_identifier_list = 502, /* identifier_list */ - YYSYMBOL_function_prototype = 503, /* function_prototype */ - YYSYMBOL_function_declarator = 504, /* function_declarator */ - YYSYMBOL_function_header_with_parameters = 505, /* function_header_with_parameters */ - YYSYMBOL_function_header = 506, /* function_header */ - YYSYMBOL_parameter_declarator = 507, /* parameter_declarator */ - YYSYMBOL_parameter_declaration = 508, /* parameter_declaration */ - YYSYMBOL_parameter_type_specifier = 509, /* parameter_type_specifier */ - YYSYMBOL_init_declarator_list = 510, /* init_declarator_list */ - YYSYMBOL_single_declaration = 511, /* single_declaration */ - YYSYMBOL_fully_specified_type = 512, /* fully_specified_type */ - YYSYMBOL_invariant_qualifier = 513, /* invariant_qualifier */ - YYSYMBOL_interpolation_qualifier = 514, /* interpolation_qualifier */ - YYSYMBOL_layout_qualifier = 515, /* layout_qualifier */ - YYSYMBOL_layout_qualifier_id_list = 516, /* layout_qualifier_id_list */ - YYSYMBOL_layout_qualifier_id = 517, /* layout_qualifier_id */ - YYSYMBOL_precise_qualifier = 518, /* precise_qualifier */ - YYSYMBOL_type_qualifier = 519, /* type_qualifier */ - YYSYMBOL_single_type_qualifier = 520, /* single_type_qualifier */ - YYSYMBOL_storage_qualifier = 521, /* storage_qualifier */ - YYSYMBOL_non_uniform_qualifier = 522, /* non_uniform_qualifier */ - YYSYMBOL_type_name_list = 523, /* type_name_list */ - YYSYMBOL_type_specifier = 524, /* type_specifier */ - YYSYMBOL_array_specifier = 525, /* array_specifier */ - YYSYMBOL_type_parameter_specifier_opt = 526, /* type_parameter_specifier_opt */ - YYSYMBOL_type_parameter_specifier = 527, /* type_parameter_specifier */ - YYSYMBOL_type_parameter_specifier_list = 528, /* type_parameter_specifier_list */ - YYSYMBOL_type_specifier_nonarray = 529, /* type_specifier_nonarray */ - YYSYMBOL_precision_qualifier = 530, /* precision_qualifier */ - YYSYMBOL_struct_specifier = 531, /* struct_specifier */ - YYSYMBOL_532_3 = 532, /* $@3 */ - YYSYMBOL_533_4 = 533, /* $@4 */ - YYSYMBOL_struct_declaration_list = 534, /* struct_declaration_list */ - YYSYMBOL_struct_declaration = 535, /* struct_declaration */ - YYSYMBOL_struct_declarator_list = 536, /* struct_declarator_list */ - YYSYMBOL_struct_declarator = 537, /* struct_declarator */ - YYSYMBOL_initializer = 538, /* initializer */ - YYSYMBOL_initializer_list = 539, /* initializer_list */ - YYSYMBOL_declaration_statement = 540, /* declaration_statement */ - YYSYMBOL_statement = 541, /* statement */ - YYSYMBOL_simple_statement = 542, /* simple_statement */ - YYSYMBOL_demote_statement = 543, /* demote_statement */ - YYSYMBOL_compound_statement = 544, /* compound_statement */ - YYSYMBOL_545_5 = 545, /* $@5 */ - YYSYMBOL_546_6 = 546, /* $@6 */ - YYSYMBOL_statement_no_new_scope = 547, /* statement_no_new_scope */ - YYSYMBOL_statement_scoped = 548, /* statement_scoped */ - YYSYMBOL_549_7 = 549, /* $@7 */ - YYSYMBOL_550_8 = 550, /* $@8 */ - YYSYMBOL_compound_statement_no_new_scope = 551, /* compound_statement_no_new_scope */ - YYSYMBOL_statement_list = 552, /* statement_list */ - YYSYMBOL_expression_statement = 553, /* expression_statement */ - YYSYMBOL_selection_statement = 554, /* selection_statement */ - YYSYMBOL_selection_statement_nonattributed = 555, /* selection_statement_nonattributed */ - YYSYMBOL_selection_rest_statement = 556, /* selection_rest_statement */ - YYSYMBOL_condition = 557, /* condition */ - YYSYMBOL_switch_statement = 558, /* switch_statement */ - YYSYMBOL_switch_statement_nonattributed = 559, /* switch_statement_nonattributed */ - YYSYMBOL_560_9 = 560, /* $@9 */ - YYSYMBOL_switch_statement_list = 561, /* switch_statement_list */ - YYSYMBOL_case_label = 562, /* case_label */ - YYSYMBOL_iteration_statement = 563, /* iteration_statement */ - YYSYMBOL_iteration_statement_nonattributed = 564, /* iteration_statement_nonattributed */ - YYSYMBOL_565_10 = 565, /* $@10 */ - YYSYMBOL_566_11 = 566, /* $@11 */ - YYSYMBOL_567_12 = 567, /* $@12 */ - YYSYMBOL_for_init_statement = 568, /* for_init_statement */ - YYSYMBOL_conditionopt = 569, /* conditionopt */ - YYSYMBOL_for_rest_statement = 570, /* for_rest_statement */ - YYSYMBOL_jump_statement = 571, /* jump_statement */ - YYSYMBOL_translation_unit = 572, /* translation_unit */ - YYSYMBOL_external_declaration = 573, /* external_declaration */ - YYSYMBOL_function_definition = 574, /* function_definition */ - YYSYMBOL_575_13 = 575, /* $@13 */ - YYSYMBOL_attribute = 576, /* attribute */ - YYSYMBOL_attribute_list = 577, /* attribute_list */ - YYSYMBOL_single_attribute = 578, /* single_attribute */ - YYSYMBOL_spirv_requirements_list = 579, /* spirv_requirements_list */ - YYSYMBOL_spirv_requirements_parameter = 580, /* spirv_requirements_parameter */ - YYSYMBOL_spirv_extension_list = 581, /* spirv_extension_list */ - YYSYMBOL_spirv_capability_list = 582, /* spirv_capability_list */ - YYSYMBOL_spirv_execution_mode_qualifier = 583, /* spirv_execution_mode_qualifier */ - YYSYMBOL_spirv_execution_mode_parameter_list = 584, /* spirv_execution_mode_parameter_list */ - YYSYMBOL_spirv_execution_mode_parameter = 585, /* spirv_execution_mode_parameter */ - YYSYMBOL_spirv_execution_mode_id_parameter_list = 586, /* spirv_execution_mode_id_parameter_list */ - YYSYMBOL_spirv_storage_class_qualifier = 587, /* spirv_storage_class_qualifier */ - YYSYMBOL_spirv_decorate_qualifier = 588, /* spirv_decorate_qualifier */ - YYSYMBOL_spirv_decorate_parameter_list = 589, /* spirv_decorate_parameter_list */ - YYSYMBOL_spirv_decorate_parameter = 590, /* spirv_decorate_parameter */ - YYSYMBOL_spirv_decorate_id_parameter_list = 591, /* spirv_decorate_id_parameter_list */ - YYSYMBOL_spirv_decorate_id_parameter = 592, /* spirv_decorate_id_parameter */ - YYSYMBOL_spirv_decorate_string_parameter_list = 593, /* spirv_decorate_string_parameter_list */ - YYSYMBOL_spirv_type_specifier = 594, /* spirv_type_specifier */ - YYSYMBOL_spirv_type_parameter_list = 595, /* spirv_type_parameter_list */ - YYSYMBOL_spirv_type_parameter = 596, /* spirv_type_parameter */ - YYSYMBOL_spirv_instruction_qualifier = 597, /* spirv_instruction_qualifier */ - YYSYMBOL_spirv_instruction_qualifier_list = 598, /* spirv_instruction_qualifier_list */ - YYSYMBOL_spirv_instruction_qualifier_id = 599 /* spirv_instruction_qualifier_id */ + YYSYMBOL_COOPVECNV = 167, /* COOPVECNV */ + YYSYMBOL_HITOBJECTNV = 168, /* HITOBJECTNV */ + YYSYMBOL_HITOBJECTATTRNV = 169, /* HITOBJECTATTRNV */ + YYSYMBOL_TENSORLAYOUTNV = 170, /* TENSORLAYOUTNV */ + YYSYMBOL_TENSORVIEWNV = 171, /* TENSORVIEWNV */ + YYSYMBOL_SAMPLERCUBEARRAY = 172, /* SAMPLERCUBEARRAY */ + YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 173, /* SAMPLERCUBEARRAYSHADOW */ + YYSYMBOL_ISAMPLERCUBEARRAY = 174, /* ISAMPLERCUBEARRAY */ + YYSYMBOL_USAMPLERCUBEARRAY = 175, /* USAMPLERCUBEARRAY */ + YYSYMBOL_SAMPLER1D = 176, /* SAMPLER1D */ + YYSYMBOL_SAMPLER1DARRAY = 177, /* SAMPLER1DARRAY */ + YYSYMBOL_SAMPLER1DARRAYSHADOW = 178, /* SAMPLER1DARRAYSHADOW */ + YYSYMBOL_ISAMPLER1D = 179, /* ISAMPLER1D */ + YYSYMBOL_SAMPLER1DSHADOW = 180, /* SAMPLER1DSHADOW */ + YYSYMBOL_SAMPLER2DRECT = 181, /* SAMPLER2DRECT */ + YYSYMBOL_SAMPLER2DRECTSHADOW = 182, /* SAMPLER2DRECTSHADOW */ + YYSYMBOL_ISAMPLER2DRECT = 183, /* ISAMPLER2DRECT */ + YYSYMBOL_USAMPLER2DRECT = 184, /* USAMPLER2DRECT */ + YYSYMBOL_SAMPLERBUFFER = 185, /* SAMPLERBUFFER */ + YYSYMBOL_ISAMPLERBUFFER = 186, /* ISAMPLERBUFFER */ + YYSYMBOL_USAMPLERBUFFER = 187, /* USAMPLERBUFFER */ + YYSYMBOL_SAMPLER2DMS = 188, /* SAMPLER2DMS */ + YYSYMBOL_ISAMPLER2DMS = 189, /* ISAMPLER2DMS */ + YYSYMBOL_USAMPLER2DMS = 190, /* USAMPLER2DMS */ + YYSYMBOL_SAMPLER2DMSARRAY = 191, /* SAMPLER2DMSARRAY */ + YYSYMBOL_ISAMPLER2DMSARRAY = 192, /* ISAMPLER2DMSARRAY */ + YYSYMBOL_USAMPLER2DMSARRAY = 193, /* USAMPLER2DMSARRAY */ + YYSYMBOL_SAMPLEREXTERNALOES = 194, /* SAMPLEREXTERNALOES */ + YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 195, /* SAMPLEREXTERNAL2DY2YEXT */ + YYSYMBOL_ISAMPLER1DARRAY = 196, /* ISAMPLER1DARRAY */ + YYSYMBOL_USAMPLER1D = 197, /* USAMPLER1D */ + YYSYMBOL_USAMPLER1DARRAY = 198, /* USAMPLER1DARRAY */ + YYSYMBOL_F16SAMPLER1D = 199, /* F16SAMPLER1D */ + YYSYMBOL_F16SAMPLER2D = 200, /* F16SAMPLER2D */ + YYSYMBOL_F16SAMPLER3D = 201, /* F16SAMPLER3D */ + YYSYMBOL_F16SAMPLER2DRECT = 202, /* F16SAMPLER2DRECT */ + YYSYMBOL_F16SAMPLERCUBE = 203, /* F16SAMPLERCUBE */ + YYSYMBOL_F16SAMPLER1DARRAY = 204, /* F16SAMPLER1DARRAY */ + YYSYMBOL_F16SAMPLER2DARRAY = 205, /* F16SAMPLER2DARRAY */ + YYSYMBOL_F16SAMPLERCUBEARRAY = 206, /* F16SAMPLERCUBEARRAY */ + YYSYMBOL_F16SAMPLERBUFFER = 207, /* F16SAMPLERBUFFER */ + YYSYMBOL_F16SAMPLER2DMS = 208, /* F16SAMPLER2DMS */ + YYSYMBOL_F16SAMPLER2DMSARRAY = 209, /* F16SAMPLER2DMSARRAY */ + YYSYMBOL_F16SAMPLER1DSHADOW = 210, /* F16SAMPLER1DSHADOW */ + YYSYMBOL_F16SAMPLER2DSHADOW = 211, /* F16SAMPLER2DSHADOW */ + YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 212, /* F16SAMPLER1DARRAYSHADOW */ + YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 213, /* F16SAMPLER2DARRAYSHADOW */ + YYSYMBOL_F16SAMPLER2DRECTSHADOW = 214, /* F16SAMPLER2DRECTSHADOW */ + YYSYMBOL_F16SAMPLERCUBESHADOW = 215, /* F16SAMPLERCUBESHADOW */ + YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 216, /* F16SAMPLERCUBEARRAYSHADOW */ + YYSYMBOL_IMAGE1D = 217, /* IMAGE1D */ + YYSYMBOL_IIMAGE1D = 218, /* IIMAGE1D */ + YYSYMBOL_UIMAGE1D = 219, /* UIMAGE1D */ + YYSYMBOL_IMAGE2D = 220, /* IMAGE2D */ + YYSYMBOL_IIMAGE2D = 221, /* IIMAGE2D */ + YYSYMBOL_UIMAGE2D = 222, /* UIMAGE2D */ + YYSYMBOL_IMAGE3D = 223, /* IMAGE3D */ + YYSYMBOL_IIMAGE3D = 224, /* IIMAGE3D */ + YYSYMBOL_UIMAGE3D = 225, /* UIMAGE3D */ + YYSYMBOL_IMAGE2DRECT = 226, /* IMAGE2DRECT */ + YYSYMBOL_IIMAGE2DRECT = 227, /* IIMAGE2DRECT */ + YYSYMBOL_UIMAGE2DRECT = 228, /* UIMAGE2DRECT */ + YYSYMBOL_IMAGECUBE = 229, /* IMAGECUBE */ + YYSYMBOL_IIMAGECUBE = 230, /* IIMAGECUBE */ + YYSYMBOL_UIMAGECUBE = 231, /* UIMAGECUBE */ + YYSYMBOL_IMAGEBUFFER = 232, /* IMAGEBUFFER */ + YYSYMBOL_IIMAGEBUFFER = 233, /* IIMAGEBUFFER */ + YYSYMBOL_UIMAGEBUFFER = 234, /* UIMAGEBUFFER */ + YYSYMBOL_IMAGE1DARRAY = 235, /* IMAGE1DARRAY */ + YYSYMBOL_IIMAGE1DARRAY = 236, /* IIMAGE1DARRAY */ + YYSYMBOL_UIMAGE1DARRAY = 237, /* UIMAGE1DARRAY */ + YYSYMBOL_IMAGE2DARRAY = 238, /* IMAGE2DARRAY */ + YYSYMBOL_IIMAGE2DARRAY = 239, /* IIMAGE2DARRAY */ + YYSYMBOL_UIMAGE2DARRAY = 240, /* UIMAGE2DARRAY */ + YYSYMBOL_IMAGECUBEARRAY = 241, /* IMAGECUBEARRAY */ + YYSYMBOL_IIMAGECUBEARRAY = 242, /* IIMAGECUBEARRAY */ + YYSYMBOL_UIMAGECUBEARRAY = 243, /* UIMAGECUBEARRAY */ + YYSYMBOL_IMAGE2DMS = 244, /* IMAGE2DMS */ + YYSYMBOL_IIMAGE2DMS = 245, /* IIMAGE2DMS */ + YYSYMBOL_UIMAGE2DMS = 246, /* UIMAGE2DMS */ + YYSYMBOL_IMAGE2DMSARRAY = 247, /* IMAGE2DMSARRAY */ + YYSYMBOL_IIMAGE2DMSARRAY = 248, /* IIMAGE2DMSARRAY */ + YYSYMBOL_UIMAGE2DMSARRAY = 249, /* UIMAGE2DMSARRAY */ + YYSYMBOL_F16IMAGE1D = 250, /* F16IMAGE1D */ + YYSYMBOL_F16IMAGE2D = 251, /* F16IMAGE2D */ + YYSYMBOL_F16IMAGE3D = 252, /* F16IMAGE3D */ + YYSYMBOL_F16IMAGE2DRECT = 253, /* F16IMAGE2DRECT */ + YYSYMBOL_F16IMAGECUBE = 254, /* F16IMAGECUBE */ + YYSYMBOL_F16IMAGE1DARRAY = 255, /* F16IMAGE1DARRAY */ + YYSYMBOL_F16IMAGE2DARRAY = 256, /* F16IMAGE2DARRAY */ + YYSYMBOL_F16IMAGECUBEARRAY = 257, /* F16IMAGECUBEARRAY */ + YYSYMBOL_F16IMAGEBUFFER = 258, /* F16IMAGEBUFFER */ + YYSYMBOL_F16IMAGE2DMS = 259, /* F16IMAGE2DMS */ + YYSYMBOL_F16IMAGE2DMSARRAY = 260, /* F16IMAGE2DMSARRAY */ + YYSYMBOL_I64IMAGE1D = 261, /* I64IMAGE1D */ + YYSYMBOL_U64IMAGE1D = 262, /* U64IMAGE1D */ + YYSYMBOL_I64IMAGE2D = 263, /* I64IMAGE2D */ + YYSYMBOL_U64IMAGE2D = 264, /* U64IMAGE2D */ + YYSYMBOL_I64IMAGE3D = 265, /* I64IMAGE3D */ + YYSYMBOL_U64IMAGE3D = 266, /* U64IMAGE3D */ + YYSYMBOL_I64IMAGE2DRECT = 267, /* I64IMAGE2DRECT */ + YYSYMBOL_U64IMAGE2DRECT = 268, /* U64IMAGE2DRECT */ + YYSYMBOL_I64IMAGECUBE = 269, /* I64IMAGECUBE */ + YYSYMBOL_U64IMAGECUBE = 270, /* U64IMAGECUBE */ + YYSYMBOL_I64IMAGEBUFFER = 271, /* I64IMAGEBUFFER */ + YYSYMBOL_U64IMAGEBUFFER = 272, /* U64IMAGEBUFFER */ + YYSYMBOL_I64IMAGE1DARRAY = 273, /* I64IMAGE1DARRAY */ + YYSYMBOL_U64IMAGE1DARRAY = 274, /* U64IMAGE1DARRAY */ + YYSYMBOL_I64IMAGE2DARRAY = 275, /* I64IMAGE2DARRAY */ + YYSYMBOL_U64IMAGE2DARRAY = 276, /* U64IMAGE2DARRAY */ + YYSYMBOL_I64IMAGECUBEARRAY = 277, /* I64IMAGECUBEARRAY */ + YYSYMBOL_U64IMAGECUBEARRAY = 278, /* U64IMAGECUBEARRAY */ + YYSYMBOL_I64IMAGE2DMS = 279, /* I64IMAGE2DMS */ + YYSYMBOL_U64IMAGE2DMS = 280, /* U64IMAGE2DMS */ + YYSYMBOL_I64IMAGE2DMSARRAY = 281, /* I64IMAGE2DMSARRAY */ + YYSYMBOL_U64IMAGE2DMSARRAY = 282, /* U64IMAGE2DMSARRAY */ + YYSYMBOL_TEXTURECUBEARRAY = 283, /* TEXTURECUBEARRAY */ + YYSYMBOL_ITEXTURECUBEARRAY = 284, /* ITEXTURECUBEARRAY */ + YYSYMBOL_UTEXTURECUBEARRAY = 285, /* UTEXTURECUBEARRAY */ + YYSYMBOL_TEXTURE1D = 286, /* TEXTURE1D */ + YYSYMBOL_ITEXTURE1D = 287, /* ITEXTURE1D */ + YYSYMBOL_UTEXTURE1D = 288, /* UTEXTURE1D */ + YYSYMBOL_TEXTURE1DARRAY = 289, /* TEXTURE1DARRAY */ + YYSYMBOL_ITEXTURE1DARRAY = 290, /* ITEXTURE1DARRAY */ + YYSYMBOL_UTEXTURE1DARRAY = 291, /* UTEXTURE1DARRAY */ + YYSYMBOL_TEXTURE2DRECT = 292, /* TEXTURE2DRECT */ + YYSYMBOL_ITEXTURE2DRECT = 293, /* ITEXTURE2DRECT */ + YYSYMBOL_UTEXTURE2DRECT = 294, /* UTEXTURE2DRECT */ + YYSYMBOL_TEXTUREBUFFER = 295, /* TEXTUREBUFFER */ + YYSYMBOL_ITEXTUREBUFFER = 296, /* ITEXTUREBUFFER */ + YYSYMBOL_UTEXTUREBUFFER = 297, /* UTEXTUREBUFFER */ + YYSYMBOL_TEXTURE2DMS = 298, /* TEXTURE2DMS */ + YYSYMBOL_ITEXTURE2DMS = 299, /* ITEXTURE2DMS */ + YYSYMBOL_UTEXTURE2DMS = 300, /* UTEXTURE2DMS */ + YYSYMBOL_TEXTURE2DMSARRAY = 301, /* TEXTURE2DMSARRAY */ + YYSYMBOL_ITEXTURE2DMSARRAY = 302, /* ITEXTURE2DMSARRAY */ + YYSYMBOL_UTEXTURE2DMSARRAY = 303, /* UTEXTURE2DMSARRAY */ + YYSYMBOL_F16TEXTURE1D = 304, /* F16TEXTURE1D */ + YYSYMBOL_F16TEXTURE2D = 305, /* F16TEXTURE2D */ + YYSYMBOL_F16TEXTURE3D = 306, /* F16TEXTURE3D */ + YYSYMBOL_F16TEXTURE2DRECT = 307, /* F16TEXTURE2DRECT */ + YYSYMBOL_F16TEXTURECUBE = 308, /* F16TEXTURECUBE */ + YYSYMBOL_F16TEXTURE1DARRAY = 309, /* F16TEXTURE1DARRAY */ + YYSYMBOL_F16TEXTURE2DARRAY = 310, /* F16TEXTURE2DARRAY */ + YYSYMBOL_F16TEXTURECUBEARRAY = 311, /* F16TEXTURECUBEARRAY */ + YYSYMBOL_F16TEXTUREBUFFER = 312, /* F16TEXTUREBUFFER */ + YYSYMBOL_F16TEXTURE2DMS = 313, /* F16TEXTURE2DMS */ + YYSYMBOL_F16TEXTURE2DMSARRAY = 314, /* F16TEXTURE2DMSARRAY */ + YYSYMBOL_SUBPASSINPUT = 315, /* SUBPASSINPUT */ + YYSYMBOL_SUBPASSINPUTMS = 316, /* SUBPASSINPUTMS */ + YYSYMBOL_ISUBPASSINPUT = 317, /* ISUBPASSINPUT */ + YYSYMBOL_ISUBPASSINPUTMS = 318, /* ISUBPASSINPUTMS */ + YYSYMBOL_USUBPASSINPUT = 319, /* USUBPASSINPUT */ + YYSYMBOL_USUBPASSINPUTMS = 320, /* USUBPASSINPUTMS */ + YYSYMBOL_F16SUBPASSINPUT = 321, /* F16SUBPASSINPUT */ + YYSYMBOL_F16SUBPASSINPUTMS = 322, /* F16SUBPASSINPUTMS */ + YYSYMBOL_SPIRV_INSTRUCTION = 323, /* SPIRV_INSTRUCTION */ + YYSYMBOL_SPIRV_EXECUTION_MODE = 324, /* SPIRV_EXECUTION_MODE */ + YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 325, /* SPIRV_EXECUTION_MODE_ID */ + YYSYMBOL_SPIRV_DECORATE = 326, /* SPIRV_DECORATE */ + YYSYMBOL_SPIRV_DECORATE_ID = 327, /* SPIRV_DECORATE_ID */ + YYSYMBOL_SPIRV_DECORATE_STRING = 328, /* SPIRV_DECORATE_STRING */ + YYSYMBOL_SPIRV_TYPE = 329, /* SPIRV_TYPE */ + YYSYMBOL_SPIRV_STORAGE_CLASS = 330, /* SPIRV_STORAGE_CLASS */ + YYSYMBOL_SPIRV_BY_REFERENCE = 331, /* SPIRV_BY_REFERENCE */ + YYSYMBOL_SPIRV_LITERAL = 332, /* SPIRV_LITERAL */ + YYSYMBOL_ATTACHMENTEXT = 333, /* ATTACHMENTEXT */ + YYSYMBOL_IATTACHMENTEXT = 334, /* IATTACHMENTEXT */ + YYSYMBOL_UATTACHMENTEXT = 335, /* UATTACHMENTEXT */ + YYSYMBOL_LEFT_OP = 336, /* LEFT_OP */ + YYSYMBOL_RIGHT_OP = 337, /* RIGHT_OP */ + YYSYMBOL_INC_OP = 338, /* INC_OP */ + YYSYMBOL_DEC_OP = 339, /* DEC_OP */ + YYSYMBOL_LE_OP = 340, /* LE_OP */ + YYSYMBOL_GE_OP = 341, /* GE_OP */ + YYSYMBOL_EQ_OP = 342, /* EQ_OP */ + YYSYMBOL_NE_OP = 343, /* NE_OP */ + YYSYMBOL_AND_OP = 344, /* AND_OP */ + YYSYMBOL_OR_OP = 345, /* OR_OP */ + YYSYMBOL_XOR_OP = 346, /* XOR_OP */ + YYSYMBOL_MUL_ASSIGN = 347, /* MUL_ASSIGN */ + YYSYMBOL_DIV_ASSIGN = 348, /* DIV_ASSIGN */ + YYSYMBOL_ADD_ASSIGN = 349, /* ADD_ASSIGN */ + YYSYMBOL_MOD_ASSIGN = 350, /* MOD_ASSIGN */ + YYSYMBOL_LEFT_ASSIGN = 351, /* LEFT_ASSIGN */ + YYSYMBOL_RIGHT_ASSIGN = 352, /* RIGHT_ASSIGN */ + YYSYMBOL_AND_ASSIGN = 353, /* AND_ASSIGN */ + YYSYMBOL_XOR_ASSIGN = 354, /* XOR_ASSIGN */ + YYSYMBOL_OR_ASSIGN = 355, /* OR_ASSIGN */ + YYSYMBOL_SUB_ASSIGN = 356, /* SUB_ASSIGN */ + YYSYMBOL_STRING_LITERAL = 357, /* STRING_LITERAL */ + YYSYMBOL_LEFT_PAREN = 358, /* LEFT_PAREN */ + YYSYMBOL_RIGHT_PAREN = 359, /* RIGHT_PAREN */ + YYSYMBOL_LEFT_BRACKET = 360, /* LEFT_BRACKET */ + YYSYMBOL_RIGHT_BRACKET = 361, /* RIGHT_BRACKET */ + YYSYMBOL_LEFT_BRACE = 362, /* LEFT_BRACE */ + YYSYMBOL_RIGHT_BRACE = 363, /* RIGHT_BRACE */ + YYSYMBOL_DOT = 364, /* DOT */ + YYSYMBOL_COMMA = 365, /* COMMA */ + YYSYMBOL_COLON = 366, /* COLON */ + YYSYMBOL_EQUAL = 367, /* EQUAL */ + YYSYMBOL_SEMICOLON = 368, /* SEMICOLON */ + YYSYMBOL_BANG = 369, /* BANG */ + YYSYMBOL_DASH = 370, /* DASH */ + YYSYMBOL_TILDE = 371, /* TILDE */ + YYSYMBOL_PLUS = 372, /* PLUS */ + YYSYMBOL_STAR = 373, /* STAR */ + YYSYMBOL_SLASH = 374, /* SLASH */ + YYSYMBOL_PERCENT = 375, /* PERCENT */ + YYSYMBOL_LEFT_ANGLE = 376, /* LEFT_ANGLE */ + YYSYMBOL_RIGHT_ANGLE = 377, /* RIGHT_ANGLE */ + YYSYMBOL_VERTICAL_BAR = 378, /* VERTICAL_BAR */ + YYSYMBOL_CARET = 379, /* CARET */ + YYSYMBOL_AMPERSAND = 380, /* AMPERSAND */ + YYSYMBOL_QUESTION = 381, /* QUESTION */ + YYSYMBOL_INVARIANT = 382, /* INVARIANT */ + YYSYMBOL_HIGH_PRECISION = 383, /* HIGH_PRECISION */ + YYSYMBOL_MEDIUM_PRECISION = 384, /* MEDIUM_PRECISION */ + YYSYMBOL_LOW_PRECISION = 385, /* LOW_PRECISION */ + YYSYMBOL_PRECISION = 386, /* PRECISION */ + YYSYMBOL_PACKED = 387, /* PACKED */ + YYSYMBOL_RESOURCE = 388, /* RESOURCE */ + YYSYMBOL_SUPERP = 389, /* SUPERP */ + YYSYMBOL_FLOATCONSTANT = 390, /* FLOATCONSTANT */ + YYSYMBOL_INTCONSTANT = 391, /* INTCONSTANT */ + YYSYMBOL_UINTCONSTANT = 392, /* UINTCONSTANT */ + YYSYMBOL_BOOLCONSTANT = 393, /* BOOLCONSTANT */ + YYSYMBOL_IDENTIFIER = 394, /* IDENTIFIER */ + YYSYMBOL_TYPE_NAME = 395, /* TYPE_NAME */ + YYSYMBOL_CENTROID = 396, /* CENTROID */ + YYSYMBOL_IN = 397, /* IN */ + YYSYMBOL_OUT = 398, /* OUT */ + YYSYMBOL_INOUT = 399, /* INOUT */ + YYSYMBOL_STRUCT = 400, /* STRUCT */ + YYSYMBOL_VOID = 401, /* VOID */ + YYSYMBOL_WHILE = 402, /* WHILE */ + YYSYMBOL_BREAK = 403, /* BREAK */ + YYSYMBOL_CONTINUE = 404, /* CONTINUE */ + YYSYMBOL_DO = 405, /* DO */ + YYSYMBOL_ELSE = 406, /* ELSE */ + YYSYMBOL_FOR = 407, /* FOR */ + YYSYMBOL_IF = 408, /* IF */ + YYSYMBOL_DISCARD = 409, /* DISCARD */ + YYSYMBOL_RETURN = 410, /* RETURN */ + YYSYMBOL_SWITCH = 411, /* SWITCH */ + YYSYMBOL_CASE = 412, /* CASE */ + YYSYMBOL_DEFAULT = 413, /* DEFAULT */ + YYSYMBOL_TERMINATE_INVOCATION = 414, /* TERMINATE_INVOCATION */ + YYSYMBOL_TERMINATE_RAY = 415, /* TERMINATE_RAY */ + YYSYMBOL_IGNORE_INTERSECTION = 416, /* IGNORE_INTERSECTION */ + YYSYMBOL_UNIFORM = 417, /* UNIFORM */ + YYSYMBOL_SHARED = 418, /* SHARED */ + YYSYMBOL_BUFFER = 419, /* BUFFER */ + YYSYMBOL_TILEIMAGEEXT = 420, /* TILEIMAGEEXT */ + YYSYMBOL_FLAT = 421, /* FLAT */ + YYSYMBOL_SMOOTH = 422, /* SMOOTH */ + YYSYMBOL_LAYOUT = 423, /* LAYOUT */ + YYSYMBOL_DOUBLECONSTANT = 424, /* DOUBLECONSTANT */ + YYSYMBOL_INT16CONSTANT = 425, /* INT16CONSTANT */ + YYSYMBOL_UINT16CONSTANT = 426, /* UINT16CONSTANT */ + YYSYMBOL_FLOAT16CONSTANT = 427, /* FLOAT16CONSTANT */ + YYSYMBOL_INT32CONSTANT = 428, /* INT32CONSTANT */ + YYSYMBOL_UINT32CONSTANT = 429, /* UINT32CONSTANT */ + YYSYMBOL_INT64CONSTANT = 430, /* INT64CONSTANT */ + YYSYMBOL_UINT64CONSTANT = 431, /* UINT64CONSTANT */ + YYSYMBOL_SUBROUTINE = 432, /* SUBROUTINE */ + YYSYMBOL_DEMOTE = 433, /* DEMOTE */ + YYSYMBOL_FUNCTION = 434, /* FUNCTION */ + YYSYMBOL_PAYLOADNV = 435, /* PAYLOADNV */ + YYSYMBOL_PAYLOADINNV = 436, /* PAYLOADINNV */ + YYSYMBOL_HITATTRNV = 437, /* HITATTRNV */ + YYSYMBOL_CALLDATANV = 438, /* CALLDATANV */ + YYSYMBOL_CALLDATAINNV = 439, /* CALLDATAINNV */ + YYSYMBOL_PAYLOADEXT = 440, /* PAYLOADEXT */ + YYSYMBOL_PAYLOADINEXT = 441, /* PAYLOADINEXT */ + YYSYMBOL_HITATTREXT = 442, /* HITATTREXT */ + YYSYMBOL_CALLDATAEXT = 443, /* CALLDATAEXT */ + YYSYMBOL_CALLDATAINEXT = 444, /* CALLDATAINEXT */ + YYSYMBOL_PATCH = 445, /* PATCH */ + YYSYMBOL_SAMPLE = 446, /* SAMPLE */ + YYSYMBOL_NONUNIFORM = 447, /* NONUNIFORM */ + YYSYMBOL_COHERENT = 448, /* COHERENT */ + YYSYMBOL_VOLATILE = 449, /* VOLATILE */ + YYSYMBOL_RESTRICT = 450, /* RESTRICT */ + YYSYMBOL_READONLY = 451, /* READONLY */ + YYSYMBOL_WRITEONLY = 452, /* WRITEONLY */ + YYSYMBOL_DEVICECOHERENT = 453, /* DEVICECOHERENT */ + YYSYMBOL_QUEUEFAMILYCOHERENT = 454, /* QUEUEFAMILYCOHERENT */ + YYSYMBOL_WORKGROUPCOHERENT = 455, /* WORKGROUPCOHERENT */ + YYSYMBOL_SUBGROUPCOHERENT = 456, /* SUBGROUPCOHERENT */ + YYSYMBOL_NONPRIVATE = 457, /* NONPRIVATE */ + YYSYMBOL_SHADERCALLCOHERENT = 458, /* SHADERCALLCOHERENT */ + YYSYMBOL_NOPERSPECTIVE = 459, /* NOPERSPECTIVE */ + YYSYMBOL_EXPLICITINTERPAMD = 460, /* EXPLICITINTERPAMD */ + YYSYMBOL_PERVERTEXEXT = 461, /* PERVERTEXEXT */ + YYSYMBOL_PERVERTEXNV = 462, /* PERVERTEXNV */ + YYSYMBOL_PERPRIMITIVENV = 463, /* PERPRIMITIVENV */ + YYSYMBOL_PERVIEWNV = 464, /* PERVIEWNV */ + YYSYMBOL_PERTASKNV = 465, /* PERTASKNV */ + YYSYMBOL_PERPRIMITIVEEXT = 466, /* PERPRIMITIVEEXT */ + YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 467, /* TASKPAYLOADWORKGROUPEXT */ + YYSYMBOL_PRECISE = 468, /* PRECISE */ + YYSYMBOL_YYACCEPT = 469, /* $accept */ + YYSYMBOL_variable_identifier = 470, /* variable_identifier */ + YYSYMBOL_primary_expression = 471, /* primary_expression */ + YYSYMBOL_postfix_expression = 472, /* postfix_expression */ + YYSYMBOL_integer_expression = 473, /* integer_expression */ + YYSYMBOL_function_call = 474, /* function_call */ + YYSYMBOL_function_call_or_method = 475, /* function_call_or_method */ + YYSYMBOL_function_call_generic = 476, /* function_call_generic */ + YYSYMBOL_function_call_header_no_parameters = 477, /* function_call_header_no_parameters */ + YYSYMBOL_function_call_header_with_parameters = 478, /* function_call_header_with_parameters */ + YYSYMBOL_function_call_header = 479, /* function_call_header */ + YYSYMBOL_function_identifier = 480, /* function_identifier */ + YYSYMBOL_unary_expression = 481, /* unary_expression */ + YYSYMBOL_unary_operator = 482, /* unary_operator */ + YYSYMBOL_multiplicative_expression = 483, /* multiplicative_expression */ + YYSYMBOL_additive_expression = 484, /* additive_expression */ + YYSYMBOL_shift_expression = 485, /* shift_expression */ + YYSYMBOL_relational_expression = 486, /* relational_expression */ + YYSYMBOL_equality_expression = 487, /* equality_expression */ + YYSYMBOL_and_expression = 488, /* and_expression */ + YYSYMBOL_exclusive_or_expression = 489, /* exclusive_or_expression */ + YYSYMBOL_inclusive_or_expression = 490, /* inclusive_or_expression */ + YYSYMBOL_logical_and_expression = 491, /* logical_and_expression */ + YYSYMBOL_logical_xor_expression = 492, /* logical_xor_expression */ + YYSYMBOL_logical_or_expression = 493, /* logical_or_expression */ + YYSYMBOL_conditional_expression = 494, /* conditional_expression */ + YYSYMBOL_495_1 = 495, /* $@1 */ + YYSYMBOL_assignment_expression = 496, /* assignment_expression */ + YYSYMBOL_assignment_operator = 497, /* assignment_operator */ + YYSYMBOL_expression = 498, /* expression */ + YYSYMBOL_constant_expression = 499, /* constant_expression */ + YYSYMBOL_declaration = 500, /* declaration */ + YYSYMBOL_block_structure = 501, /* block_structure */ + YYSYMBOL_502_2 = 502, /* $@2 */ + YYSYMBOL_identifier_list = 503, /* identifier_list */ + YYSYMBOL_function_prototype = 504, /* function_prototype */ + YYSYMBOL_function_declarator = 505, /* function_declarator */ + YYSYMBOL_function_header_with_parameters = 506, /* function_header_with_parameters */ + YYSYMBOL_function_header = 507, /* function_header */ + YYSYMBOL_parameter_declarator = 508, /* parameter_declarator */ + YYSYMBOL_parameter_declaration = 509, /* parameter_declaration */ + YYSYMBOL_parameter_type_specifier = 510, /* parameter_type_specifier */ + YYSYMBOL_init_declarator_list = 511, /* init_declarator_list */ + YYSYMBOL_single_declaration = 512, /* single_declaration */ + YYSYMBOL_fully_specified_type = 513, /* fully_specified_type */ + YYSYMBOL_invariant_qualifier = 514, /* invariant_qualifier */ + YYSYMBOL_interpolation_qualifier = 515, /* interpolation_qualifier */ + YYSYMBOL_layout_qualifier = 516, /* layout_qualifier */ + YYSYMBOL_layout_qualifier_id_list = 517, /* layout_qualifier_id_list */ + YYSYMBOL_layout_qualifier_id = 518, /* layout_qualifier_id */ + YYSYMBOL_precise_qualifier = 519, /* precise_qualifier */ + YYSYMBOL_type_qualifier = 520, /* type_qualifier */ + YYSYMBOL_single_type_qualifier = 521, /* single_type_qualifier */ + YYSYMBOL_storage_qualifier = 522, /* storage_qualifier */ + YYSYMBOL_non_uniform_qualifier = 523, /* non_uniform_qualifier */ + YYSYMBOL_type_name_list = 524, /* type_name_list */ + YYSYMBOL_type_specifier = 525, /* type_specifier */ + YYSYMBOL_array_specifier = 526, /* array_specifier */ + YYSYMBOL_type_parameter_specifier_opt = 527, /* type_parameter_specifier_opt */ + YYSYMBOL_type_parameter_specifier = 528, /* type_parameter_specifier */ + YYSYMBOL_type_parameter_specifier_list = 529, /* type_parameter_specifier_list */ + YYSYMBOL_type_specifier_nonarray = 530, /* type_specifier_nonarray */ + YYSYMBOL_precision_qualifier = 531, /* precision_qualifier */ + YYSYMBOL_struct_specifier = 532, /* struct_specifier */ + YYSYMBOL_533_3 = 533, /* $@3 */ + YYSYMBOL_534_4 = 534, /* $@4 */ + YYSYMBOL_struct_declaration_list = 535, /* struct_declaration_list */ + YYSYMBOL_struct_declaration = 536, /* struct_declaration */ + YYSYMBOL_struct_declarator_list = 537, /* struct_declarator_list */ + YYSYMBOL_struct_declarator = 538, /* struct_declarator */ + YYSYMBOL_initializer = 539, /* initializer */ + YYSYMBOL_initializer_list = 540, /* initializer_list */ + YYSYMBOL_declaration_statement = 541, /* declaration_statement */ + YYSYMBOL_statement = 542, /* statement */ + YYSYMBOL_simple_statement = 543, /* simple_statement */ + YYSYMBOL_demote_statement = 544, /* demote_statement */ + YYSYMBOL_compound_statement = 545, /* compound_statement */ + YYSYMBOL_546_5 = 546, /* $@5 */ + YYSYMBOL_547_6 = 547, /* $@6 */ + YYSYMBOL_statement_no_new_scope = 548, /* statement_no_new_scope */ + YYSYMBOL_statement_scoped = 549, /* statement_scoped */ + YYSYMBOL_550_7 = 550, /* $@7 */ + YYSYMBOL_551_8 = 551, /* $@8 */ + YYSYMBOL_compound_statement_no_new_scope = 552, /* compound_statement_no_new_scope */ + YYSYMBOL_statement_list = 553, /* statement_list */ + YYSYMBOL_expression_statement = 554, /* expression_statement */ + YYSYMBOL_selection_statement = 555, /* selection_statement */ + YYSYMBOL_selection_statement_nonattributed = 556, /* selection_statement_nonattributed */ + YYSYMBOL_selection_rest_statement = 557, /* selection_rest_statement */ + YYSYMBOL_condition = 558, /* condition */ + YYSYMBOL_switch_statement = 559, /* switch_statement */ + YYSYMBOL_switch_statement_nonattributed = 560, /* switch_statement_nonattributed */ + YYSYMBOL_561_9 = 561, /* $@9 */ + YYSYMBOL_switch_statement_list = 562, /* switch_statement_list */ + YYSYMBOL_case_label = 563, /* case_label */ + YYSYMBOL_iteration_statement = 564, /* iteration_statement */ + YYSYMBOL_iteration_statement_nonattributed = 565, /* iteration_statement_nonattributed */ + YYSYMBOL_566_10 = 566, /* $@10 */ + YYSYMBOL_567_11 = 567, /* $@11 */ + YYSYMBOL_568_12 = 568, /* $@12 */ + YYSYMBOL_for_init_statement = 569, /* for_init_statement */ + YYSYMBOL_conditionopt = 570, /* conditionopt */ + YYSYMBOL_for_rest_statement = 571, /* for_rest_statement */ + YYSYMBOL_jump_statement = 572, /* jump_statement */ + YYSYMBOL_translation_unit = 573, /* translation_unit */ + YYSYMBOL_external_declaration = 574, /* external_declaration */ + YYSYMBOL_function_definition = 575, /* function_definition */ + YYSYMBOL_576_13 = 576, /* $@13 */ + YYSYMBOL_attribute = 577, /* attribute */ + YYSYMBOL_attribute_list = 578, /* attribute_list */ + YYSYMBOL_single_attribute = 579, /* single_attribute */ + YYSYMBOL_spirv_requirements_list = 580, /* spirv_requirements_list */ + YYSYMBOL_spirv_requirements_parameter = 581, /* spirv_requirements_parameter */ + YYSYMBOL_spirv_extension_list = 582, /* spirv_extension_list */ + YYSYMBOL_spirv_capability_list = 583, /* spirv_capability_list */ + YYSYMBOL_spirv_execution_mode_qualifier = 584, /* spirv_execution_mode_qualifier */ + YYSYMBOL_spirv_execution_mode_parameter_list = 585, /* spirv_execution_mode_parameter_list */ + YYSYMBOL_spirv_execution_mode_parameter = 586, /* spirv_execution_mode_parameter */ + YYSYMBOL_spirv_execution_mode_id_parameter_list = 587, /* spirv_execution_mode_id_parameter_list */ + YYSYMBOL_spirv_storage_class_qualifier = 588, /* spirv_storage_class_qualifier */ + YYSYMBOL_spirv_decorate_qualifier = 589, /* spirv_decorate_qualifier */ + YYSYMBOL_spirv_decorate_parameter_list = 590, /* spirv_decorate_parameter_list */ + YYSYMBOL_spirv_decorate_parameter = 591, /* spirv_decorate_parameter */ + YYSYMBOL_spirv_decorate_id_parameter_list = 592, /* spirv_decorate_id_parameter_list */ + YYSYMBOL_spirv_decorate_id_parameter = 593, /* spirv_decorate_id_parameter */ + YYSYMBOL_spirv_decorate_string_parameter_list = 594, /* spirv_decorate_string_parameter_list */ + YYSYMBOL_spirv_type_specifier = 595, /* spirv_type_specifier */ + YYSYMBOL_spirv_type_parameter_list = 596, /* spirv_type_parameter_list */ + YYSYMBOL_spirv_type_parameter = 597, /* spirv_type_parameter */ + YYSYMBOL_spirv_instruction_qualifier = 598, /* spirv_instruction_qualifier */ + YYSYMBOL_spirv_instruction_qualifier_list = 599, /* spirv_instruction_qualifier_list */ + YYSYMBOL_spirv_instruction_qualifier_id = 600 /* spirv_instruction_qualifier_id */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -735,7 +736,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; extern int yylex(YYSTYPE*, TParseContext&); -#line 739 "MachineIndependent/glslang_tab.cpp" +#line 740 "MachineIndependent/glslang_tab.cpp" #ifdef short @@ -1057,21 +1058,21 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 455 +#define YYFINAL 456 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 12814 +#define YYLAST 12841 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 468 +#define YYNTOKENS 469 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 132 /* YYNRULES -- Number of rules. */ -#define YYNRULES 703 +#define YYNRULES 704 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 949 +#define YYNSTATES 950 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 722 +#define YYMAXUTOK 723 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -1157,84 +1158,84 @@ static const yytype_int16 yytranslate[] = 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467 + 465, 466, 467, 468 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 356, 356, 362, 365, 370, 373, 376, 380, 383, - 386, 390, 394, 398, 402, 406, 410, 416, 423, 426, - 429, 432, 435, 440, 448, 455, 462, 468, 472, 479, - 482, 488, 506, 531, 539, 544, 571, 579, 585, 589, - 593, 613, 614, 615, 616, 622, 623, 628, 633, 642, - 643, 648, 656, 657, 663, 672, 673, 678, 683, 688, - 696, 697, 706, 718, 719, 728, 729, 738, 739, 748, - 749, 757, 758, 766, 767, 775, 776, 776, 794, 795, - 811, 815, 819, 823, 828, 832, 836, 840, 844, 848, - 852, 859, 862, 873, 880, 885, 892, 897, 902, 909, - 913, 917, 921, 926, 931, 940, 940, 951, 955, 962, - 967, 975, 983, 995, 998, 1005, 1018, 1041, 1064, 1079, - 1104, 1115, 1125, 1135, 1145, 1154, 1157, 1161, 1165, 1170, - 1178, 1183, 1188, 1193, 1198, 1207, 1217, 1244, 1253, 1260, - 1267, 1274, 1281, 1289, 1297, 1307, 1317, 1324, 1334, 1340, - 1343, 1350, 1354, 1358, 1366, 1375, 1378, 1389, 1392, 1395, - 1399, 1403, 1407, 1411, 1414, 1419, 1423, 1428, 1436, 1440, - 1445, 1451, 1457, 1464, 1469, 1474, 1482, 1487, 1499, 1513, - 1519, 1524, 1532, 1540, 1548, 1556, 1564, 1572, 1580, 1588, - 1596, 1603, 1610, 1614, 1619, 1624, 1629, 1634, 1639, 1644, - 1648, 1652, 1656, 1660, 1666, 1672, 1682, 1689, 1692, 1700, - 1707, 1718, 1723, 1731, 1735, 1745, 1748, 1754, 1760, 1766, - 1774, 1784, 1788, 1792, 1796, 1801, 1805, 1810, 1815, 1820, - 1825, 1830, 1835, 1840, 1845, 1850, 1856, 1862, 1868, 1873, - 1878, 1883, 1888, 1893, 1898, 1903, 1908, 1913, 1918, 1923, - 1928, 1935, 1940, 1945, 1950, 1955, 1960, 1965, 1970, 1975, - 1980, 1985, 1990, 1998, 2006, 2014, 2020, 2026, 2032, 2038, - 2044, 2050, 2056, 2062, 2068, 2074, 2080, 2086, 2092, 2098, - 2104, 2110, 2116, 2122, 2128, 2134, 2140, 2146, 2152, 2158, - 2164, 2170, 2176, 2182, 2188, 2194, 2200, 2206, 2212, 2220, - 2228, 2236, 2244, 2252, 2260, 2268, 2276, 2284, 2292, 2300, - 2308, 2314, 2320, 2326, 2332, 2338, 2344, 2350, 2356, 2362, - 2368, 2374, 2380, 2386, 2392, 2398, 2404, 2410, 2416, 2422, - 2428, 2434, 2440, 2446, 2452, 2458, 2464, 2470, 2476, 2482, - 2488, 2494, 2500, 2506, 2512, 2518, 2524, 2528, 2532, 2536, - 2541, 2546, 2551, 2556, 2561, 2566, 2571, 2576, 2581, 2586, - 2591, 2596, 2601, 2606, 2612, 2618, 2624, 2630, 2636, 2642, - 2648, 2654, 2660, 2666, 2672, 2678, 2684, 2689, 2694, 2699, - 2704, 2709, 2714, 2719, 2724, 2729, 2734, 2739, 2744, 2749, - 2754, 2759, 2764, 2769, 2774, 2779, 2784, 2789, 2794, 2799, - 2804, 2809, 2814, 2819, 2824, 2829, 2834, 2839, 2844, 2849, - 2855, 2861, 2866, 2871, 2876, 2882, 2887, 2892, 2897, 2903, - 2908, 2913, 2918, 2924, 2929, 2934, 2939, 2945, 2951, 2957, - 2963, 2968, 2974, 2980, 2986, 2991, 2996, 3001, 3006, 3011, - 3017, 3022, 3027, 3032, 3038, 3043, 3048, 3053, 3059, 3064, - 3069, 3074, 3080, 3085, 3090, 3095, 3101, 3106, 3111, 3116, - 3122, 3127, 3132, 3137, 3143, 3148, 3153, 3158, 3164, 3169, - 3174, 3179, 3185, 3190, 3195, 3200, 3206, 3211, 3216, 3221, - 3227, 3232, 3237, 3242, 3248, 3253, 3258, 3263, 3269, 3274, - 3279, 3284, 3290, 3295, 3300, 3305, 3311, 3316, 3321, 3326, - 3331, 3336, 3341, 3346, 3351, 3356, 3361, 3366, 3371, 3376, - 3381, 3386, 3391, 3396, 3401, 3406, 3411, 3416, 3421, 3426, - 3431, 3437, 3443, 3449, 3455, 3461, 3467, 3473, 3480, 3487, - 3493, 3499, 3505, 3511, 3518, 3525, 3532, 3539, 3544, 3549, - 3553, 3557, 3561, 3566, 3582, 3587, 3592, 3600, 3600, 3617, - 3617, 3627, 3630, 3643, 3665, 3692, 3696, 3702, 3707, 3718, - 3721, 3727, 3733, 3742, 3745, 3751, 3755, 3756, 3762, 3763, - 3764, 3765, 3766, 3767, 3768, 3769, 3773, 3781, 3782, 3786, - 3782, 3800, 3801, 3805, 3805, 3812, 3812, 3826, 3829, 3839, - 3847, 3858, 3859, 3863, 3866, 3873, 3880, 3884, 3892, 3896, - 3909, 3912, 3919, 3919, 3939, 3942, 3948, 3960, 3972, 3975, - 3983, 3983, 3998, 3998, 4016, 4016, 4037, 4040, 4046, 4049, - 4055, 4059, 4066, 4071, 4076, 4083, 4086, 4090, 4094, 4098, - 4107, 4111, 4120, 4123, 4126, 4134, 4134, 4176, 4181, 4184, - 4189, 4192, 4197, 4200, 4205, 4208, 4213, 4216, 4221, 4224, - 4229, 4233, 4238, 4242, 4247, 4251, 4258, 4261, 4266, 4269, - 4272, 4275, 4278, 4283, 4292, 4303, 4308, 4316, 4320, 4325, - 4329, 4334, 4338, 4343, 4347, 4354, 4357, 4362, 4365, 4368, - 4371, 4376, 4379, 4384, 4390, 4393, 4396, 4399, 4404, 4408, - 4413, 4417, 4422, 4426, 4433, 4436, 4441, 4444, 4449, 4452, - 4458, 4461, 4466, 4469 + 0, 357, 357, 363, 366, 371, 374, 377, 381, 384, + 387, 391, 395, 399, 403, 407, 411, 417, 424, 427, + 430, 433, 436, 441, 449, 456, 463, 469, 473, 480, + 483, 489, 507, 532, 540, 545, 572, 580, 586, 590, + 594, 614, 615, 616, 617, 623, 624, 629, 634, 643, + 644, 649, 657, 658, 664, 673, 674, 679, 684, 689, + 697, 698, 707, 719, 720, 729, 730, 739, 740, 749, + 750, 758, 759, 767, 768, 776, 777, 777, 795, 796, + 812, 816, 820, 824, 829, 833, 837, 841, 845, 849, + 853, 860, 863, 874, 881, 886, 893, 898, 903, 910, + 914, 918, 922, 927, 932, 941, 941, 952, 956, 963, + 968, 976, 984, 996, 999, 1006, 1019, 1042, 1065, 1080, + 1105, 1116, 1126, 1136, 1146, 1155, 1158, 1162, 1166, 1171, + 1179, 1184, 1189, 1194, 1199, 1208, 1218, 1245, 1254, 1261, + 1268, 1275, 1282, 1290, 1298, 1308, 1318, 1325, 1335, 1341, + 1344, 1351, 1355, 1359, 1367, 1376, 1379, 1390, 1393, 1396, + 1400, 1404, 1408, 1412, 1415, 1420, 1424, 1429, 1437, 1441, + 1446, 1452, 1458, 1465, 1470, 1475, 1483, 1488, 1500, 1514, + 1520, 1525, 1533, 1541, 1549, 1557, 1565, 1573, 1581, 1589, + 1597, 1604, 1611, 1615, 1620, 1625, 1630, 1635, 1640, 1645, + 1649, 1653, 1657, 1661, 1667, 1673, 1683, 1690, 1693, 1701, + 1708, 1719, 1724, 1732, 1736, 1746, 1749, 1755, 1761, 1767, + 1775, 1785, 1789, 1793, 1797, 1802, 1806, 1811, 1816, 1821, + 1826, 1831, 1836, 1841, 1846, 1851, 1857, 1863, 1869, 1874, + 1879, 1884, 1889, 1894, 1899, 1904, 1909, 1914, 1919, 1924, + 1929, 1936, 1941, 1946, 1951, 1956, 1961, 1966, 1971, 1976, + 1981, 1986, 1991, 1999, 2007, 2015, 2021, 2027, 2033, 2039, + 2045, 2051, 2057, 2063, 2069, 2075, 2081, 2087, 2093, 2099, + 2105, 2111, 2117, 2123, 2129, 2135, 2141, 2147, 2153, 2159, + 2165, 2171, 2177, 2183, 2189, 2195, 2201, 2207, 2213, 2221, + 2229, 2237, 2245, 2253, 2261, 2269, 2277, 2285, 2293, 2301, + 2309, 2315, 2321, 2327, 2333, 2339, 2345, 2351, 2357, 2363, + 2369, 2375, 2381, 2387, 2393, 2399, 2405, 2411, 2417, 2423, + 2429, 2435, 2441, 2447, 2453, 2459, 2465, 2471, 2477, 2483, + 2489, 2495, 2501, 2507, 2513, 2519, 2525, 2529, 2533, 2537, + 2542, 2547, 2552, 2557, 2562, 2567, 2572, 2577, 2582, 2587, + 2592, 2597, 2602, 2607, 2613, 2619, 2625, 2631, 2637, 2643, + 2649, 2655, 2661, 2667, 2673, 2679, 2685, 2690, 2695, 2700, + 2705, 2710, 2715, 2720, 2725, 2730, 2735, 2740, 2745, 2750, + 2755, 2760, 2765, 2770, 2775, 2780, 2785, 2790, 2795, 2800, + 2805, 2810, 2815, 2820, 2825, 2830, 2835, 2840, 2845, 2850, + 2856, 2862, 2867, 2872, 2877, 2883, 2888, 2893, 2898, 2904, + 2909, 2914, 2919, 2925, 2930, 2935, 2940, 2946, 2952, 2958, + 2964, 2969, 2975, 2981, 2987, 2992, 2997, 3002, 3007, 3012, + 3018, 3023, 3028, 3033, 3039, 3044, 3049, 3054, 3060, 3065, + 3070, 3075, 3081, 3086, 3091, 3096, 3102, 3107, 3112, 3117, + 3123, 3128, 3133, 3138, 3144, 3149, 3154, 3159, 3165, 3170, + 3175, 3180, 3186, 3191, 3196, 3201, 3207, 3212, 3217, 3222, + 3228, 3233, 3238, 3243, 3249, 3254, 3259, 3264, 3270, 3275, + 3280, 3285, 3291, 3296, 3301, 3306, 3312, 3317, 3322, 3327, + 3332, 3337, 3342, 3347, 3352, 3357, 3362, 3367, 3372, 3377, + 3382, 3387, 3392, 3397, 3402, 3407, 3412, 3417, 3422, 3427, + 3432, 3438, 3444, 3450, 3456, 3462, 3468, 3474, 3481, 3488, + 3494, 3500, 3506, 3512, 3519, 3526, 3533, 3540, 3545, 3550, + 3554, 3560, 3564, 3568, 3573, 3589, 3594, 3599, 3607, 3607, + 3624, 3624, 3634, 3637, 3650, 3672, 3699, 3703, 3709, 3714, + 3725, 3728, 3734, 3740, 3749, 3752, 3758, 3762, 3763, 3769, + 3770, 3771, 3772, 3773, 3774, 3775, 3776, 3780, 3788, 3789, + 3793, 3789, 3807, 3808, 3812, 3812, 3819, 3819, 3833, 3836, + 3846, 3854, 3865, 3866, 3870, 3873, 3880, 3887, 3891, 3899, + 3903, 3916, 3919, 3926, 3926, 3946, 3949, 3955, 3967, 3979, + 3982, 3990, 3990, 4005, 4005, 4023, 4023, 4044, 4047, 4053, + 4056, 4062, 4066, 4073, 4078, 4083, 4090, 4093, 4097, 4101, + 4105, 4114, 4118, 4127, 4130, 4133, 4141, 4141, 4183, 4188, + 4191, 4196, 4199, 4204, 4207, 4212, 4215, 4220, 4223, 4228, + 4231, 4236, 4240, 4245, 4249, 4254, 4258, 4265, 4268, 4273, + 4276, 4279, 4282, 4285, 4290, 4299, 4310, 4315, 4323, 4327, + 4332, 4336, 4341, 4345, 4350, 4354, 4361, 4364, 4369, 4372, + 4375, 4378, 4383, 4386, 4391, 4397, 4400, 4403, 4406, 4411, + 4415, 4420, 4424, 4429, 4433, 4440, 4443, 4448, 4451, 4456, + 4459, 4465, 4468, 4473, 4476 }; #endif @@ -1280,9 +1281,9 @@ static const char *const yytname[] = "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "RAYQUERYEXT", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", "COOPMAT", - "HITOBJECTNV", "HITOBJECTATTRNV", "TENSORLAYOUTNV", "TENSORVIEWNV", - "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", - "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY", + "COOPVECNV", "HITOBJECTNV", "HITOBJECTATTRNV", "TENSORLAYOUTNV", + "TENSORVIEWNV", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", + "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY", "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS", @@ -1411,12 +1412,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-875) +#define YYPACT_NINF (-841) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-698) +#define YYTABLE_NINF (-699) #define yytable_value_is_error(Yyn) \ 0 @@ -1425,101 +1426,101 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 4675, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -289, -274, -235, -138, -118, -95, -84, -82, -875, -875, - -875, -875, -875, -186, -875, -875, -875, -875, -875, -46, - -875, -875, -875, -875, -875, -320, -875, -875, -875, -875, - -875, -875, -875, -69, -62, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -334, -164, -115, -81, 7930, -257, -875, -54, -875, - -875, -875, -875, 5605, -875, -875, -875, -875, -51, -875, - -875, 955, -875, -875, 7930, -36, -875, -875, -875, 6070, - -52, -248, -161, -149, -127, -126, -52, -119, -45, 12381, - -875, -12, -361, -43, -875, -312, -875, -10, -7, 7930, - -875, -875, -875, 7930, -40, -39, -875, -309, -875, -258, - -875, -875, 11052, -4, -875, -875, -875, -2, -33, 7930, - -875, -8, -9, -1, -875, -267, -875, -253, 1, 4, - 5, 7, -246, 8, 11, 13, 14, 15, 16, -243, - 18, 19, 27, -130, -875, -5, 7930, -875, 20, -875, - -241, -875, -875, -239, 9280, -875, -277, 1420, -875, -875, - -875, -875, -875, -4, -270, -875, 9723, -265, -875, -28, - -875, -85, 11052, 11052, -875, 11052, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, -259, -875, -875, -875, 29, - -238, 11495, 28, -875, 11052, -875, 31, -301, 30, -7, - 33, -875, -321, -52, -875, -27, -875, -304, 32, -106, - 11052, -101, -875, -136, -100, -165, -74, 17, -72, -52, - -875, 11938, -875, -70, 11052, 10, -45, -875, 7930, 34, - 6535, -875, 7930, 11052, -875, -361, -875, 35, -875, -875, - -29, -219, -282, -310, -212, -15, 21, 23, 49, 48, - -313, 37, -875, 10166, -875, 36, -875, -875, 45, 38, - 39, -875, 51, 52, 43, 10609, 55, 11052, 57, 65, - 67, 68, 69, -157, -875, -875, -42, -875, -164, 80, - 31, -875, -875, -875, -875, -875, 1885, -875, -875, -875, - -875, -875, -875, -875, -875, -875, 5140, 30, 9723, -264, - 8394, -875, -875, 9723, 7930, -875, 53, -875, -875, -875, - -231, -875, -875, 11052, 54, -875, -875, 11052, 66, -875, - -875, -875, 11052, -875, -875, -875, -328, -875, -875, -227, - 72, -875, -875, -875, -875, -875, -875, -218, -875, -193, - -875, -875, -192, 77, -875, -875, -875, -875, -184, -875, - -183, -875, -875, -875, -875, -875, -182, -875, 78, -875, - -181, 81, -180, 72, -875, -315, -158, -875, 86, 90, - -875, -875, 34, -4, -38, -875, -875, -875, 7000, -875, - -875, -875, 11052, 11052, 11052, 11052, 11052, 11052, 11052, 11052, - 11052, 11052, 11052, 11052, 11052, 11052, 11052, 11052, 11052, 11052, - 11052, -875, -875, -875, 89, -875, 2350, -875, -875, -875, - 2350, -875, 11052, -875, -875, -34, 11052, -201, -875, -875, - -875, -875, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, 11052, 11052, -875, -875, -875, -875, - -875, -875, -875, 9723, -875, -875, -177, -875, 7465, -875, - -875, 94, 92, -875, -875, -875, -875, -875, -129, -122, - -875, -316, -875, -304, -875, -304, -875, 11052, 11052, -875, - -136, -875, -136, -875, -165, -165, -875, 101, 17, -875, - 11938, -875, 11052, -875, -875, -32, 30, 34, -875, -875, - -875, -875, -875, -29, -29, -219, -219, -282, -282, -282, - -282, -310, -310, -212, -15, 21, 23, 49, 48, 11052, - -875, 2350, 4210, 59, 3745, -156, -875, -154, -875, -875, - -875, -875, -875, 8837, -875, -875, -875, 102, -875, 60, - -875, -153, -875, -151, -875, -146, -875, -144, -875, -143, - -142, -875, -875, -875, -114, 99, 92, 70, 104, 107, - -875, -875, 4210, 105, -875, -875, -875, -875, -875, -875, - -875, -875, -875, -875, -875, 11052, -875, 103, 2815, 11052, - -875, 98, 109, 71, 111, 3280, -875, 112, -875, 9723, - -875, -875, -875, -141, 11052, 2815, 105, -875, -875, 2350, - -875, 108, 92, -875, -875, 2350, 115, -875, -875 + 4684, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -312, -303, -268, -255, -225, -220, -195, -187, -841, + -841, -841, -841, -841, -232, -841, -841, -841, -841, -841, + -39, -841, -841, -841, -841, -841, -318, -841, -841, -841, + -841, -841, -841, -841, -135, -109, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -333, -182, -99, -111, 7946, -180, -841, -199, + -841, -841, -841, -841, 5616, -841, -841, -841, -841, -107, + -841, -841, 956, -841, -841, 7946, -94, -841, -841, -841, + 6082, -132, -170, -141, -124, -123, -119, -132, -118, -100, + 12407, -841, -66, -361, -78, -841, -310, -841, -28, -24, + 7946, -841, -841, -841, 7946, -52, -42, -841, -307, -841, + -274, -841, -841, 11075, -5, -841, -841, -841, -3, -37, + 7946, -841, -9, -7, -2, -841, -257, -841, -248, -1, + 3, 4, 5, -235, 6, 8, 11, 13, 14, 15, + -233, 18, 16, 26, -260, -841, -6, 7946, -841, 19, + -841, -230, -841, -841, -228, 9299, -841, -271, 1422, -841, + -841, -841, -841, -841, -5, -315, -841, 9743, -311, -841, + -29, -841, -117, 11075, 11075, -841, 11075, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, -254, -841, -841, -841, + 28, -212, 11519, 27, -841, 11075, -841, 30, -323, 29, + -24, 32, -841, -321, -132, -841, -27, -841, -328, 31, + -114, 11075, -106, -841, -146, -74, -164, -73, 17, -69, + -132, -841, 11963, -841, -63, 11075, 33, -100, -841, 7946, + -22, 6548, -841, 7946, 11075, -841, -361, -841, 34, -841, + -841, -26, -251, -105, -309, -101, -16, 20, 22, 48, + 47, -308, 37, -841, 10187, -841, 39, -841, -841, 45, + 38, 41, -841, 52, 53, 55, 10631, 67, 11075, 60, + 66, 68, 69, 70, -173, -841, -841, -36, -841, -182, + 77, 30, -841, -841, -841, -841, -841, 1888, -841, -841, + -841, -841, -841, -841, -841, -841, -841, 5150, 29, 9743, + -267, 8411, -841, -841, 9743, 7946, -841, 49, -841, -841, + -841, -205, -841, -841, 11075, 51, -841, -841, 11075, 46, + -841, -841, -841, 11075, -841, -841, -841, -317, -841, -841, + -201, 72, -841, -841, -841, -841, -841, -841, -200, -841, + -198, -841, -841, -193, 81, -841, -841, -841, -841, -175, + -841, -172, -841, -841, -841, -841, -841, -167, -841, 82, + -841, -163, 83, -162, 72, -841, -278, -160, -841, 54, + 91, -841, -841, -22, -5, -35, -841, -841, -841, 7014, + -841, -841, -841, 11075, 11075, 11075, 11075, 11075, 11075, 11075, + 11075, 11075, 11075, 11075, 11075, 11075, 11075, 11075, 11075, 11075, + 11075, 11075, -841, -841, -841, 90, -841, 2354, -841, -841, + -841, 2354, -841, 11075, -841, -841, -30, 11075, -82, -841, + -841, -841, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, 11075, 11075, -841, -841, -841, + -841, -841, -841, -841, 9743, -841, -841, -214, -841, 7480, + -841, -841, 93, 92, -841, -841, -841, -841, -841, -127, + -122, -841, -316, -841, -328, -841, -328, -841, 11075, 11075, + -841, -146, -841, -146, -841, -164, -164, -841, 85, 17, + -841, 11963, -841, 11075, -841, -841, -25, 29, -22, -841, + -841, -841, -841, -841, -26, -26, -251, -251, -105, -105, + -105, -105, -309, -309, -101, -16, 20, 22, 48, 47, + 11075, -841, 2354, 4218, 56, 3752, -159, -841, -155, -841, + -841, -841, -841, -841, 8855, -841, -841, -841, 98, -841, + 71, -841, -152, -841, -150, -841, -148, -841, -147, -841, + -145, -143, -841, -841, -841, -76, 96, 92, 73, 102, + 105, -841, -841, 4218, 103, -841, -841, -841, -841, -841, + -841, -841, -841, -841, -841, -841, 11075, -841, 97, 2820, + 11075, -841, 100, 107, 63, 108, 3286, -841, 111, -841, + 9743, -841, -841, -841, -140, 11075, 2820, 103, -841, -841, + 2354, -841, 106, 92, -841, -841, 2354, 112, -841, -841 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1543,123 +1544,123 @@ static const yytype_int16 yydefact[] = 313, 314, 315, 316, 317, 318, 319, 320, 321, 325, 326, 327, 328, 329, 330, 331, 332, 333, 337, 338, 339, 340, 341, 342, 343, 344, 345, 349, 346, 347, - 348, 533, 534, 535, 536, 541, 182, 537, 538, 361, - 362, 385, 388, 350, 359, 360, 376, 358, 407, 408, - 411, 412, 413, 415, 416, 417, 419, 420, 421, 423, - 424, 520, 521, 384, 386, 387, 363, 364, 365, 409, - 366, 370, 371, 374, 414, 418, 422, 367, 368, 372, - 373, 410, 369, 375, 454, 456, 457, 458, 460, 461, - 462, 464, 465, 466, 468, 469, 470, 472, 473, 474, - 476, 477, 478, 480, 481, 482, 484, 485, 486, 488, - 489, 490, 492, 493, 494, 496, 497, 455, 459, 463, - 467, 471, 479, 483, 487, 475, 491, 495, 498, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 389, 390, 391, 425, 434, 436, 430, 435, 437, 438, - 440, 441, 442, 444, 445, 446, 448, 449, 450, 452, - 453, 426, 427, 428, 439, 429, 431, 432, 433, 443, - 447, 451, 525, 526, 529, 530, 531, 532, 527, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 166, 167, - 522, 523, 524, 0, 634, 137, 544, 545, 546, 0, - 543, 172, 170, 171, 169, 0, 221, 173, 175, 176, - 174, 139, 138, 0, 203, 539, 184, 186, 181, 188, - 190, 185, 187, 183, 189, 191, 179, 180, 206, 192, - 199, 200, 201, 202, 193, 194, 195, 196, 197, 198, - 140, 141, 143, 142, 144, 146, 147, 145, 205, 154, - 633, 0, 635, 0, 114, 113, 0, 125, 130, 161, - 160, 158, 162, 0, 155, 157, 163, 135, 216, 159, - 542, 0, 630, 632, 0, 0, 164, 165, 540, 0, + 348, 533, 534, 535, 536, 540, 542, 182, 537, 538, + 361, 362, 385, 388, 350, 359, 360, 376, 358, 407, + 408, 411, 412, 413, 415, 416, 417, 419, 420, 421, + 423, 424, 520, 521, 384, 386, 387, 363, 364, 365, + 409, 366, 370, 371, 374, 414, 418, 422, 367, 368, + 372, 373, 410, 369, 375, 454, 456, 457, 458, 460, + 461, 462, 464, 465, 466, 468, 469, 470, 472, 473, + 474, 476, 477, 478, 480, 481, 482, 484, 485, 486, + 488, 489, 490, 492, 493, 494, 496, 497, 455, 459, + 463, 467, 471, 479, 483, 487, 475, 491, 495, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 389, 390, 391, 425, 434, 436, 430, 435, 437, + 438, 440, 441, 442, 444, 445, 446, 448, 449, 450, + 452, 453, 426, 427, 428, 439, 429, 431, 432, 433, + 443, 447, 451, 525, 526, 529, 530, 531, 532, 527, + 528, 0, 0, 0, 0, 0, 0, 0, 0, 166, + 167, 522, 523, 524, 0, 635, 137, 545, 546, 547, + 0, 544, 172, 170, 171, 169, 0, 221, 173, 175, + 176, 174, 139, 138, 0, 203, 539, 184, 186, 181, + 188, 190, 185, 187, 183, 189, 191, 179, 180, 206, + 192, 199, 200, 201, 202, 193, 194, 195, 196, 197, + 198, 140, 141, 143, 142, 144, 146, 147, 145, 205, + 154, 634, 0, 636, 0, 114, 113, 0, 125, 130, + 161, 160, 158, 162, 0, 155, 157, 163, 135, 216, + 159, 543, 0, 631, 633, 0, 0, 164, 165, 541, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 549, 0, 0, 0, 99, 0, 94, 0, 109, 0, - 121, 115, 123, 0, 124, 0, 97, 131, 102, 0, - 156, 136, 0, 209, 215, 1, 631, 0, 0, 0, - 96, 0, 0, 0, 642, 0, 700, 0, 0, 0, + 0, 550, 0, 0, 0, 99, 0, 94, 0, 109, + 0, 121, 115, 123, 0, 124, 0, 97, 131, 102, + 0, 156, 136, 0, 209, 215, 1, 632, 0, 0, + 0, 96, 0, 0, 0, 643, 0, 701, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 640, 0, 638, 0, 0, 547, 151, 153, - 0, 149, 207, 0, 0, 100, 0, 0, 636, 110, - 116, 120, 122, 118, 126, 117, 0, 132, 105, 0, - 103, 0, 0, 0, 9, 0, 43, 42, 44, 41, - 5, 6, 7, 8, 2, 16, 14, 15, 17, 10, - 11, 12, 13, 3, 18, 37, 20, 25, 26, 0, - 0, 30, 0, 219, 0, 36, 218, 0, 210, 111, - 0, 95, 0, 0, 698, 0, 650, 0, 0, 0, - 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, - 692, 0, 665, 0, 0, 0, 0, 98, 0, 0, - 0, 551, 0, 0, 148, 0, 204, 0, 211, 45, - 49, 52, 55, 60, 63, 65, 67, 69, 71, 73, - 75, 0, 34, 0, 101, 578, 587, 591, 0, 0, - 0, 612, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 45, 78, 91, 0, 565, 0, 163, - 135, 568, 589, 567, 575, 566, 0, 569, 570, 593, - 571, 600, 572, 573, 608, 574, 0, 119, 0, 127, - 0, 559, 134, 0, 0, 107, 0, 104, 38, 39, - 0, 22, 23, 0, 0, 28, 27, 0, 221, 31, - 33, 40, 0, 217, 112, 702, 0, 703, 643, 0, - 0, 701, 662, 658, 659, 660, 661, 0, 656, 0, - 93, 663, 0, 0, 677, 678, 679, 680, 0, 675, - 0, 684, 685, 686, 687, 683, 0, 681, 0, 688, - 0, 0, 0, 2, 696, 216, 0, 694, 0, 0, - 637, 639, 0, 557, 0, 555, 550, 552, 0, 152, - 150, 208, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 641, 0, 639, 0, 0, 548, 151, + 153, 0, 149, 207, 0, 0, 100, 0, 0, 637, + 110, 116, 120, 122, 118, 126, 117, 0, 132, 105, + 0, 103, 0, 0, 0, 9, 0, 43, 42, 44, + 41, 5, 6, 7, 8, 2, 16, 14, 15, 17, + 10, 11, 12, 13, 3, 18, 37, 20, 25, 26, + 0, 0, 30, 0, 219, 0, 36, 218, 0, 210, + 111, 0, 95, 0, 0, 699, 0, 651, 0, 0, + 0, 0, 0, 668, 0, 0, 0, 0, 0, 0, + 0, 693, 0, 666, 0, 0, 0, 0, 98, 0, + 0, 0, 552, 0, 0, 148, 0, 204, 0, 211, + 45, 49, 52, 55, 60, 63, 65, 67, 69, 71, + 73, 75, 0, 34, 0, 101, 579, 588, 592, 0, + 0, 0, 613, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 45, 78, 91, 0, 566, 0, + 163, 135, 569, 590, 568, 576, 567, 0, 570, 571, + 594, 572, 601, 573, 574, 609, 575, 0, 119, 0, + 127, 0, 560, 134, 0, 0, 107, 0, 104, 38, + 39, 0, 22, 23, 0, 0, 28, 27, 0, 221, + 31, 33, 40, 0, 217, 112, 703, 0, 704, 644, + 0, 0, 702, 663, 659, 660, 661, 662, 0, 657, + 0, 93, 664, 0, 0, 678, 679, 680, 681, 0, + 676, 0, 685, 686, 687, 688, 684, 0, 682, 0, + 689, 0, 0, 0, 2, 697, 216, 0, 695, 0, + 0, 638, 640, 0, 558, 0, 556, 551, 553, 0, + 152, 150, 208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 76, 212, 213, 0, 577, 0, 610, 623, 622, - 0, 614, 0, 626, 624, 0, 0, 0, 607, 627, - 628, 629, 576, 81, 82, 84, 83, 86, 87, 88, - 89, 90, 85, 80, 0, 0, 592, 588, 590, 594, - 601, 609, 129, 0, 562, 563, 0, 133, 0, 108, - 4, 0, 24, 21, 32, 220, 646, 648, 0, 0, - 699, 0, 652, 0, 651, 0, 654, 0, 0, 669, - 0, 668, 0, 671, 0, 0, 673, 0, 0, 693, - 0, 690, 0, 666, 641, 0, 558, 0, 553, 548, - 46, 47, 48, 51, 50, 53, 54, 58, 59, 56, - 57, 61, 62, 64, 66, 68, 70, 72, 74, 0, - 214, 579, 0, 0, 0, 0, 625, 0, 606, 79, - 92, 128, 560, 0, 106, 19, 644, 0, 645, 0, - 657, 0, 664, 0, 676, 0, 682, 0, 689, 0, - 0, 695, 554, 556, 0, 0, 598, 0, 0, 0, - 617, 616, 619, 585, 602, 561, 564, 647, 649, 653, - 655, 670, 672, 674, 691, 0, 580, 0, 0, 0, - 618, 0, 0, 597, 0, 0, 595, 0, 77, 0, - 582, 611, 581, 0, 620, 0, 585, 584, 586, 604, - 599, 0, 621, 615, 596, 605, 0, 613, 603 + 0, 0, 76, 212, 213, 0, 578, 0, 611, 624, + 623, 0, 615, 0, 627, 625, 0, 0, 0, 608, + 628, 629, 630, 577, 81, 82, 84, 83, 86, 87, + 88, 89, 90, 85, 80, 0, 0, 593, 589, 591, + 595, 602, 610, 129, 0, 563, 564, 0, 133, 0, + 108, 4, 0, 24, 21, 32, 220, 647, 649, 0, + 0, 700, 0, 653, 0, 652, 0, 655, 0, 0, + 670, 0, 669, 0, 672, 0, 0, 674, 0, 0, + 694, 0, 691, 0, 667, 642, 0, 559, 0, 554, + 549, 46, 47, 48, 51, 50, 53, 54, 58, 59, + 56, 57, 61, 62, 64, 66, 68, 70, 72, 74, + 0, 214, 580, 0, 0, 0, 0, 626, 0, 607, + 79, 92, 128, 561, 0, 106, 19, 645, 0, 646, + 0, 658, 0, 665, 0, 677, 0, 683, 0, 690, + 0, 0, 696, 555, 557, 0, 0, 599, 0, 0, + 0, 618, 617, 620, 586, 603, 562, 565, 648, 650, + 654, 656, 671, 673, 675, 692, 0, 581, 0, 0, + 0, 619, 0, 0, 598, 0, 0, 596, 0, 77, + 0, 583, 612, 582, 0, 621, 0, 586, 585, 587, + 605, 600, 0, 622, 616, 597, 606, 0, 614, 604 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -875, -548, -875, -875, -875, -875, -875, -875, -875, -875, - -875, -875, -436, -875, -478, -469, -493, -397, -275, -272, - -269, -268, -262, -271, -875, -490, -875, -499, -875, -501, - -537, 9, -875, -875, -875, 6, -401, -875, -875, 40, - 42, 41, -875, -875, -409, -875, -875, -875, -875, -103, - -875, -394, -379, -875, 12, -875, 0, -432, -875, -875, - -875, -560, 146, -875, -875, -875, -555, -558, -234, -348, - -614, -875, -374, -628, -874, -875, -433, -875, -875, -443, - -442, -875, -875, 58, -738, -368, -875, -147, -875, -402, - -875, -145, -875, -875, -875, -875, -140, -875, -875, -875, - -875, -875, -875, -875, -875, 91, -875, -875, 2, -875, - -73, -266, -425, -875, -875, -875, -311, -308, -307, -875, - -875, -306, -305, -318, -314, -303, -875, -317, -302, -875, - -400, -552 + -841, -547, -841, -841, -841, -841, -841, -841, -841, -841, + -841, -841, -436, -841, -413, -388, -484, -391, -270, -269, + -266, -272, -265, -263, -841, -492, -841, -499, -841, -502, + -537, 7, -841, -841, -841, 9, -395, -841, -841, 35, + 40, 42, -841, -841, -414, -841, -841, -841, -841, -103, + -841, -392, -378, -841, 12, -841, 0, -433, -841, -841, + -841, -567, 141, -841, -841, -841, -556, -559, -239, -348, + -638, -841, -374, -627, -840, -841, -432, -841, -841, -444, + -443, -841, -841, 57, -732, -369, -841, -144, -841, -406, + -841, -142, -841, -841, -841, -841, -139, -841, -841, -841, + -841, -841, -841, -841, -841, 88, -841, -841, 2, -841, + -75, -282, -447, -841, -841, -841, -304, -313, -306, -841, + -841, -319, -314, -320, -305, -302, -841, -322, -301, -841, + -397, -538 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - 0, 533, 534, 535, 801, 536, 537, 538, 539, 540, - 541, 542, 623, 544, 590, 591, 592, 593, 594, 595, - 596, 597, 598, 599, 600, 624, 859, 625, 784, 626, - 714, 627, 391, 654, 511, 628, 393, 394, 395, 440, - 441, 442, 396, 397, 398, 399, 400, 401, 490, 491, - 402, 403, 404, 405, 545, 493, 602, 496, 453, 454, - 547, 408, 409, 410, 582, 486, 580, 581, 724, 725, - 652, 796, 631, 632, 633, 634, 635, 756, 895, 931, - 923, 924, 925, 932, 636, 637, 638, 639, 926, 898, - 640, 641, 927, 946, 642, 643, 644, 862, 760, 864, - 902, 921, 922, 645, 411, 412, 413, 437, 646, 483, - 484, 463, 464, 808, 809, 415, 687, 688, 692, 416, - 417, 698, 699, 706, 707, 710, 418, 716, 717, 419, - 465, 466 + 0, 534, 535, 536, 802, 537, 538, 539, 540, 541, + 542, 543, 624, 545, 591, 592, 593, 594, 595, 596, + 597, 598, 599, 600, 601, 625, 860, 626, 785, 627, + 715, 628, 392, 655, 512, 629, 394, 395, 396, 441, + 442, 443, 397, 398, 399, 400, 401, 402, 491, 492, + 403, 404, 405, 406, 546, 494, 603, 497, 454, 455, + 548, 409, 410, 411, 583, 487, 581, 582, 725, 726, + 653, 797, 632, 633, 634, 635, 636, 757, 896, 932, + 924, 925, 926, 933, 637, 638, 639, 640, 927, 899, + 641, 642, 928, 947, 643, 644, 645, 863, 761, 865, + 903, 922, 923, 646, 412, 413, 414, 438, 647, 484, + 485, 464, 465, 809, 810, 416, 688, 689, 693, 417, + 418, 699, 700, 707, 708, 711, 419, 717, 718, 420, + 466, 467 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1667,242 +1668,289 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 407, 443, 414, 681, 601, 458, 392, 651, 788, 390, - 458, 715, 406, 457, 660, 507, 543, 705, 861, 681, - 459, 548, 727, 691, 450, 459, 479, 728, 806, 739, - 740, 750, 488, 434, 792, 675, 795, 719, 676, 797, - 675, 430, 669, -697, 930, 443, 729, 494, 505, -697, - 494, 938, 682, 737, 738, 495, 489, 506, 589, 435, - 452, 930, 807, 672, 450, 741, 742, 751, 420, 677, - 690, 647, 649, 431, 677, 673, 658, 659, 661, 662, - 450, 690, 603, 421, 690, 683, 684, 685, 686, 494, - 604, 554, 578, 690, 603, 603, 648, 555, -35, 798, - 663, 653, 793, 508, 664, 556, 509, 445, 671, 510, - 446, 557, 562, 754, 765, 570, 767, 584, 563, 586, - 666, 571, 422, 585, 589, 587, 667, 800, 678, 743, - 744, 810, 863, 785, 678, 589, 678, 555, 589, 678, - 812, 678, 467, 678, 678, 468, 813, 589, 678, 651, - 735, 651, 736, 679, 651, 469, 471, 473, 475, 477, - 478, 481, 802, 785, 868, 814, 816, 589, 804, 712, - 727, 815, 817, 428, 819, 821, 823, 826, 829, 871, - 820, 822, 824, 827, 830, 872, 578, 873, 578, 773, - 774, 775, 776, 777, 778, 779, 780, 781, 782, 450, - 831, 945, 903, 436, 904, 909, 832, 910, 785, 783, - 785, 813, 911, 817, 912, 913, 914, 941, 820, 423, - 824, 827, 832, 785, 701, 702, 703, 704, 524, 470, - 575, 876, 468, 788, 576, 877, 805, 458, 878, 424, - 727, 472, 879, 438, 468, 457, 847, 848, 849, 850, - 785, 915, 459, 694, 695, 696, 697, 843, 844, 906, - 578, 865, 425, 474, 476, 867, 468, 468, 845, 846, - 715, 480, 715, 426, 468, 427, 705, 705, 681, 656, - 882, 691, 657, 439, 689, 869, 870, 468, 432, 693, - 700, 836, 468, 468, 651, 433, 840, 841, 842, 589, - 589, 589, 589, 589, 589, 589, 589, 589, 589, 589, - 589, 589, 589, 589, 589, 940, 708, 788, 711, 468, - 718, 468, 785, 468, 452, 786, 837, 690, 690, 838, - 785, 460, 837, 866, 578, 892, 336, 337, 338, 447, - 690, 462, 690, 732, 733, 734, 851, 852, 482, 487, - 492, 497, 333, 503, 504, 494, 549, 552, 894, 551, - 550, 896, 577, 553, 745, 655, 680, 558, 559, 560, - 720, 561, 564, 709, 651, 565, 572, 566, 567, 568, - 569, 589, 589, 573, 574, 670, 583, 665, -34, 603, - 505, 676, 748, 749, 589, 444, 589, 752, 755, 746, - 747, 896, 757, 451, 578, 758, 759, 406, 761, 762, - 763, 407, 766, 414, 407, 406, 928, 392, 933, 407, - 390, 414, 768, 406, -29, 461, 406, 723, 731, 485, - 651, 406, 769, 942, 770, 771, 772, -36, 811, 444, - 499, 818, 825, 444, 833, 828, 799, 803, 834, 860, - 908, 406, 546, 897, 875, 406, 785, 888, 907, 451, - 899, 916, 918, 917, 919, 934, -583, 935, 459, 929, - 853, 406, 605, 939, 854, 947, 936, 948, 855, 858, - 856, 500, 730, 501, 502, 429, 579, 857, 835, 893, - 900, 937, 943, 897, 944, 498, 901, 630, 406, 789, - 920, 790, 456, 721, 881, 880, 791, 887, 459, 629, - 886, 883, 0, 890, 0, 884, 885, 0, 0, 0, - 0, 0, 0, 0, 0, 889, 0, 0, 0, 0, - 891, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 408, 459, 415, 602, 444, 716, 459, 391, 652, 393, + 789, 793, 407, 796, 661, 508, 798, 544, 682, 706, + 458, 549, 728, 460, 692, 862, 451, 729, 460, 683, + 480, 740, 741, 489, 682, 435, 676, 751, 720, 677, + 807, 676, 673, 670, 431, 495, 421, 730, 444, 604, + 495, 506, 649, 495, 674, 422, 654, 490, 496, 590, + 507, 436, 684, 685, 686, 687, 451, 742, 743, 691, + 678, 648, 650, 752, 808, 678, 432, 659, 660, 931, + 691, -698, 451, 691, 662, 663, 939, -698, 509, 604, + 423, 510, 691, 604, 511, 579, 931, 605, 453, 799, + 794, 576, 555, 424, -35, 577, 664, 679, 556, 672, + 665, 557, 755, 679, 766, 679, 768, 558, 679, 736, + 679, 737, 679, 679, 563, 590, 571, 679, 429, 585, + 564, 587, 572, 425, 864, 586, 590, 588, 426, 590, + 470, 472, 474, 476, 478, 479, 482, 667, 590, 873, + 652, 874, 652, 668, 801, 652, 872, 680, 811, 813, + 786, 815, 803, 427, 556, 814, 817, 816, 590, 805, + 728, 428, 818, 713, 774, 775, 776, 777, 778, 779, + 780, 781, 782, 783, 820, 446, 437, 822, 447, 579, + 821, 579, 824, 823, 784, 448, 827, 830, 825, 832, + 904, 451, 828, 831, 905, 833, 786, 910, 946, 911, + 786, 912, 913, 814, 914, 818, 915, 821, 825, 942, + 828, 468, 833, 433, 469, 786, 702, 703, 704, 705, + 525, 738, 739, 459, 877, 789, 907, 806, 878, 879, + 728, 744, 745, 880, 695, 696, 697, 698, 657, 434, + 471, 658, 458, 469, 440, 460, 848, 849, 850, 851, + 439, 866, 463, 579, 716, 868, 716, 473, 475, 453, + 469, 469, 477, 481, 461, 469, 469, 690, 706, 706, + 469, 883, 692, 786, 869, 694, 870, 871, 469, 786, + 916, 837, 941, 682, 483, 652, 488, 841, 842, 843, + 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, + 590, 590, 590, 590, 590, 590, 493, 701, 709, 789, + 469, 469, 712, 844, 845, 469, 691, 691, 719, 786, + 838, 469, 787, 839, 498, 786, 334, 579, 867, 691, + 838, 691, 504, 893, 337, 338, 339, 733, 734, 735, + 846, 847, 505, 852, 853, 495, 550, 551, 895, 552, + 553, 897, 578, 554, 746, 656, 559, 681, 560, 561, + 562, 565, 724, 566, 710, 652, 567, 573, 568, 569, + 570, 574, 590, 590, 575, 671, 584, 666, -34, 604, + 506, 677, 749, 750, 721, 590, 445, 590, 753, 747, + 748, 897, 756, 758, 452, -29, 759, 579, 407, 760, + 762, 763, 408, 834, 415, 408, 407, 929, 934, 391, + 408, 393, 415, 764, 407, 767, 769, 407, 732, 462, + 486, 652, 407, 943, 770, -36, 771, 772, 773, 812, + 445, 500, 889, 800, 445, 804, 819, 826, 829, 898, + 835, 861, 407, 547, 876, 908, 407, 786, 900, 917, + 452, 919, 909, 920, 930, -584, 936, 918, 935, 937, + 606, 460, 407, 940, 948, 949, 854, 857, 855, 502, + 501, 430, 856, 731, 836, 858, 503, 580, 859, 898, + 894, 901, 944, 938, 945, 499, 902, 921, 631, 407, + 457, 881, 722, 790, 886, 791, 888, 885, 792, 891, + 630, 460, 882, 884, 0, 0, 0, 0, 0, 0, + 887, 0, 0, 0, 0, 0, 0, 890, 0, 0, + 0, 0, 892, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 674, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 675, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 722, 0, - 579, 0, 579, 0, 0, 0, 0, 0, 0, 0, - 406, 0, 406, 0, 406, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 723, + 0, 580, 0, 580, 0, 0, 0, 0, 0, 0, + 0, 407, 0, 407, 0, 407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 630, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 407, 0, 629, 0, - 0, 0, 0, 0, 579, 0, 0, 0, 406, 0, - 0, 0, 0, 0, 0, 0, 406, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 631, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 408, 0, 630, + 0, 0, 0, 0, 0, 580, 0, 0, 0, 407, + 0, 0, 0, 0, 0, 0, 0, 407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 580, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 406, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 630, 0, 0, 0, - 630, 0, 0, 0, 0, 0, 0, 0, 629, 0, - 0, 0, 629, 0, 0, 0, 0, 0, 0, 0, + 0, 407, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 631, 0, 0, + 0, 631, 0, 0, 0, 0, 0, 0, 0, 630, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 580, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 406, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 630, 630, 0, 630, 0, 414, 0, 0, 0, - 0, 0, 0, 629, 629, 0, 629, 0, 0, 0, + 0, 0, 631, 631, 0, 631, 0, 415, 0, 0, + 0, 0, 0, 0, 630, 630, 0, 630, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 630, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 629, 0, 0, 0, 630, 0, - 0, 0, 0, 0, 0, 630, 0, 0, 0, 0, - 629, 0, 0, 0, 0, 630, 0, 629, 0, 630, - 0, 0, 0, 0, 0, 630, 0, 629, 0, 0, - 0, 629, 0, 0, 0, 455, 0, 629, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 630, 0, 0, 0, 631, + 0, 0, 0, 0, 0, 0, 631, 0, 0, 0, + 0, 630, 0, 0, 0, 0, 631, 0, 630, 0, + 631, 0, 0, 0, 0, 0, 631, 0, 630, 0, + 0, 0, 630, 0, 0, 0, 456, 0, 630, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 333, 0, 0, 0, 0, 0, - 0, 0, 334, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 339, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 334, 0, 0, 0, + 0, 0, 0, 0, 335, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 336, 337, + 338, 339, 340, 0, 0, 0, 0, 0, 0, 0, + 0, 341, 342, 343, 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 512, 513, 0, + 0, 0, 0, 348, 349, 350, 351, 352, 353, 354, + 0, 0, 0, 0, 0, 0, 0, 0, 355, 0, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, + 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 515, + 516, 0, 334, 0, 606, 607, 0, 0, 0, 0, + 608, 517, 518, 519, 520, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 336, 337, 338, 339, 340, 0, + 0, 0, 521, 522, 523, 524, 525, 341, 342, 343, + 344, 345, 346, 347, 609, 610, 611, 612, 0, 613, + 614, 615, 616, 617, 618, 619, 620, 621, 622, 348, + 349, 350, 351, 352, 353, 354, 526, 527, 528, 529, + 530, 531, 532, 533, 355, 623, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 514, 515, 0, 333, - 0, 605, 606, 0, 0, 0, 0, 607, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 339, 0, 0, 0, 520, - 521, 522, 523, 524, 340, 341, 342, 343, 344, 345, - 346, 608, 609, 610, 611, 0, 612, 613, 614, 615, - 616, 617, 618, 619, 620, 621, 347, 348, 349, 350, - 351, 352, 353, 525, 526, 527, 528, 529, 530, 531, - 532, 354, 622, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 512, 513, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 515, 516, 0, 334, 0, + 606, 788, 0, 0, 0, 0, 608, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 336, 337, 338, 339, 340, 0, 0, 0, 521, 522, + 523, 524, 525, 341, 342, 343, 344, 345, 346, 347, + 609, 610, 611, 612, 0, 613, 614, 615, 616, 617, + 618, 619, 620, 621, 622, 348, 349, 350, 351, 352, + 353, 354, 526, 527, 528, 529, 530, 531, 532, 533, + 355, 623, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 514, 515, 0, 333, 0, 605, 787, 0, 0, - 0, 0, 607, 516, 517, 518, 519, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 339, 0, 0, 0, 520, 521, 522, 523, 524, 340, - 341, 342, 343, 344, 345, 346, 608, 609, 610, 611, - 0, 612, 613, 614, 615, 616, 617, 618, 619, 620, - 621, 347, 348, 349, 350, 351, 352, 353, 525, 526, - 527, 528, 529, 530, 531, 532, 354, 622, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, + 0, 515, 516, 0, 334, 0, 606, 0, 0, 0, + 0, 0, 608, 517, 518, 519, 520, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 336, 337, 338, 339, + 340, 0, 0, 0, 521, 522, 523, 524, 525, 341, + 342, 343, 344, 345, 346, 347, 609, 610, 611, 612, + 0, 613, 614, 615, 616, 617, 618, 619, 620, 621, + 622, 348, 349, 350, 351, 352, 353, 354, 526, 527, + 528, 529, 530, 531, 532, 533, 355, 623, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 388, 389, 390, 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, @@ -1935,253 +1983,207 @@ static const yytype_int16 yytable[] = 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 512, 513, 0, + 328, 329, 330, 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 514, 515, 0, 333, - 0, 605, 0, 0, 0, 0, 0, 607, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 339, 0, 0, 0, 520, - 521, 522, 523, 524, 340, 341, 342, 343, 344, 345, - 346, 608, 609, 610, 611, 0, 612, 613, 614, 615, - 616, 617, 618, 619, 620, 621, 347, 348, 349, 350, - 351, 352, 353, 525, 526, 527, 528, 529, 530, 531, - 532, 354, 622, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 0, 0, 0, 0, 0, 515, 516, 0, + 334, 0, 498, 0, 0, 0, 0, 0, 608, 517, + 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 336, 337, 338, 339, 340, 0, 0, 0, + 521, 522, 523, 524, 525, 341, 342, 343, 344, 345, + 346, 347, 609, 610, 611, 612, 0, 613, 614, 615, + 616, 617, 618, 619, 620, 621, 622, 348, 349, 350, + 351, 352, 353, 354, 526, 527, 528, 529, 530, 531, + 532, 533, 355, 623, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 512, 513, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 514, 515, 0, 333, 0, 497, 0, 0, 0, - 0, 0, 607, 516, 517, 518, 519, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 339, 0, 0, 0, 520, 521, 522, 523, 524, 340, - 341, 342, 343, 344, 345, 346, 608, 609, 610, 611, - 0, 612, 613, 614, 615, 616, 617, 618, 619, 620, - 621, 347, 348, 349, 350, 351, 352, 353, 525, 526, - 527, 528, 529, 530, 531, 532, 354, 622, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 512, 513, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 514, 515, 0, 333, - 0, 0, 0, 0, 0, 0, 0, 607, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 339, 0, 0, 0, 520, - 521, 522, 523, 524, 340, 341, 342, 343, 344, 345, - 346, 608, 609, 610, 611, 0, 612, 613, 614, 615, - 616, 617, 618, 619, 620, 621, 347, 348, 349, 350, - 351, 352, 353, 525, 526, 527, 528, 529, 530, 531, - 532, 354, 622, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 512, 513, 0, 0, 0, 0, 0, 0, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 514, 515, 0, 333, 0, 0, 0, 0, 0, - 0, 0, 607, 516, 517, 518, 519, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 339, 0, 0, 0, 520, 521, 522, 523, 524, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, + 0, 0, 0, 515, 516, 0, 334, 0, 0, 0, + 0, 0, 0, 0, 608, 517, 518, 519, 520, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 336, 337, + 338, 339, 340, 0, 0, 0, 521, 522, 523, 524, + 525, 341, 342, 343, 344, 345, 346, 347, 609, 610, + 611, 612, 0, 613, 614, 615, 616, 617, 618, 619, + 620, 621, 622, 348, 349, 350, 351, 352, 353, 354, + 526, 527, 528, 529, 530, 531, 532, 533, 355, 623, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, + 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 515, + 516, 0, 334, 0, 0, 0, 0, 0, 0, 0, + 608, 517, 518, 519, 520, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 336, 337, 338, 339, 340, 0, + 0, 0, 521, 522, 523, 524, 525, 341, 342, 343, + 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 348, + 349, 350, 351, 352, 353, 354, 526, 527, 528, 529, + 530, 531, 532, 533, 355, 0, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 0, 0, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 525, 526, - 527, 528, 529, 530, 531, 532, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 512, 513, 0, + 0, 0, 0, 0, 0, 515, 516, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 336, 337, 338, 339, 0, 0, 0, 0, 521, 522, + 523, 524, 525, 341, 342, 343, 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 514, 515, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 0, 0, 0, 0, 520, - 521, 522, 523, 524, 340, 341, 342, 343, 344, 345, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 347, 348, 349, 350, - 351, 352, 353, 525, 526, 527, 528, 529, 530, 531, - 532, 354, 0, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 0, 0, 0, 0, 0, 348, 349, 350, 351, 352, + 353, 354, 526, 527, 528, 529, 530, 531, 532, 533, + 355, 0, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 333, 0, 0, 0, 0, 0, - 0, 0, 334, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 339, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, + 0, 0, 0, 0, 334, 0, 0, 0, 0, 0, + 0, 0, 335, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 336, 337, 338, 339, + 340, 0, 0, 0, 0, 0, 0, 0, 0, 341, + 342, 343, 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, + 0, 348, 349, 350, 351, 352, 353, 354, 0, 0, + 0, 0, 0, 0, 0, 0, 355, 0, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 388, 389, 390, 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, @@ -2213,68 +2215,208 @@ static const yytype_int16 yytable[] = 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 0, 0, 0, + 318, 319, 320, 0, 0, 0, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 340, 341, 342, 343, 344, 345, - 346, 608, 0, 0, 611, 0, 612, 613, 0, 0, - 616, 0, 0, 0, 0, 0, 347, 348, 349, 350, - 351, 352, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 336, 337, 338, 339, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 341, 342, 343, 344, 345, + 346, 347, 609, 0, 0, 612, 0, 613, 614, 0, + 0, 617, 0, 0, 0, 0, 0, 348, 349, 350, + 351, 352, 353, 354, 0, 0, 0, 0, 0, 0, + 0, 0, 355, 0, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 0, 0, 0, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 0, 0, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 449, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 336, 337, + 338, 339, 0, 0, 0, 0, 0, 0, 0, 0, + 450, 341, 342, 343, 344, 345, 346, 347, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 348, 349, 350, 351, 352, 353, 354, + 0, 0, 0, 0, 0, 0, 0, 0, 355, 0, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 0, 0, 0, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 334, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 336, 337, 338, 339, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 341, 342, 343, + 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 348, + 349, 350, 351, 352, 353, 354, 0, 0, 0, 0, + 0, 0, 0, 0, 355, 0, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 0, 0, 0, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 727, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 336, 337, 338, 339, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 341, 342, 343, 344, 345, 346, 347, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 348, 349, 350, 351, 352, + 353, 354, 0, 0, 0, 0, 0, 0, 0, 0, + 355, 0, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 0, 0, 0, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 840, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 448, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 0, 0, 0, 0, 0, 0, 0, 0, 449, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 336, 337, 338, 339, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 341, + 342, 343, 344, 345, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, + 0, 348, 349, 350, 351, 352, 353, 354, 0, 0, + 0, 0, 0, 0, 0, 0, 355, 0, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 388, 389, 390, 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, @@ -2306,27 +2448,118 @@ static const yytype_int16 yytable[] = 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 0, 0, 0, + 318, 319, 320, 0, 0, 0, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 875, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 340, 341, 342, 343, 344, 345, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 347, 348, 349, 350, - 351, 352, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 336, 337, 338, 339, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 341, 342, 343, 344, 345, + 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 348, 349, 350, + 351, 352, 353, 354, 0, 0, 0, 0, 0, 0, + 0, 0, 355, 0, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 0, + 0, 0, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 336, 337, + 338, 339, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 341, 342, 343, 344, 345, 346, 347, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 348, 349, 350, 351, 352, 353, 354, + 0, 0, 0, 0, 0, 0, 0, 0, 355, 0, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 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, + 0, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 0, 0, 0, 0, 0, 0, + 327, 0, 0, 0, 331, 332, 333, 0, 0, 513, + 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 515, 516, + 0, 0, 0, 651, 795, 0, 0, 0, 0, 0, + 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 521, 522, 523, 524, 525, 341, 0, 0, 0, + 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 526, 527, 528, 529, 530, + 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 369, 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, + 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, @@ -2337,7 +2570,7 @@ static const yytype_int16 yytable[] = 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, + 163, 164, 165, 166, 0, 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, @@ -2352,206 +2585,109 @@ static const yytype_int16 yytable[] = 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 0, 0, 0, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 726, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, + 313, 314, 315, 316, 317, 318, 319, 320, 0, 0, + 0, 0, 0, 0, 327, 0, 0, 0, 331, 332, + 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 0, 0, 0, + 0, 0, 515, 516, 0, 0, 0, 651, 906, 0, + 0, 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 521, 522, 523, 524, 525, + 341, 0, 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 839, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 340, 341, 342, 343, 344, 345, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 347, 348, 349, 350, - 351, 352, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 0, 0, 0, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 874, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 335, 336, 337, 338, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 347, 348, 349, 350, 351, 352, 353, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 526, + 527, 528, 529, 530, 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 369, 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, 0, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 0, 0, 0, 0, 0, 0, 327, 0, + 0, 0, 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 515, 516, 0, 0, + 589, 0, 0, 0, 0, 0, 0, 0, 517, 518, + 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 521, + 522, 523, 524, 525, 341, 0, 0, 0, 0, 346, + 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 335, 336, 337, 338, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 340, 341, 342, 343, 344, 345, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 347, 348, 349, 350, - 351, 352, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 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, 0, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 0, 0, 0, 0, - 0, 0, 326, 0, 0, 0, 330, 331, 332, 0, - 0, 512, 513, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 526, 527, 528, 529, 530, 531, 532, + 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 369, 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, 0, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 0, 0, 0, + 0, 0, 327, 0, 0, 0, 331, 332, 333, 0, + 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 514, 515, 0, 0, 0, 650, 794, 0, 0, 0, - 0, 0, 516, 517, 518, 519, 0, 0, 0, 0, + 515, 516, 0, 0, 0, 651, 0, 0, 0, 0, + 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 520, 521, 522, 523, 524, 340, 0, - 0, 0, 0, 345, 346, 0, 0, 0, 0, 0, + 0, 0, 0, 521, 522, 523, 524, 525, 341, 0, + 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 525, 526, 527, - 528, 529, 530, 531, 532, 0, 0, 355, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 526, 527, 528, + 529, 530, 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 368, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 369, 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, @@ -2567,7 +2703,7 @@ static const yytype_int16 yytable[] = 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, 0, 167, 168, 169, 170, + 161, 162, 163, 164, 165, 166, 0, 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, @@ -2582,153 +2718,109 @@ static const yytype_int16 yytable[] = 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 0, - 0, 0, 0, 0, 0, 326, 0, 0, 0, 330, - 331, 332, 0, 0, 512, 513, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 514, 515, 0, 0, 0, 650, 905, - 0, 0, 0, 0, 0, 516, 517, 518, 519, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 520, 521, 522, 523, - 524, 340, 0, 0, 0, 0, 345, 346, 0, 0, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 0, 0, 0, 0, 0, 0, 327, 0, 0, 0, + 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 515, 516, 0, 0, 754, 0, + 0, 0, 0, 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 525, 526, 527, 528, 529, 530, 531, 532, 0, 0, - 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 368, 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, 0, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 0, 0, 0, 0, 0, 0, 326, 0, - 0, 0, 330, 331, 332, 0, 0, 512, 513, 0, + 0, 0, 0, 0, 0, 0, 0, 521, 522, 523, + 524, 525, 341, 0, 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 514, 515, 0, 0, - 588, 0, 0, 0, 0, 0, 0, 0, 516, 517, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 520, - 521, 522, 523, 524, 340, 0, 0, 0, 0, 345, - 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 525, 526, 527, 528, 529, 530, 531, - 532, 0, 0, 355, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 368, 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, 0, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 0, 0, 0, 0, 0, - 0, 326, 0, 0, 0, 330, 331, 332, 0, 0, - 512, 513, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 514, - 515, 0, 0, 0, 650, 0, 0, 0, 0, 0, - 0, 516, 517, 518, 519, 0, 0, 0, 0, 0, + 0, 526, 527, 528, 529, 530, 531, 532, 533, 0, + 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 369, 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, + 0, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 0, 0, 0, 0, 0, 0, + 327, 0, 0, 0, 331, 332, 333, 0, 0, 513, + 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 515, 516, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 765, + 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 520, 521, 522, 523, 524, 340, 0, 0, - 0, 0, 345, 346, 0, 0, 0, 0, 0, 0, + 0, 521, 522, 523, 524, 525, 341, 0, 0, 0, + 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 525, 526, 527, 528, - 529, 530, 531, 532, 0, 0, 355, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 368, - 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, 0, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 0, 0, - 0, 0, 0, 0, 326, 0, 0, 0, 330, 331, - 332, 0, 0, 512, 513, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 526, 527, 528, 529, 530, + 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 369, 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, 0, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 0, 0, + 0, 0, 0, 0, 327, 0, 0, 0, 331, 332, + 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 514, 515, 0, 0, 753, 0, 0, 0, - 0, 0, 0, 0, 516, 517, 518, 519, 0, 0, + 0, 0, 515, 516, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 520, 521, 522, 523, 524, - 340, 0, 0, 0, 0, 345, 346, 0, 0, 0, + 0, 0, 0, 0, 0, 521, 522, 523, 524, 525, + 341, 0, 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 525, - 526, 527, 528, 529, 530, 531, 532, 0, 0, 355, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 526, + 527, 528, 529, 530, 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 368, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 369, 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, @@ -2744,7 +2836,7 @@ static const yytype_int16 yytable[] = 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, 0, 167, 168, + 159, 160, 161, 162, 163, 164, 165, 166, 0, 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, @@ -2760,435 +2852,394 @@ static const yytype_int16 yytable[] = 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 0, 0, 0, 0, 0, 0, 326, 0, 0, - 0, 330, 331, 332, 0, 0, 512, 513, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 514, 515, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 764, 516, 517, 518, - 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 520, 521, - 522, 523, 524, 340, 0, 0, 0, 0, 345, 346, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 525, 526, 527, 528, 529, 530, 531, 532, - 0, 0, 355, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 368, 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, - 0, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 0, 0, 0, 0, 0, 0, - 326, 0, 0, 0, 330, 331, 332, 0, 0, 512, - 513, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 514, 515, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 516, 517, 518, 519, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 520, 521, 522, 523, 524, 340, 0, 0, 0, - 0, 345, 346, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 525, 526, 527, 528, 529, - 530, 531, 532, 0, 0, 355, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 368, 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, 0, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 0, 0, 0, - 0, 0, 0, 326, 0, 0, 0, 330, 331, 332, - 0, 0, 512, 513, 0, 0, 0, 0, 0, 0, + 319, 320, 0, 0, 0, 0, 0, 0, 327, 0, + 0, 0, 331, 332, 333, 0, 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 514, 515, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 516, 517, 518, 519, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 515, 516, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 517, 518, + 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 521, + 522, 523, 524, 525, 341, 0, 0, 0, 0, 346, + 669, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 520, 521, 522, 523, 524, 340, - 0, 0, 0, 0, 345, 668, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 525, 526, - 527, 528, 529, 530, 531, 532, 0, 0, 355, 0, + 0, 0, 0, 526, 527, 528, 529, 530, 531, 532, + 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 369, 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, 0, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 0, 0, 0, 0, + 0, 0, 327, 0, 0, 0, 331, 332, 333, 0, + 0, 513, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 368, 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, 0, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, - 330, 331, 332, 0, 0, 512, 513, 0, 0, 0, + 515, 516, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 514, 515, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 516, 517, 518, 519, + 0, 0, 0, 521, 522, 523, 524, 714, 341, 0, + 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 520, 521, 522, - 523, 713, 340, 0, 0, 0, 0, 345, 346, 0, + 0, 0, 0, 0, 0, 0, 0, 526, 527, 528, + 529, 530, 531, 532, 533, 0, 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 369, 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, 0, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 0, 0, 0, 0, 0, 0, 327, 0, 0, 0, + 331, 332, 333, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 525, 526, 527, 528, 529, 530, 531, 532, 0, - 0, 355, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 368, 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, 0, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 0, 0, 0, 0, 0, 0, 326, - 0, 0, 0, 330, 331, 332, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 341, 0, 0, 0, 0, 346, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 340, 0, 0, 0, 0, - 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 355 + 0, 356 }; static const yytype_int16 yycheck[] = { - 0, 395, 0, 555, 494, 414, 0, 506, 636, 0, - 419, 571, 0, 414, 515, 447, 452, 565, 756, 571, - 414, 453, 580, 560, 403, 419, 426, 582, 356, 339, - 340, 344, 393, 367, 648, 356, 650, 574, 359, 653, - 356, 361, 541, 358, 918, 439, 583, 359, 357, 364, - 359, 925, 356, 335, 336, 367, 417, 366, 494, 393, - 375, 935, 390, 364, 443, 375, 376, 380, 357, 390, - 560, 503, 504, 393, 390, 376, 512, 513, 337, 338, - 459, 571, 359, 357, 574, 389, 390, 391, 392, 359, - 367, 358, 486, 583, 359, 359, 366, 364, 357, 654, - 359, 366, 366, 361, 363, 358, 364, 364, 544, 367, - 367, 364, 358, 603, 615, 358, 617, 358, 364, 358, - 358, 364, 357, 364, 560, 364, 364, 358, 553, 341, - 342, 358, 760, 364, 559, 571, 561, 364, 574, 564, - 358, 566, 390, 568, 569, 393, 364, 583, 573, 648, - 369, 650, 371, 553, 653, 421, 422, 423, 424, 425, - 426, 427, 663, 364, 365, 358, 358, 603, 667, 569, - 728, 364, 364, 359, 358, 358, 358, 358, 358, 793, - 364, 364, 364, 364, 364, 362, 580, 364, 582, 346, - 347, 348, 349, 350, 351, 352, 353, 354, 355, 578, - 358, 939, 358, 367, 358, 358, 364, 358, 364, 366, - 364, 364, 358, 364, 358, 358, 358, 358, 364, 357, - 364, 364, 364, 364, 389, 390, 391, 392, 393, 390, - 360, 360, 393, 861, 364, 364, 672, 646, 360, 357, - 798, 390, 364, 358, 393, 646, 739, 740, 741, 742, - 364, 365, 646, 389, 390, 391, 392, 735, 736, 873, - 654, 762, 357, 390, 390, 766, 393, 393, 737, 738, - 830, 390, 832, 357, 393, 357, 824, 825, 830, 364, - 817, 818, 367, 364, 390, 784, 785, 393, 357, 390, - 390, 723, 393, 393, 793, 357, 732, 733, 734, 735, + 0, 415, 0, 495, 396, 572, 420, 0, 507, 0, + 637, 649, 0, 651, 516, 448, 654, 453, 556, 566, + 415, 454, 581, 415, 561, 757, 404, 583, 420, 357, + 427, 340, 341, 394, 572, 368, 357, 345, 575, 360, + 357, 357, 365, 542, 362, 360, 358, 584, 440, 360, + 360, 358, 367, 360, 377, 358, 367, 418, 368, 495, + 367, 394, 390, 391, 392, 393, 444, 376, 377, 561, + 391, 504, 505, 381, 391, 391, 394, 513, 514, 919, + 572, 359, 460, 575, 338, 339, 926, 365, 362, 360, + 358, 365, 584, 360, 368, 487, 936, 368, 376, 655, + 367, 361, 359, 358, 358, 365, 360, 554, 365, 545, + 364, 359, 604, 560, 616, 562, 618, 365, 565, 370, + 567, 372, 569, 570, 359, 561, 359, 574, 360, 359, + 365, 359, 365, 358, 761, 365, 572, 365, 358, 575, + 422, 423, 424, 425, 426, 427, 428, 359, 584, 363, + 649, 365, 651, 365, 359, 654, 794, 554, 359, 359, + 365, 359, 664, 358, 365, 365, 359, 365, 604, 668, + 729, 358, 365, 570, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 359, 365, 368, 359, 368, 581, + 365, 583, 359, 365, 367, 394, 359, 359, 365, 359, + 359, 579, 365, 365, 359, 365, 365, 359, 940, 359, + 365, 359, 359, 365, 359, 365, 359, 365, 365, 359, + 365, 391, 365, 358, 394, 365, 390, 391, 392, 393, + 394, 336, 337, 647, 361, 862, 874, 673, 365, 361, + 799, 342, 343, 365, 390, 391, 392, 393, 365, 358, + 391, 368, 647, 394, 365, 647, 740, 741, 742, 743, + 359, 763, 394, 655, 831, 767, 833, 391, 391, 376, + 394, 394, 391, 391, 368, 394, 394, 391, 825, 826, + 394, 818, 819, 365, 366, 391, 785, 786, 394, 365, + 366, 724, 930, 831, 394, 794, 362, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, - 746, 747, 748, 749, 750, 929, 390, 945, 390, 393, - 390, 393, 364, 393, 375, 367, 364, 817, 818, 367, - 364, 367, 364, 367, 728, 367, 382, 383, 384, 393, - 830, 393, 832, 372, 373, 374, 743, 744, 393, 361, - 393, 361, 359, 393, 393, 359, 358, 366, 859, 367, - 393, 862, 367, 364, 379, 393, 393, 366, 364, 364, - 360, 364, 364, 356, 873, 364, 358, 364, 364, 364, - 364, 817, 818, 364, 357, 357, 366, 358, 357, 359, - 357, 359, 343, 345, 830, 395, 832, 360, 362, 378, - 377, 902, 357, 403, 798, 367, 367, 395, 357, 357, - 367, 411, 357, 411, 414, 403, 915, 411, 919, 419, - 411, 419, 365, 411, 358, 419, 414, 393, 393, 429, - 929, 419, 367, 934, 367, 367, 367, 357, 366, 439, - 438, 364, 364, 443, 358, 364, 393, 393, 358, 360, - 390, 439, 452, 862, 360, 443, 364, 356, 356, 459, - 401, 362, 358, 393, 357, 367, 361, 358, 862, 366, - 745, 459, 361, 361, 746, 367, 405, 362, 747, 750, - 748, 439, 585, 443, 443, 339, 486, 749, 722, 837, - 864, 924, 935, 902, 936, 437, 864, 497, 486, 646, - 902, 646, 411, 576, 815, 813, 646, 825, 902, 497, - 824, 818, -1, 830, -1, 820, 822, -1, -1, -1, - -1, -1, -1, -1, -1, 828, -1, -1, -1, -1, - 832, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 746, 747, 748, 749, 750, 751, 394, 391, 391, 946, + 394, 394, 391, 736, 737, 394, 818, 819, 391, 365, + 365, 394, 368, 368, 362, 365, 360, 729, 368, 831, + 365, 833, 394, 368, 383, 384, 385, 373, 374, 375, + 738, 739, 394, 744, 745, 360, 359, 394, 860, 368, + 367, 863, 368, 365, 380, 394, 367, 394, 365, 365, + 365, 365, 394, 365, 357, 874, 365, 359, 365, 365, + 365, 365, 818, 819, 358, 358, 367, 359, 358, 360, + 358, 360, 344, 346, 361, 831, 396, 833, 361, 379, + 378, 903, 363, 358, 404, 359, 368, 799, 396, 368, + 358, 358, 412, 359, 412, 415, 404, 916, 920, 412, + 420, 412, 420, 368, 412, 358, 366, 415, 394, 420, + 430, 930, 420, 935, 368, 358, 368, 368, 368, 367, + 440, 439, 357, 394, 444, 394, 365, 365, 365, 863, + 359, 361, 440, 453, 361, 357, 444, 365, 402, 363, + 460, 359, 391, 358, 367, 362, 359, 394, 368, 406, + 362, 863, 460, 362, 368, 363, 746, 749, 747, 444, + 440, 340, 748, 586, 723, 750, 444, 487, 751, 903, + 838, 865, 936, 925, 937, 438, 865, 903, 498, 487, + 412, 814, 577, 647, 823, 647, 826, 821, 647, 831, + 498, 903, 816, 819, -1, -1, -1, -1, -1, -1, + 825, -1, -1, -1, -1, -1, -1, 829, -1, -1, + -1, -1, 833, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 549, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 550, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 578, -1, - 580, -1, 582, -1, -1, -1, -1, -1, -1, -1, - 578, -1, 580, -1, 582, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 579, + -1, 581, -1, 583, -1, -1, -1, -1, -1, -1, + -1, 579, -1, 581, -1, 583, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 636, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 646, -1, 636, -1, - -1, -1, -1, -1, 654, -1, -1, -1, 646, -1, - -1, -1, -1, -1, -1, -1, 654, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 637, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 647, -1, 637, + -1, -1, -1, -1, -1, 655, -1, -1, -1, 647, + -1, -1, -1, -1, -1, -1, -1, 655, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 728, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 729, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 728, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 756, -1, -1, -1, - 760, -1, -1, -1, -1, -1, -1, -1, 756, -1, - -1, -1, 760, -1, -1, -1, -1, -1, -1, -1, + -1, 729, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 757, -1, -1, + -1, 761, -1, -1, -1, -1, -1, -1, -1, 757, + -1, -1, -1, 761, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 798, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 799, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 798, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 799, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 861, 862, -1, 864, -1, 864, -1, -1, -1, - -1, -1, -1, 861, 862, -1, 864, -1, -1, -1, + -1, -1, 862, 863, -1, 865, -1, 865, -1, -1, + -1, -1, -1, -1, 862, 863, -1, 865, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 902, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 902, -1, -1, -1, 918, -1, - -1, -1, -1, -1, -1, 925, -1, -1, -1, -1, - 918, -1, -1, -1, -1, 935, -1, 925, -1, 939, - -1, -1, -1, -1, -1, 945, -1, 935, -1, -1, - -1, 939, -1, -1, -1, 0, -1, 945, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 903, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 903, -1, -1, -1, 919, + -1, -1, -1, -1, -1, -1, 926, -1, -1, -1, + -1, 919, -1, -1, -1, -1, 936, -1, 926, -1, + 940, -1, -1, -1, -1, -1, 946, -1, 936, -1, + -1, -1, 940, -1, -1, -1, 0, -1, 946, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 359, -1, -1, -1, -1, -1, - -1, -1, 367, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - 385, -1, -1, -1, -1, -1, -1, -1, -1, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 360, -1, -1, -1, + -1, -1, -1, -1, 368, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 382, 383, + 384, 385, 386, -1, -1, -1, -1, -1, -1, -1, + -1, 395, 396, 397, 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, -1, -1, - -1, -1, -1, -1, -1, -1, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, 337, 338, -1, + -1, -1, -1, 417, 418, 419, 420, 421, 422, 423, + -1, -1, -1, -1, -1, -1, -1, -1, 432, -1, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, + 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 357, + 358, -1, 360, -1, 362, 363, -1, -1, -1, -1, + 368, 369, 370, 371, 372, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 382, 383, 384, 385, 386, -1, + -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, -1, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 356, 357, -1, 359, - -1, 361, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, 385, -1, -1, -1, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, 337, 338, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 357, 358, -1, 360, -1, + 362, 363, -1, -1, -1, -1, 368, 369, 370, 371, + 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 382, 383, 384, 385, 386, -1, -1, -1, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, -1, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 356, 357, -1, 359, -1, 361, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - 385, -1, -1, -1, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, + -1, 357, 358, -1, 360, -1, 362, -1, -1, -1, + -1, -1, 368, 369, 370, 371, 372, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 382, 383, 384, 385, + 386, -1, -1, -1, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, + -1, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 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, @@ -3221,439 +3272,207 @@ static const yytype_int16 yycheck[] = 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, 337, 338, -1, + 330, 331, 332, 333, 334, 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 356, 357, -1, 359, - -1, 361, -1, -1, -1, -1, -1, 367, 368, 369, - 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, 385, -1, -1, -1, 389, + -1, -1, -1, -1, -1, -1, -1, 357, 358, -1, + 360, -1, 362, -1, -1, -1, -1, -1, 368, 369, + 370, 371, 372, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 382, 383, 384, 385, 386, -1, -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, + 400, 401, 402, 403, 404, 405, -1, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, 337, 338, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 356, 357, -1, 359, -1, 361, -1, -1, -1, - -1, -1, 367, 368, 369, 370, 371, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - 385, -1, -1, -1, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, 337, 338, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 356, 357, -1, 359, - -1, -1, -1, -1, -1, -1, -1, 367, 368, 369, - 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, 385, -1, -1, -1, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, 337, 338, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 356, 357, -1, 359, -1, -1, -1, -1, -1, - -1, -1, 367, 368, 369, 370, 371, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - 385, -1, -1, -1, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, 337, 338, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 356, 357, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 368, 369, - 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, -1, -1, -1, -1, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, -1, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 359, -1, -1, -1, -1, -1, - -1, -1, 367, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - 385, -1, -1, -1, -1, -1, -1, -1, -1, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, -1, -1, - -1, -1, -1, -1, -1, -1, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - 400, 401, -1, -1, 404, -1, 406, 407, -1, -1, - 410, -1, -1, -1, -1, -1, 416, 417, 418, 419, - 420, 421, 422, -1, -1, -1, -1, -1, -1, -1, - -1, 431, -1, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, -1, -1, -1, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 367, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - -1, -1, -1, -1, -1, -1, -1, -1, 393, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, -1, -1, - -1, -1, -1, -1, -1, -1, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 359, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 416, 417, 418, 419, - 420, 421, 422, -1, -1, -1, -1, -1, -1, -1, - -1, 431, -1, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, -1, -1, -1, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + -1, -1, -1, 357, 358, -1, 360, -1, -1, -1, + -1, -1, -1, -1, 368, 369, 370, 371, 372, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 382, 383, + 384, 385, 386, -1, -1, -1, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, -1, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, + 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 357, + 358, -1, 360, -1, -1, -1, -1, -1, -1, -1, + 368, 369, 370, 371, 372, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 382, 383, 384, 385, 386, -1, + -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 430, 431, 432, -1, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, -1, -1, -1, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, -1, -1, 338, 339, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 357, 358, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 369, 370, 371, + 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 382, 383, 384, 385, -1, -1, -1, -1, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, -1, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, + -1, -1, -1, -1, 360, -1, -1, -1, -1, -1, + -1, -1, 368, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 382, 383, 384, 385, + 386, -1, -1, -1, -1, -1, -1, -1, -1, 395, + 396, 397, 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, -1, -1, - -1, -1, -1, -1, -1, -1, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, + -1, 417, 418, 419, 420, 421, 422, 423, -1, -1, + -1, -1, -1, -1, -1, -1, 432, -1, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 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, @@ -3685,120 +3504,167 @@ static const yytype_int16 yycheck[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, -1, -1, -1, + 320, 321, 322, -1, -1, -1, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 362, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 416, 417, 418, 419, - 420, 421, 422, -1, -1, -1, -1, -1, -1, -1, - -1, 431, -1, 433, 434, 435, 436, 437, 438, 439, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 382, 383, 384, 385, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 395, 396, 397, 398, 399, + 400, 401, 402, -1, -1, 405, -1, 407, 408, -1, + -1, 411, -1, -1, -1, -1, -1, 417, 418, 419, + 420, 421, 422, 423, -1, -1, -1, -1, -1, -1, + -1, -1, 432, -1, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, -1, -1, -1, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, -1, + -1, -1, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, + -1, -1, -1, -1, 368, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 382, 383, + 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, + 394, 395, 396, 397, 398, 399, 400, 401, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 417, 418, 419, 420, 421, 422, 423, + -1, -1, -1, -1, -1, -1, -1, -1, 432, -1, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, -1, -1, -1, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 381, 382, 383, 384, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - 395, 396, 397, 398, 399, 400, -1, -1, -1, -1, + -1, -1, 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 416, 417, 418, 419, 420, 421, 422, -1, -1, - -1, -1, -1, -1, -1, -1, 431, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 382, 383, 384, 385, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 395, 396, 397, + 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 417, + 418, 419, 420, 421, 422, 423, -1, -1, -1, -1, + -1, -1, -1, -1, 432, -1, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, -1, -1, -1, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 363, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 395, 396, 397, 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 381, 382, 383, 384, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 416, 417, 418, 419, - 420, 421, 422, -1, -1, -1, -1, -1, -1, -1, - -1, 431, -1, 433, 434, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 4, 5, + -1, -1, -1, -1, -1, 417, 418, 419, 420, 421, + 422, 423, -1, -1, -1, -1, -1, -1, -1, -1, + 432, -1, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 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, + 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, @@ -3809,7 +3675,7 @@ static const yytype_int16 yycheck[] = 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, -1, 169, 170, 171, 172, 173, 174, 175, + 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, @@ -3820,74 +3686,32 @@ static const yytype_int16 yycheck[] = 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, -1, -1, -1, -1, - -1, -1, 328, -1, -1, -1, 332, 333, 334, -1, - -1, 337, 338, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 356, 357, -1, -1, -1, 361, 362, -1, -1, -1, - -1, -1, 368, 369, 370, 371, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 389, 390, 391, 392, 393, 394, -1, - -1, -1, -1, 399, 400, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 423, 424, 425, - 426, 427, 428, 429, 430, -1, -1, 433, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 446, 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, -1, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, -1, - -1, -1, -1, -1, -1, 328, -1, -1, -1, 332, - 333, 334, -1, -1, 337, 338, -1, -1, -1, -1, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, -1, -1, -1, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 356, 357, -1, -1, -1, 361, 362, - -1, -1, -1, -1, -1, 368, 369, 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 389, 390, 391, 392, - 393, 394, -1, -1, -1, -1, 399, 400, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 363, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 382, 383, 384, 385, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 395, + 396, 397, 398, 399, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 423, 424, 425, 426, 427, 428, 429, 430, -1, -1, - 433, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 446, 4, 5, 6, 7, 8, 9, + -1, 417, 418, 419, 420, 421, 422, 423, -1, -1, + -1, -1, -1, -1, -1, -1, 432, -1, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 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, + 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, @@ -3897,7 +3721,7 @@ static const yytype_int16 yycheck[] = 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, -1, 169, + 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, @@ -3913,69 +3737,27 @@ static const yytype_int16 yycheck[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, -1, -1, -1, -1, -1, -1, 328, -1, - -1, -1, 332, 333, 334, -1, -1, 337, 338, -1, + 320, 321, 322, -1, -1, -1, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 356, 357, -1, -1, - 360, -1, -1, -1, -1, -1, -1, -1, 368, 369, - 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 389, - 390, 391, 392, 393, 394, -1, -1, -1, -1, 399, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 423, 424, 425, 426, 427, 428, 429, - 430, -1, -1, 433, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 446, 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, -1, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, -1, -1, -1, -1, -1, - -1, 328, -1, -1, -1, 332, 333, 334, -1, -1, - 337, 338, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 356, - 357, -1, -1, -1, 361, -1, -1, -1, -1, -1, - -1, 368, 369, 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 389, 390, 391, 392, 393, 394, -1, -1, - -1, -1, 399, 400, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 363, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 423, 424, 425, 426, - 427, 428, 429, 430, -1, -1, 433, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 446, + -1, -1, 382, 383, 384, 385, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 395, 396, 397, 398, 399, + 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 417, 418, 419, + 420, 421, 422, 423, -1, -1, -1, -1, -1, -1, + -1, -1, 432, -1, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 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, @@ -3986,7 +3768,7 @@ static const yytype_int16 yycheck[] = 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, -1, 169, 170, 171, 172, 173, + 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, @@ -4001,20 +3783,111 @@ static const yytype_int16 yycheck[] = 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, -1, -1, - -1, -1, -1, -1, 328, -1, -1, -1, 332, 333, - 334, -1, -1, 337, 338, -1, -1, -1, -1, -1, + 314, 315, 316, 317, 318, 319, 320, 321, 322, -1, + -1, -1, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 382, 383, + 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 395, 396, 397, 398, 399, 400, 401, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 417, 418, 419, 420, 421, 422, 423, + -1, -1, -1, -1, -1, -1, -1, -1, 432, -1, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 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, + -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, -1, -1, -1, -1, -1, -1, + 329, -1, -1, -1, 333, 334, 335, -1, -1, 338, + 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 357, 358, + -1, -1, -1, 362, 363, -1, -1, -1, -1, -1, + 369, 370, 371, 372, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 390, 391, 392, 393, 394, 395, -1, -1, -1, + -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 424, 425, 426, 427, 428, + 429, 430, 431, -1, -1, 434, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 447, 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, -1, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, -1, -1, + -1, -1, -1, -1, 329, -1, -1, -1, 333, 334, + 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 356, 357, -1, -1, 360, -1, -1, -1, - -1, -1, -1, -1, 368, 369, 370, 371, -1, -1, + -1, -1, 357, 358, -1, -1, -1, 362, 363, -1, + -1, -1, -1, -1, 369, 370, 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, 390, 391, 392, 393, - 394, -1, -1, -1, -1, 399, 400, -1, -1, -1, + -1, -1, -1, -1, -1, 390, 391, 392, 393, 394, + 395, -1, -1, -1, -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 423, - 424, 425, 426, 427, 428, 429, 430, -1, -1, 433, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 424, + 425, 426, 427, 428, 429, 430, 431, -1, -1, 434, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 446, 4, 5, 6, 7, 8, 9, 10, + -1, -1, 447, 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, @@ -4030,7 +3903,7 @@ static const yytype_int16 yycheck[] = 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, -1, 169, 170, + 161, 162, 163, 164, 165, 166, 167, 168, -1, 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, @@ -4046,63 +3919,152 @@ static const yytype_int16 yycheck[] = 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, -1, -1, -1, -1, -1, -1, 328, -1, -1, - -1, 332, 333, 334, -1, -1, 337, 338, -1, -1, + 321, 322, -1, -1, -1, -1, -1, -1, 329, -1, + -1, -1, 333, 334, 335, -1, -1, 338, 339, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 357, 358, -1, -1, + 361, -1, -1, -1, -1, -1, -1, -1, 369, 370, + 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 390, + 391, 392, 393, 394, 395, -1, -1, -1, -1, 400, + 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 424, 425, 426, 427, 428, 429, 430, + 431, -1, -1, 434, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 447, 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, -1, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, -1, -1, -1, -1, + -1, -1, 329, -1, -1, -1, 333, 334, 335, -1, + -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 356, 357, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 367, 368, 369, 370, - 371, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 389, 390, - 391, 392, 393, 394, -1, -1, -1, -1, 399, 400, + 357, 358, -1, -1, -1, 362, -1, -1, -1, -1, + -1, -1, 369, 370, 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 390, 391, 392, 393, 394, 395, -1, + -1, -1, -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 423, 424, 425, 426, 427, 428, 429, 430, - -1, -1, 433, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 446, 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, - -1, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, -1, -1, -1, -1, -1, -1, - 328, -1, -1, -1, 332, 333, 334, -1, -1, 337, - 338, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 356, 357, + -1, -1, -1, -1, -1, -1, -1, 424, 425, 426, + 427, 428, 429, 430, 431, -1, -1, 434, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 447, 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, -1, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + -1, -1, -1, -1, -1, -1, 329, -1, -1, -1, + 333, 334, 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 368, 369, 370, 371, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 357, 358, -1, -1, 361, -1, + -1, -1, -1, -1, -1, -1, 369, 370, 371, 372, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 390, 391, 392, + 393, 394, 395, -1, -1, -1, -1, 400, 401, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 424, 425, 426, 427, 428, 429, 430, 431, -1, + -1, 434, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 447, 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, + -1, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, -1, -1, -1, -1, -1, -1, + 329, -1, -1, -1, 333, 334, 335, -1, -1, 338, + 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 357, 358, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 368, + 369, 370, 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 389, 390, 391, 392, 393, 394, -1, -1, -1, - -1, 399, 400, -1, -1, -1, -1, -1, -1, -1, + -1, 390, 391, 392, 393, 394, 395, -1, -1, -1, + -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 423, 424, 425, 426, 427, - 428, 429, 430, -1, -1, 433, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 446, 4, + -1, -1, -1, -1, -1, 424, 425, 426, 427, 428, + 429, 430, 431, -1, -1, 434, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 447, 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, @@ -4119,7 +4081,7 @@ static const yytype_int16 yycheck[] = 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, -1, 169, 170, 171, 172, 173, 174, + 165, 166, 167, 168, -1, 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, @@ -4134,107 +4096,152 @@ static const yytype_int16 yycheck[] = 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, -1, -1, -1, - -1, -1, -1, 328, -1, -1, -1, 332, 333, 334, - -1, -1, 337, 338, -1, -1, -1, -1, -1, -1, + 315, 316, 317, 318, 319, 320, 321, 322, -1, -1, + -1, -1, -1, -1, 329, -1, -1, -1, 333, 334, + 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 356, 357, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 368, 369, 370, 371, -1, -1, -1, + -1, -1, 357, 358, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 369, 370, 371, 372, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 390, 391, 392, 393, 394, + 395, -1, -1, -1, -1, 400, 401, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 424, + 425, 426, 427, 428, 429, 430, 431, -1, -1, 434, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 447, 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, -1, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, -1, -1, -1, -1, -1, -1, 329, -1, + -1, -1, 333, 334, 335, -1, -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 389, 390, 391, 392, 393, 394, - -1, -1, -1, -1, 399, 400, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 357, 358, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 369, 370, + 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 390, + 391, 392, 393, 394, 395, -1, -1, -1, -1, 400, + 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, 423, 424, - 425, 426, 427, 428, 429, 430, -1, -1, 433, -1, + -1, -1, -1, 424, 425, 426, 427, 428, 429, 430, + 431, -1, -1, 434, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 447, 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, -1, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, -1, -1, -1, -1, + -1, -1, 329, -1, -1, -1, 333, 334, 335, -1, + -1, 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 446, 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, -1, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - -1, -1, -1, -1, -1, -1, 328, -1, -1, -1, - 332, 333, 334, -1, -1, 337, 338, -1, -1, -1, + 357, 358, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 369, 370, 371, 372, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 356, 357, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 368, 369, 370, 371, + -1, -1, -1, 390, 391, 392, 393, 394, 395, -1, + -1, -1, -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 389, 390, 391, - 392, 393, 394, -1, -1, -1, -1, 399, 400, -1, + -1, -1, -1, -1, -1, -1, -1, 424, 425, 426, + 427, 428, 429, 430, 431, -1, -1, 434, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 447, 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, -1, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + -1, -1, -1, -1, -1, -1, 329, -1, -1, -1, + 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 423, 424, 425, 426, 427, 428, 429, 430, -1, - -1, 433, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 446, 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, -1, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, -1, -1, -1, -1, -1, -1, 328, - -1, -1, -1, 332, 333, 334, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 395, -1, -1, -1, -1, 400, 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, - 399, 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 433 + -1, 434 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -4274,144 +4281,144 @@ static const yytype_int16 yystos[] = 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, 333, 334, 359, 367, 381, 382, 383, 384, 385, - 394, 395, 396, 397, 398, 399, 400, 416, 417, 418, - 419, 420, 421, 422, 431, 433, 434, 435, 436, 437, + 332, 333, 334, 335, 360, 368, 382, 383, 384, 385, + 386, 395, 396, 397, 398, 399, 400, 401, 417, 418, + 419, 420, 421, 422, 423, 432, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 499, 500, 503, 504, 505, 506, 510, 511, 512, 513, - 514, 515, 518, 519, 520, 521, 522, 524, 529, 530, - 531, 572, 573, 574, 576, 583, 587, 588, 594, 597, - 357, 357, 357, 357, 357, 357, 357, 357, 359, 530, - 361, 393, 357, 357, 367, 393, 367, 575, 358, 364, - 507, 508, 509, 519, 524, 364, 367, 393, 367, 393, - 520, 524, 375, 526, 527, 0, 573, 504, 512, 519, - 367, 503, 393, 579, 580, 598, 599, 390, 393, 579, - 390, 579, 390, 579, 390, 579, 390, 579, 579, 598, - 390, 579, 393, 577, 578, 524, 533, 361, 393, 417, - 516, 517, 393, 523, 359, 367, 525, 361, 551, 576, - 508, 507, 509, 393, 393, 357, 366, 525, 361, 364, - 367, 502, 337, 338, 356, 357, 368, 369, 370, 371, - 389, 390, 391, 392, 393, 423, 424, 425, 426, 427, - 428, 429, 430, 469, 470, 471, 473, 474, 475, 476, - 477, 478, 479, 480, 481, 522, 524, 528, 525, 358, - 393, 367, 366, 364, 358, 364, 358, 364, 366, 364, - 364, 364, 358, 364, 364, 364, 364, 364, 364, 364, - 358, 364, 358, 364, 357, 360, 364, 367, 519, 524, - 534, 535, 532, 366, 358, 364, 358, 364, 360, 480, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 524, 359, 367, 361, 362, 367, 401, 402, - 403, 404, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 432, 480, 493, 495, 497, 499, 503, 522, - 524, 540, 541, 542, 543, 544, 552, 553, 554, 555, - 558, 559, 562, 563, 564, 571, 576, 525, 366, 525, - 361, 495, 538, 366, 501, 393, 364, 367, 480, 480, - 497, 337, 338, 359, 363, 358, 358, 364, 400, 495, - 357, 480, 364, 376, 576, 356, 359, 390, 580, 598, - 393, 599, 356, 389, 390, 391, 392, 584, 585, 390, - 493, 498, 586, 390, 389, 390, 391, 392, 589, 590, - 390, 389, 390, 391, 392, 469, 591, 592, 390, 356, - 593, 390, 598, 393, 498, 529, 595, 596, 390, 498, - 360, 578, 524, 393, 536, 537, 362, 535, 534, 498, - 517, 393, 372, 373, 374, 369, 371, 335, 336, 339, - 340, 375, 376, 341, 342, 379, 378, 377, 343, 345, - 344, 380, 360, 360, 493, 362, 545, 357, 367, 367, - 566, 357, 357, 367, 367, 497, 357, 497, 365, 367, - 367, 367, 367, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 366, 496, 364, 367, 362, 541, 555, - 559, 564, 538, 366, 362, 538, 539, 538, 534, 393, - 358, 472, 497, 393, 495, 480, 356, 390, 581, 582, - 358, 366, 358, 364, 358, 364, 358, 364, 364, 358, - 364, 358, 364, 358, 364, 364, 358, 364, 364, 358, - 364, 358, 364, 358, 358, 536, 525, 364, 367, 362, - 480, 480, 480, 482, 482, 483, 483, 484, 484, 484, - 484, 485, 485, 486, 487, 488, 489, 490, 491, 494, - 360, 552, 565, 541, 567, 497, 367, 497, 365, 495, - 495, 538, 362, 364, 362, 360, 360, 364, 360, 364, - 585, 584, 498, 586, 590, 589, 592, 591, 356, 593, - 595, 596, 367, 537, 497, 546, 497, 512, 557, 401, - 540, 553, 568, 358, 358, 362, 538, 356, 390, 358, - 358, 358, 358, 358, 358, 365, 362, 393, 358, 357, - 557, 569, 570, 548, 549, 550, 556, 560, 495, 366, - 542, 547, 551, 497, 367, 358, 405, 544, 542, 361, - 538, 358, 497, 547, 548, 552, 561, 367, 362 + 468, 500, 501, 504, 505, 506, 507, 511, 512, 513, + 514, 515, 516, 519, 520, 521, 522, 523, 525, 530, + 531, 532, 573, 574, 575, 577, 584, 588, 589, 595, + 598, 358, 358, 358, 358, 358, 358, 358, 358, 360, + 531, 362, 394, 358, 358, 368, 394, 368, 576, 359, + 365, 508, 509, 510, 520, 525, 365, 368, 394, 368, + 394, 521, 525, 376, 527, 528, 0, 574, 505, 513, + 520, 368, 504, 394, 580, 581, 599, 600, 391, 394, + 580, 391, 580, 391, 580, 391, 580, 391, 580, 580, + 599, 391, 580, 394, 578, 579, 525, 534, 362, 394, + 418, 517, 518, 394, 524, 360, 368, 526, 362, 552, + 577, 509, 508, 510, 394, 394, 358, 367, 526, 362, + 365, 368, 503, 338, 339, 357, 358, 369, 370, 371, + 372, 390, 391, 392, 393, 394, 424, 425, 426, 427, + 428, 429, 430, 431, 470, 471, 472, 474, 475, 476, + 477, 478, 479, 480, 481, 482, 523, 525, 529, 526, + 359, 394, 368, 367, 365, 359, 365, 359, 365, 367, + 365, 365, 365, 359, 365, 365, 365, 365, 365, 365, + 365, 359, 365, 359, 365, 358, 361, 365, 368, 520, + 525, 535, 536, 533, 367, 359, 365, 359, 365, 361, + 481, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 525, 360, 368, 362, 363, 368, 402, + 403, 404, 405, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 433, 481, 494, 496, 498, 500, 504, + 523, 525, 541, 542, 543, 544, 545, 553, 554, 555, + 556, 559, 560, 563, 564, 565, 572, 577, 526, 367, + 526, 362, 496, 539, 367, 502, 394, 365, 368, 481, + 481, 498, 338, 339, 360, 364, 359, 359, 365, 401, + 496, 358, 481, 365, 377, 577, 357, 360, 391, 581, + 599, 394, 600, 357, 390, 391, 392, 393, 585, 586, + 391, 494, 499, 587, 391, 390, 391, 392, 393, 590, + 591, 391, 390, 391, 392, 393, 470, 592, 593, 391, + 357, 594, 391, 599, 394, 499, 530, 596, 597, 391, + 499, 361, 579, 525, 394, 537, 538, 363, 536, 535, + 499, 518, 394, 373, 374, 375, 370, 372, 336, 337, + 340, 341, 376, 377, 342, 343, 380, 379, 378, 344, + 346, 345, 381, 361, 361, 494, 363, 546, 358, 368, + 368, 567, 358, 358, 368, 368, 498, 358, 498, 366, + 368, 368, 368, 368, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 367, 497, 365, 368, 363, 542, + 556, 560, 565, 539, 367, 363, 539, 540, 539, 535, + 394, 359, 473, 498, 394, 496, 481, 357, 391, 582, + 583, 359, 367, 359, 365, 359, 365, 359, 365, 365, + 359, 365, 359, 365, 359, 365, 365, 359, 365, 365, + 359, 365, 359, 365, 359, 359, 537, 526, 365, 368, + 363, 481, 481, 481, 483, 483, 484, 484, 485, 485, + 485, 485, 486, 486, 487, 488, 489, 490, 491, 492, + 495, 361, 553, 566, 542, 568, 498, 368, 498, 366, + 496, 496, 539, 363, 365, 363, 361, 361, 365, 361, + 365, 586, 585, 499, 587, 591, 590, 593, 592, 357, + 594, 596, 597, 368, 538, 498, 547, 498, 513, 558, + 402, 541, 554, 569, 359, 359, 363, 539, 357, 391, + 359, 359, 359, 359, 359, 359, 366, 363, 394, 359, + 358, 558, 570, 571, 549, 550, 551, 557, 561, 496, + 367, 543, 548, 552, 498, 368, 359, 406, 545, 543, + 362, 539, 359, 498, 548, 549, 553, 562, 368, 363 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_int16 yyr1[] = { - 0, 468, 469, 470, 470, 470, 470, 470, 470, 470, - 470, 470, 470, 470, 470, 470, 470, 470, 471, 471, - 471, 471, 471, 471, 472, 473, 474, 475, 475, 476, - 476, 477, 477, 478, 479, 479, 479, 480, 480, 480, - 480, 481, 481, 481, 481, 482, 482, 482, 482, 483, - 483, 483, 484, 484, 484, 485, 485, 485, 485, 485, - 486, 486, 486, 487, 487, 488, 488, 489, 489, 490, - 490, 491, 491, 492, 492, 493, 494, 493, 495, 495, - 496, 496, 496, 496, 496, 496, 496, 496, 496, 496, - 496, 497, 497, 498, 499, 499, 499, 499, 499, 499, - 499, 499, 499, 499, 499, 501, 500, 502, 502, 503, - 503, 503, 503, 504, 504, 505, 505, 506, 507, 507, - 508, 508, 508, 508, 509, 510, 510, 510, 510, 510, - 511, 511, 511, 511, 511, 512, 512, 513, 514, 514, - 514, 514, 514, 514, 514, 514, 514, 514, 515, 516, - 516, 517, 517, 517, 518, 519, 519, 520, 520, 520, - 520, 520, 520, 520, 520, 520, 520, 520, 521, 521, - 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, - 521, 521, 521, 521, 521, 521, 522, 523, 523, 524, - 524, 525, 525, 525, 525, 526, 526, 527, 528, 528, - 528, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, - 529, 529, 529, 529, 530, 530, 530, 532, 531, 533, - 531, 534, 534, 535, 535, 536, 536, 537, 537, 538, - 538, 538, 538, 539, 539, 540, 541, 541, 542, 542, - 542, 542, 542, 542, 542, 542, 543, 544, 545, 546, - 544, 547, 547, 549, 548, 550, 548, 551, 551, 552, - 552, 553, 553, 554, 554, 555, 556, 556, 557, 557, - 558, 558, 560, 559, 561, 561, 562, 562, 563, 563, - 565, 564, 566, 564, 567, 564, 568, 568, 569, 569, - 570, 570, 571, 571, 571, 571, 571, 571, 571, 571, - 572, 572, 573, 573, 573, 575, 574, 576, 577, 577, - 578, 578, 579, 579, 580, 580, 581, 581, 582, 582, - 583, 583, 583, 583, 583, 583, 584, 584, 585, 585, - 585, 585, 585, 586, 586, 587, 587, 588, 588, 588, - 588, 588, 588, 588, 588, 589, 589, 590, 590, 590, - 590, 591, 591, 592, 592, 592, 592, 592, 593, 593, - 594, 594, 594, 594, 595, 595, 596, 596, 597, 597, - 598, 598, 599, 599 + 0, 469, 470, 471, 471, 471, 471, 471, 471, 471, + 471, 471, 471, 471, 471, 471, 471, 471, 472, 472, + 472, 472, 472, 472, 473, 474, 475, 476, 476, 477, + 477, 478, 478, 479, 480, 480, 480, 481, 481, 481, + 481, 482, 482, 482, 482, 483, 483, 483, 483, 484, + 484, 484, 485, 485, 485, 486, 486, 486, 486, 486, + 487, 487, 487, 488, 488, 489, 489, 490, 490, 491, + 491, 492, 492, 493, 493, 494, 495, 494, 496, 496, + 497, 497, 497, 497, 497, 497, 497, 497, 497, 497, + 497, 498, 498, 499, 500, 500, 500, 500, 500, 500, + 500, 500, 500, 500, 500, 502, 501, 503, 503, 504, + 504, 504, 504, 505, 505, 506, 506, 507, 508, 508, + 509, 509, 509, 509, 510, 511, 511, 511, 511, 511, + 512, 512, 512, 512, 512, 513, 513, 514, 515, 515, + 515, 515, 515, 515, 515, 515, 515, 515, 516, 517, + 517, 518, 518, 518, 519, 520, 520, 521, 521, 521, + 521, 521, 521, 521, 521, 521, 521, 521, 522, 522, + 522, 522, 522, 522, 522, 522, 522, 522, 522, 522, + 522, 522, 522, 522, 522, 522, 522, 522, 522, 522, + 522, 522, 522, 522, 522, 522, 522, 522, 522, 522, + 522, 522, 522, 522, 522, 522, 523, 524, 524, 525, + 525, 526, 526, 526, 526, 527, 527, 528, 529, 529, + 529, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 530, 530, 530, 530, 530, 531, 531, 531, 533, 532, + 534, 532, 535, 535, 536, 536, 537, 537, 538, 538, + 539, 539, 539, 539, 540, 540, 541, 542, 542, 543, + 543, 543, 543, 543, 543, 543, 543, 544, 545, 546, + 547, 545, 548, 548, 550, 549, 551, 549, 552, 552, + 553, 553, 554, 554, 555, 555, 556, 557, 557, 558, + 558, 559, 559, 561, 560, 562, 562, 563, 563, 564, + 564, 566, 565, 567, 565, 568, 565, 569, 569, 570, + 570, 571, 571, 572, 572, 572, 572, 572, 572, 572, + 572, 573, 573, 574, 574, 574, 576, 575, 577, 578, + 578, 579, 579, 580, 580, 581, 581, 582, 582, 583, + 583, 584, 584, 584, 584, 584, 584, 585, 585, 586, + 586, 586, 586, 586, 587, 587, 588, 588, 589, 589, + 589, 589, 589, 589, 589, 589, 590, 590, 591, 591, + 591, 591, 592, 592, 593, 593, 593, 593, 593, 594, + 594, 595, 595, 595, 595, 596, 596, 597, 597, 598, + 598, 599, 599, 600, 600 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -4471,23 +4478,23 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 0, 6, 0, - 5, 1, 2, 3, 4, 1, 3, 1, 2, 1, - 3, 4, 2, 1, 3, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 2, 2, 0, 0, - 5, 1, 1, 0, 2, 0, 2, 2, 3, 1, - 2, 1, 2, 1, 2, 5, 3, 1, 1, 4, - 1, 2, 0, 8, 0, 1, 3, 2, 1, 2, - 0, 6, 0, 8, 0, 7, 1, 1, 1, 0, - 2, 3, 2, 2, 2, 3, 2, 2, 2, 2, - 1, 2, 1, 1, 1, 0, 3, 5, 1, 3, - 1, 4, 1, 3, 5, 5, 1, 3, 1, 3, - 4, 6, 6, 8, 6, 8, 1, 3, 1, 1, - 1, 1, 1, 1, 3, 4, 6, 4, 6, 6, - 8, 6, 8, 6, 8, 1, 3, 1, 1, 1, - 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, - 6, 8, 4, 6, 1, 3, 1, 1, 4, 6, - 1, 3, 3, 3 + 1, 1, 1, 1, 1, 1, 1, 1, 0, 6, + 0, 5, 1, 2, 3, 4, 1, 3, 1, 2, + 1, 3, 4, 2, 1, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 0, + 0, 5, 1, 1, 0, 2, 0, 2, 2, 3, + 1, 2, 1, 2, 1, 2, 5, 3, 1, 1, + 4, 1, 2, 0, 8, 0, 1, 3, 2, 1, + 2, 0, 6, 0, 8, 0, 7, 1, 1, 1, + 0, 2, 3, 2, 2, 2, 3, 2, 2, 2, + 2, 1, 2, 1, 1, 1, 0, 3, 5, 1, + 3, 1, 4, 1, 3, 5, 5, 1, 3, 1, + 3, 4, 6, 6, 8, 6, 8, 1, 3, 1, + 1, 1, 1, 1, 1, 3, 4, 6, 4, 6, + 6, 8, 6, 8, 6, 8, 1, 3, 1, 1, + 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, + 3, 6, 8, 4, 6, 1, 3, 1, 1, 4, + 6, 1, 3, 3, 3 }; @@ -5229,260 +5236,260 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); switch (yyn) { case 2: /* variable_identifier: IDENTIFIER */ -#line 356 "MachineIndependent/glslang.y" +#line 357 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 5237 "MachineIndependent/glslang_tab.cpp" +#line 5244 "MachineIndependent/glslang_tab.cpp" break; case 3: /* primary_expression: variable_identifier */ -#line 362 "MachineIndependent/glslang.y" +#line 363 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5245 "MachineIndependent/glslang_tab.cpp" +#line 5252 "MachineIndependent/glslang_tab.cpp" break; case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN */ -#line 365 "MachineIndependent/glslang.y" +#line 366 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 5255 "MachineIndependent/glslang_tab.cpp" +#line 5262 "MachineIndependent/glslang_tab.cpp" break; case 5: /* primary_expression: FLOATCONSTANT */ -#line 370 "MachineIndependent/glslang.y" +#line 371 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 5263 "MachineIndependent/glslang_tab.cpp" +#line 5270 "MachineIndependent/glslang_tab.cpp" break; case 6: /* primary_expression: INTCONSTANT */ -#line 373 "MachineIndependent/glslang.y" +#line 374 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5271 "MachineIndependent/glslang_tab.cpp" +#line 5278 "MachineIndependent/glslang_tab.cpp" break; case 7: /* primary_expression: UINTCONSTANT */ -#line 376 "MachineIndependent/glslang.y" +#line 377 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5280 "MachineIndependent/glslang_tab.cpp" +#line 5287 "MachineIndependent/glslang_tab.cpp" break; case 8: /* primary_expression: BOOLCONSTANT */ -#line 380 "MachineIndependent/glslang.y" +#line 381 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 5288 "MachineIndependent/glslang_tab.cpp" +#line 5295 "MachineIndependent/glslang_tab.cpp" break; case 9: /* primary_expression: STRING_LITERAL */ -#line 383 "MachineIndependent/glslang.y" +#line 384 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 5296 "MachineIndependent/glslang_tab.cpp" +#line 5303 "MachineIndependent/glslang_tab.cpp" break; case 10: /* primary_expression: INT32CONSTANT */ -#line 386 "MachineIndependent/glslang.y" +#line 387 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5305 "MachineIndependent/glslang_tab.cpp" +#line 5312 "MachineIndependent/glslang_tab.cpp" break; case 11: /* primary_expression: UINT32CONSTANT */ -#line 390 "MachineIndependent/glslang.y" +#line 391 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5314 "MachineIndependent/glslang_tab.cpp" +#line 5321 "MachineIndependent/glslang_tab.cpp" break; case 12: /* primary_expression: INT64CONSTANT */ -#line 394 "MachineIndependent/glslang.y" +#line 395 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 5323 "MachineIndependent/glslang_tab.cpp" +#line 5330 "MachineIndependent/glslang_tab.cpp" break; case 13: /* primary_expression: UINT64CONSTANT */ -#line 398 "MachineIndependent/glslang.y" +#line 399 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 5332 "MachineIndependent/glslang_tab.cpp" +#line 5339 "MachineIndependent/glslang_tab.cpp" break; case 14: /* primary_expression: INT16CONSTANT */ -#line 402 "MachineIndependent/glslang.y" +#line 403 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5341 "MachineIndependent/glslang_tab.cpp" +#line 5348 "MachineIndependent/glslang_tab.cpp" break; case 15: /* primary_expression: UINT16CONSTANT */ -#line 406 "MachineIndependent/glslang.y" +#line 407 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5350 "MachineIndependent/glslang_tab.cpp" +#line 5357 "MachineIndependent/glslang_tab.cpp" break; case 16: /* primary_expression: DOUBLECONSTANT */ -#line 410 "MachineIndependent/glslang.y" +#line 411 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); } -#line 5361 "MachineIndependent/glslang_tab.cpp" +#line 5368 "MachineIndependent/glslang_tab.cpp" break; case 17: /* primary_expression: FLOAT16CONSTANT */ -#line 416 "MachineIndependent/glslang.y" +#line 417 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 5370 "MachineIndependent/glslang_tab.cpp" +#line 5377 "MachineIndependent/glslang_tab.cpp" break; case 18: /* postfix_expression: primary_expression */ -#line 423 "MachineIndependent/glslang.y" +#line 424 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5378 "MachineIndependent/glslang_tab.cpp" +#line 5385 "MachineIndependent/glslang_tab.cpp" break; case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET */ -#line 426 "MachineIndependent/glslang.y" +#line 427 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 5386 "MachineIndependent/glslang_tab.cpp" +#line 5393 "MachineIndependent/glslang_tab.cpp" break; case 20: /* postfix_expression: function_call */ -#line 429 "MachineIndependent/glslang.y" +#line 430 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5394 "MachineIndependent/glslang_tab.cpp" +#line 5401 "MachineIndependent/glslang_tab.cpp" break; case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER */ -#line 432 "MachineIndependent/glslang.y" +#line 433 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 5402 "MachineIndependent/glslang_tab.cpp" +#line 5409 "MachineIndependent/glslang_tab.cpp" break; case 22: /* postfix_expression: postfix_expression INC_OP */ -#line 435 "MachineIndependent/glslang.y" +#line 436 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5412 "MachineIndependent/glslang_tab.cpp" +#line 5419 "MachineIndependent/glslang_tab.cpp" break; case 23: /* postfix_expression: postfix_expression DEC_OP */ -#line 440 "MachineIndependent/glslang.y" +#line 441 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5422 "MachineIndependent/glslang_tab.cpp" +#line 5429 "MachineIndependent/glslang_tab.cpp" break; case 24: /* integer_expression: expression */ -#line 448 "MachineIndependent/glslang.y" +#line 449 "MachineIndependent/glslang.y" { parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5431 "MachineIndependent/glslang_tab.cpp" +#line 5438 "MachineIndependent/glslang_tab.cpp" break; case 25: /* function_call: function_call_or_method */ -#line 455 "MachineIndependent/glslang.y" +#line 456 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 5440 "MachineIndependent/glslang_tab.cpp" +#line 5447 "MachineIndependent/glslang_tab.cpp" break; case 26: /* function_call_or_method: function_call_generic */ -#line 462 "MachineIndependent/glslang.y" +#line 463 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5448 "MachineIndependent/glslang_tab.cpp" +#line 5455 "MachineIndependent/glslang_tab.cpp" break; case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN */ -#line 468 "MachineIndependent/glslang.y" +#line 469 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5457 "MachineIndependent/glslang_tab.cpp" +#line 5464 "MachineIndependent/glslang_tab.cpp" break; case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN */ -#line 472 "MachineIndependent/glslang.y" +#line 473 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5466 "MachineIndependent/glslang_tab.cpp" +#line 5473 "MachineIndependent/glslang_tab.cpp" break; case 29: /* function_call_header_no_parameters: function_call_header VOID */ -#line 479 "MachineIndependent/glslang.y" +#line 480 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5474 "MachineIndependent/glslang_tab.cpp" +#line 5481 "MachineIndependent/glslang_tab.cpp" break; case 30: /* function_call_header_no_parameters: function_call_header */ -#line 482 "MachineIndependent/glslang.y" +#line 483 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5482 "MachineIndependent/glslang_tab.cpp" +#line 5489 "MachineIndependent/glslang_tab.cpp" break; case 31: /* function_call_header_with_parameters: function_call_header assignment_expression */ -#line 488 "MachineIndependent/glslang.y" +#line 489 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5501,11 +5508,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } } -#line 5505 "MachineIndependent/glslang_tab.cpp" +#line 5512 "MachineIndependent/glslang_tab.cpp" break; case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression */ -#line 506 "MachineIndependent/glslang.y" +#line 507 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5528,29 +5535,29 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } } -#line 5532 "MachineIndependent/glslang_tab.cpp" +#line 5539 "MachineIndependent/glslang_tab.cpp" break; case 33: /* function_call_header: function_identifier LEFT_PAREN */ -#line 531 "MachineIndependent/glslang.y" +#line 532 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5540 "MachineIndependent/glslang_tab.cpp" +#line 5547 "MachineIndependent/glslang_tab.cpp" break; case 34: /* function_identifier: type_specifier */ -#line 539 "MachineIndependent/glslang.y" +#line 540 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5550 "MachineIndependent/glslang_tab.cpp" +#line 5557 "MachineIndependent/glslang_tab.cpp" break; case 35: /* function_identifier: postfix_expression */ -#line 544 "MachineIndependent/glslang.y" +#line 545 "MachineIndependent/glslang.y" { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -5578,50 +5585,50 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 5582 "MachineIndependent/glslang_tab.cpp" +#line 5589 "MachineIndependent/glslang_tab.cpp" break; case 36: /* function_identifier: non_uniform_qualifier */ -#line 571 "MachineIndependent/glslang.y" +#line 572 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5592 "MachineIndependent/glslang_tab.cpp" +#line 5599 "MachineIndependent/glslang_tab.cpp" break; case 37: /* unary_expression: postfix_expression */ -#line 579 "MachineIndependent/glslang.y" +#line 580 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 5603 "MachineIndependent/glslang_tab.cpp" +#line 5610 "MachineIndependent/glslang_tab.cpp" break; case 38: /* unary_expression: INC_OP unary_expression */ -#line 585 "MachineIndependent/glslang.y" +#line 586 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5612 "MachineIndependent/glslang_tab.cpp" +#line 5619 "MachineIndependent/glslang_tab.cpp" break; case 39: /* unary_expression: DEC_OP unary_expression */ -#line 589 "MachineIndependent/glslang.y" +#line 590 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5621 "MachineIndependent/glslang_tab.cpp" +#line 5628 "MachineIndependent/glslang_tab.cpp" break; case 40: /* unary_expression: unary_operator unary_expression */ -#line 593 "MachineIndependent/glslang.y" +#line 594 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -5638,179 +5645,179 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 5642 "MachineIndependent/glslang_tab.cpp" +#line 5649 "MachineIndependent/glslang_tab.cpp" break; case 41: /* unary_operator: PLUS */ -#line 613 "MachineIndependent/glslang.y" +#line 614 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 5648 "MachineIndependent/glslang_tab.cpp" +#line 5655 "MachineIndependent/glslang_tab.cpp" break; case 42: /* unary_operator: DASH */ -#line 614 "MachineIndependent/glslang.y" +#line 615 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 5654 "MachineIndependent/glslang_tab.cpp" +#line 5661 "MachineIndependent/glslang_tab.cpp" break; case 43: /* unary_operator: BANG */ -#line 615 "MachineIndependent/glslang.y" +#line 616 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 5660 "MachineIndependent/glslang_tab.cpp" +#line 5667 "MachineIndependent/glslang_tab.cpp" break; case 44: /* unary_operator: TILDE */ -#line 616 "MachineIndependent/glslang.y" +#line 617 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } -#line 5667 "MachineIndependent/glslang_tab.cpp" +#line 5674 "MachineIndependent/glslang_tab.cpp" break; case 45: /* multiplicative_expression: unary_expression */ -#line 622 "MachineIndependent/glslang.y" +#line 623 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5673 "MachineIndependent/glslang_tab.cpp" +#line 5680 "MachineIndependent/glslang_tab.cpp" break; case 46: /* multiplicative_expression: multiplicative_expression STAR unary_expression */ -#line 623 "MachineIndependent/glslang.y" +#line 624 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5683 "MachineIndependent/glslang_tab.cpp" +#line 5690 "MachineIndependent/glslang_tab.cpp" break; case 47: /* multiplicative_expression: multiplicative_expression SLASH unary_expression */ -#line 628 "MachineIndependent/glslang.y" +#line 629 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5693 "MachineIndependent/glslang_tab.cpp" +#line 5700 "MachineIndependent/glslang_tab.cpp" break; case 48: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression */ -#line 633 "MachineIndependent/glslang.y" +#line 634 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5704 "MachineIndependent/glslang_tab.cpp" +#line 5711 "MachineIndependent/glslang_tab.cpp" break; case 49: /* additive_expression: multiplicative_expression */ -#line 642 "MachineIndependent/glslang.y" +#line 643 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5710 "MachineIndependent/glslang_tab.cpp" +#line 5717 "MachineIndependent/glslang_tab.cpp" break; case 50: /* additive_expression: additive_expression PLUS multiplicative_expression */ -#line 643 "MachineIndependent/glslang.y" +#line 644 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5720 "MachineIndependent/glslang_tab.cpp" +#line 5727 "MachineIndependent/glslang_tab.cpp" break; case 51: /* additive_expression: additive_expression DASH multiplicative_expression */ -#line 648 "MachineIndependent/glslang.y" +#line 649 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5730 "MachineIndependent/glslang_tab.cpp" +#line 5737 "MachineIndependent/glslang_tab.cpp" break; case 52: /* shift_expression: additive_expression */ -#line 656 "MachineIndependent/glslang.y" +#line 657 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5736 "MachineIndependent/glslang_tab.cpp" +#line 5743 "MachineIndependent/glslang_tab.cpp" break; case 53: /* shift_expression: shift_expression LEFT_OP additive_expression */ -#line 657 "MachineIndependent/glslang.y" +#line 658 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5747 "MachineIndependent/glslang_tab.cpp" +#line 5754 "MachineIndependent/glslang_tab.cpp" break; case 54: /* shift_expression: shift_expression RIGHT_OP additive_expression */ -#line 663 "MachineIndependent/glslang.y" +#line 664 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5758 "MachineIndependent/glslang_tab.cpp" +#line 5765 "MachineIndependent/glslang_tab.cpp" break; case 55: /* relational_expression: shift_expression */ -#line 672 "MachineIndependent/glslang.y" +#line 673 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5764 "MachineIndependent/glslang_tab.cpp" +#line 5771 "MachineIndependent/glslang_tab.cpp" break; case 56: /* relational_expression: relational_expression LEFT_ANGLE shift_expression */ -#line 673 "MachineIndependent/glslang.y" +#line 674 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5774 "MachineIndependent/glslang_tab.cpp" +#line 5781 "MachineIndependent/glslang_tab.cpp" break; case 57: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression */ -#line 678 "MachineIndependent/glslang.y" +#line 679 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5784 "MachineIndependent/glslang_tab.cpp" +#line 5791 "MachineIndependent/glslang_tab.cpp" break; case 58: /* relational_expression: relational_expression LE_OP shift_expression */ -#line 683 "MachineIndependent/glslang.y" +#line 684 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5794 "MachineIndependent/glslang_tab.cpp" +#line 5801 "MachineIndependent/glslang_tab.cpp" break; case 59: /* relational_expression: relational_expression GE_OP shift_expression */ -#line 688 "MachineIndependent/glslang.y" +#line 689 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5804 "MachineIndependent/glslang_tab.cpp" +#line 5811 "MachineIndependent/glslang_tab.cpp" break; case 60: /* equality_expression: relational_expression */ -#line 696 "MachineIndependent/glslang.y" +#line 697 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5810 "MachineIndependent/glslang_tab.cpp" +#line 5817 "MachineIndependent/glslang_tab.cpp" break; case 61: /* equality_expression: equality_expression EQ_OP relational_expression */ -#line 697 "MachineIndependent/glslang.y" +#line 698 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); @@ -5820,11 +5827,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5824 "MachineIndependent/glslang_tab.cpp" +#line 5831 "MachineIndependent/glslang_tab.cpp" break; case 62: /* equality_expression: equality_expression NE_OP relational_expression */ -#line 706 "MachineIndependent/glslang.y" +#line 707 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -5834,124 +5841,124 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5838 "MachineIndependent/glslang_tab.cpp" +#line 5845 "MachineIndependent/glslang_tab.cpp" break; case 63: /* and_expression: equality_expression */ -#line 718 "MachineIndependent/glslang.y" +#line 719 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5844 "MachineIndependent/glslang_tab.cpp" +#line 5851 "MachineIndependent/glslang_tab.cpp" break; case 64: /* and_expression: and_expression AMPERSAND equality_expression */ -#line 719 "MachineIndependent/glslang.y" +#line 720 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5855 "MachineIndependent/glslang_tab.cpp" +#line 5862 "MachineIndependent/glslang_tab.cpp" break; case 65: /* exclusive_or_expression: and_expression */ -#line 728 "MachineIndependent/glslang.y" +#line 729 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5861 "MachineIndependent/glslang_tab.cpp" +#line 5868 "MachineIndependent/glslang_tab.cpp" break; case 66: /* exclusive_or_expression: exclusive_or_expression CARET and_expression */ -#line 729 "MachineIndependent/glslang.y" +#line 730 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5872 "MachineIndependent/glslang_tab.cpp" +#line 5879 "MachineIndependent/glslang_tab.cpp" break; case 67: /* inclusive_or_expression: exclusive_or_expression */ -#line 738 "MachineIndependent/glslang.y" +#line 739 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5878 "MachineIndependent/glslang_tab.cpp" +#line 5885 "MachineIndependent/glslang_tab.cpp" break; case 68: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression */ -#line 739 "MachineIndependent/glslang.y" +#line 740 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5889 "MachineIndependent/glslang_tab.cpp" +#line 5896 "MachineIndependent/glslang_tab.cpp" break; case 69: /* logical_and_expression: inclusive_or_expression */ -#line 748 "MachineIndependent/glslang.y" +#line 749 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5895 "MachineIndependent/glslang_tab.cpp" +#line 5902 "MachineIndependent/glslang_tab.cpp" break; case 70: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression */ -#line 749 "MachineIndependent/glslang.y" +#line 750 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5905 "MachineIndependent/glslang_tab.cpp" +#line 5912 "MachineIndependent/glslang_tab.cpp" break; case 71: /* logical_xor_expression: logical_and_expression */ -#line 757 "MachineIndependent/glslang.y" +#line 758 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5911 "MachineIndependent/glslang_tab.cpp" +#line 5918 "MachineIndependent/glslang_tab.cpp" break; case 72: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression */ -#line 758 "MachineIndependent/glslang.y" +#line 759 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5921 "MachineIndependent/glslang_tab.cpp" +#line 5928 "MachineIndependent/glslang_tab.cpp" break; case 73: /* logical_or_expression: logical_xor_expression */ -#line 766 "MachineIndependent/glslang.y" +#line 767 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5927 "MachineIndependent/glslang_tab.cpp" +#line 5934 "MachineIndependent/glslang_tab.cpp" break; case 74: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression */ -#line 767 "MachineIndependent/glslang.y" +#line 768 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5937 "MachineIndependent/glslang_tab.cpp" +#line 5944 "MachineIndependent/glslang_tab.cpp" break; case 75: /* conditional_expression: logical_or_expression */ -#line 775 "MachineIndependent/glslang.y" +#line 776 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5943 "MachineIndependent/glslang_tab.cpp" +#line 5950 "MachineIndependent/glslang_tab.cpp" break; case 76: /* $@1: %empty */ -#line 776 "MachineIndependent/glslang.y" +#line 777 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 5951 "MachineIndependent/glslang_tab.cpp" +#line 5958 "MachineIndependent/glslang_tab.cpp" break; case 77: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression */ -#line 779 "MachineIndependent/glslang.y" +#line 780 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -5964,17 +5971,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 5968 "MachineIndependent/glslang_tab.cpp" +#line 5975 "MachineIndependent/glslang_tab.cpp" break; case 78: /* assignment_expression: conditional_expression */ -#line 794 "MachineIndependent/glslang.y" +#line 795 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5974 "MachineIndependent/glslang_tab.cpp" +#line 5981 "MachineIndependent/glslang_tab.cpp" break; case 79: /* assignment_expression: unary_expression assignment_operator assignment_expression */ -#line 795 "MachineIndependent/glslang.y" +#line 796 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); @@ -5988,119 +5995,119 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 5992 "MachineIndependent/glslang_tab.cpp" +#line 5999 "MachineIndependent/glslang_tab.cpp" break; case 80: /* assignment_operator: EQUAL */ -#line 811 "MachineIndependent/glslang.y" +#line 812 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 6001 "MachineIndependent/glslang_tab.cpp" +#line 6008 "MachineIndependent/glslang_tab.cpp" break; case 81: /* assignment_operator: MUL_ASSIGN */ -#line 815 "MachineIndependent/glslang.y" +#line 816 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 6010 "MachineIndependent/glslang_tab.cpp" +#line 6017 "MachineIndependent/glslang_tab.cpp" break; case 82: /* assignment_operator: DIV_ASSIGN */ -#line 819 "MachineIndependent/glslang.y" +#line 820 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 6019 "MachineIndependent/glslang_tab.cpp" +#line 6026 "MachineIndependent/glslang_tab.cpp" break; case 83: /* assignment_operator: MOD_ASSIGN */ -#line 823 "MachineIndependent/glslang.y" +#line 824 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 6029 "MachineIndependent/glslang_tab.cpp" +#line 6036 "MachineIndependent/glslang_tab.cpp" break; case 84: /* assignment_operator: ADD_ASSIGN */ -#line 828 "MachineIndependent/glslang.y" +#line 829 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 6038 "MachineIndependent/glslang_tab.cpp" +#line 6045 "MachineIndependent/glslang_tab.cpp" break; case 85: /* assignment_operator: SUB_ASSIGN */ -#line 832 "MachineIndependent/glslang.y" +#line 833 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 6047 "MachineIndependent/glslang_tab.cpp" +#line 6054 "MachineIndependent/glslang_tab.cpp" break; case 86: /* assignment_operator: LEFT_ASSIGN */ -#line 836 "MachineIndependent/glslang.y" +#line 837 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 6056 "MachineIndependent/glslang_tab.cpp" +#line 6063 "MachineIndependent/glslang_tab.cpp" break; case 87: /* assignment_operator: RIGHT_ASSIGN */ -#line 840 "MachineIndependent/glslang.y" +#line 841 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 6065 "MachineIndependent/glslang_tab.cpp" +#line 6072 "MachineIndependent/glslang_tab.cpp" break; case 88: /* assignment_operator: AND_ASSIGN */ -#line 844 "MachineIndependent/glslang.y" +#line 845 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 6074 "MachineIndependent/glslang_tab.cpp" +#line 6081 "MachineIndependent/glslang_tab.cpp" break; case 89: /* assignment_operator: XOR_ASSIGN */ -#line 848 "MachineIndependent/glslang.y" +#line 849 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 6083 "MachineIndependent/glslang_tab.cpp" +#line 6090 "MachineIndependent/glslang_tab.cpp" break; case 90: /* assignment_operator: OR_ASSIGN */ -#line 852 "MachineIndependent/glslang.y" +#line 853 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 6092 "MachineIndependent/glslang_tab.cpp" +#line 6099 "MachineIndependent/glslang_tab.cpp" break; case 91: /* expression: assignment_expression */ -#line 859 "MachineIndependent/glslang.y" +#line 860 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6100 "MachineIndependent/glslang_tab.cpp" +#line 6107 "MachineIndependent/glslang_tab.cpp" break; case 92: /* expression: expression COMMA assignment_expression */ -#line 862 "MachineIndependent/glslang.y" +#line 863 "MachineIndependent/glslang.y" { parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); @@ -6109,30 +6116,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6113 "MachineIndependent/glslang_tab.cpp" +#line 6120 "MachineIndependent/glslang_tab.cpp" break; case 93: /* constant_expression: conditional_expression */ -#line 873 "MachineIndependent/glslang.y" +#line 874 "MachineIndependent/glslang.y" { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6122 "MachineIndependent/glslang_tab.cpp" +#line 6129 "MachineIndependent/glslang_tab.cpp" break; case 94: /* declaration: function_prototype SEMICOLON */ -#line 880 "MachineIndependent/glslang.y" +#line 881 "MachineIndependent/glslang.y" { parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6132 "MachineIndependent/glslang_tab.cpp" +#line 6139 "MachineIndependent/glslang_tab.cpp" break; case 95: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON */ -#line 885 "MachineIndependent/glslang.y" +#line 886 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier"); (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier @@ -6140,31 +6147,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6144 "MachineIndependent/glslang_tab.cpp" +#line 6151 "MachineIndependent/glslang_tab.cpp" break; case 96: /* declaration: spirv_execution_mode_qualifier SEMICOLON */ -#line 892 "MachineIndependent/glslang.y" +#line 893 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "SPIR-V execution mode qualifier"); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier"); (yyval.interm.intermNode) = 0; } -#line 6154 "MachineIndependent/glslang_tab.cpp" +#line 6161 "MachineIndependent/glslang_tab.cpp" break; case 97: /* declaration: init_declarator_list SEMICOLON */ -#line 897 "MachineIndependent/glslang.y" +#line 898 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; } -#line 6164 "MachineIndependent/glslang_tab.cpp" +#line 6171 "MachineIndependent/glslang_tab.cpp" break; case 98: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON */ -#line 902 "MachineIndependent/glslang.y" +#line 903 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope @@ -6172,75 +6179,75 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 6176 "MachineIndependent/glslang_tab.cpp" +#line 6183 "MachineIndependent/glslang_tab.cpp" break; case 99: /* declaration: block_structure SEMICOLON */ -#line 909 "MachineIndependent/glslang.y" +#line 910 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 6185 "MachineIndependent/glslang_tab.cpp" +#line 6192 "MachineIndependent/glslang_tab.cpp" break; case 100: /* declaration: block_structure IDENTIFIER SEMICOLON */ -#line 913 "MachineIndependent/glslang.y" +#line 914 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 6194 "MachineIndependent/glslang_tab.cpp" +#line 6201 "MachineIndependent/glslang_tab.cpp" break; case 101: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON */ -#line 917 "MachineIndependent/glslang.y" +#line 918 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); (yyval.interm.intermNode) = 0; } -#line 6203 "MachineIndependent/glslang_tab.cpp" +#line 6210 "MachineIndependent/glslang_tab.cpp" break; case 102: /* declaration: type_qualifier SEMICOLON */ -#line 921 "MachineIndependent/glslang.y" +#line 922 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 6213 "MachineIndependent/glslang_tab.cpp" +#line 6220 "MachineIndependent/glslang_tab.cpp" break; case 103: /* declaration: type_qualifier IDENTIFIER SEMICOLON */ -#line 926 "MachineIndependent/glslang.y" +#line 927 "MachineIndependent/glslang.y" { parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 6223 "MachineIndependent/glslang_tab.cpp" +#line 6230 "MachineIndependent/glslang_tab.cpp" break; case 104: /* declaration: type_qualifier IDENTIFIER identifier_list SEMICOLON */ -#line 931 "MachineIndependent/glslang.y" +#line 932 "MachineIndependent/glslang.y" { parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 6234 "MachineIndependent/glslang_tab.cpp" +#line 6241 "MachineIndependent/glslang_tab.cpp" break; case 105: /* $@2: %empty */ -#line 940 "MachineIndependent/glslang.y" +#line 941 "MachineIndependent/glslang.y" { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 6240 "MachineIndependent/glslang_tab.cpp" +#line 6247 "MachineIndependent/glslang_tab.cpp" break; case 106: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE */ -#line 940 "MachineIndependent/glslang.y" +#line 941 "MachineIndependent/glslang.y" { --parseContext.blockNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -6250,39 +6257,39 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 6254 "MachineIndependent/glslang_tab.cpp" +#line 6261 "MachineIndependent/glslang_tab.cpp" break; case 107: /* identifier_list: COMMA IDENTIFIER */ -#line 951 "MachineIndependent/glslang.y" +#line 952 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6263 "MachineIndependent/glslang_tab.cpp" +#line 6270 "MachineIndependent/glslang_tab.cpp" break; case 108: /* identifier_list: identifier_list COMMA IDENTIFIER */ -#line 955 "MachineIndependent/glslang.y" +#line 956 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6272 "MachineIndependent/glslang_tab.cpp" +#line 6279 "MachineIndependent/glslang_tab.cpp" break; case 109: /* function_prototype: function_declarator RIGHT_PAREN */ -#line 962 "MachineIndependent/glslang.y" +#line 963 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 6282 "MachineIndependent/glslang_tab.cpp" +#line 6289 "MachineIndependent/glslang_tab.cpp" break; case 110: /* function_prototype: function_declarator RIGHT_PAREN attribute */ -#line 967 "MachineIndependent/glslang.y" +#line 968 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6291,11 +6298,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6295 "MachineIndependent/glslang_tab.cpp" +#line 6302 "MachineIndependent/glslang_tab.cpp" break; case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN */ -#line 975 "MachineIndependent/glslang.y" +#line 976 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6304,11 +6311,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes)); } -#line 6308 "MachineIndependent/glslang_tab.cpp" +#line 6315 "MachineIndependent/glslang_tab.cpp" break; case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ -#line 983 "MachineIndependent/glslang.y" +#line 984 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6318,27 +6325,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes)); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6322 "MachineIndependent/glslang_tab.cpp" +#line 6329 "MachineIndependent/glslang_tab.cpp" break; case 113: /* function_declarator: function_header */ -#line 995 "MachineIndependent/glslang.y" +#line 996 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6330 "MachineIndependent/glslang_tab.cpp" +#line 6337 "MachineIndependent/glslang_tab.cpp" break; case 114: /* function_declarator: function_header_with_parameters */ -#line 998 "MachineIndependent/glslang.y" +#line 999 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6338 "MachineIndependent/glslang_tab.cpp" +#line 6345 "MachineIndependent/glslang_tab.cpp" break; case 115: /* function_header_with_parameters: function_header parameter_declaration */ -#line 1005 "MachineIndependent/glslang.y" +#line 1006 "MachineIndependent/glslang.y" { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -6352,11 +6359,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else delete (yyvsp[0].interm).param.type; } -#line 6356 "MachineIndependent/glslang_tab.cpp" +#line 6363 "MachineIndependent/glslang_tab.cpp" break; case 116: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ -#line 1018 "MachineIndependent/glslang.y" +#line 1019 "MachineIndependent/glslang.y" { // // Only first parameter of one-parameter functions can be void @@ -6377,11 +6384,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.vkRelaxedRemapFunctionParameter((yyvsp[-2].interm.function), (yyvsp[0].interm).param); } } -#line 6381 "MachineIndependent/glslang_tab.cpp" +#line 6388 "MachineIndependent/glslang_tab.cpp" break; case 117: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN */ -#line 1041 "MachineIndependent/glslang.y" +#line 1042 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", @@ -6401,11 +6408,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 6405 "MachineIndependent/glslang_tab.cpp" +#line 6412 "MachineIndependent/glslang_tab.cpp" break; case 118: /* parameter_declarator: type_specifier IDENTIFIER */ -#line 1064 "MachineIndependent/glslang.y" +#line 1065 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6421,11 +6428,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 6425 "MachineIndependent/glslang_tab.cpp" +#line 6432 "MachineIndependent/glslang_tab.cpp" break; case 119: /* parameter_declarator: type_specifier IDENTIFIER array_specifier */ -#line 1079 "MachineIndependent/glslang.y" +#line 1080 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6445,173 +6452,173 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 6449 "MachineIndependent/glslang_tab.cpp" +#line 6456 "MachineIndependent/glslang_tab.cpp" break; case 120: /* parameter_declaration: type_qualifier parameter_declarator */ -#line 1104 "MachineIndependent/glslang.y" +#line 1105 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 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 6465 "MachineIndependent/glslang_tab.cpp" +#line 6472 "MachineIndependent/glslang_tab.cpp" break; case 121: /* parameter_declaration: parameter_declarator */ -#line 1115 "MachineIndependent/glslang.y" +#line 1116 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); } -#line 6477 "MachineIndependent/glslang_tab.cpp" +#line 6484 "MachineIndependent/glslang_tab.cpp" break; case 122: /* parameter_declaration: type_qualifier parameter_type_specifier */ -#line 1125 "MachineIndependent/glslang.y" +#line 1126 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; - parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); + parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 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 6492 "MachineIndependent/glslang_tab.cpp" +#line 6499 "MachineIndependent/glslang_tab.cpp" break; case 123: /* parameter_declaration: parameter_type_specifier */ -#line 1135 "MachineIndependent/glslang.y" +#line 1136 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); } -#line 6504 "MachineIndependent/glslang_tab.cpp" +#line 6511 "MachineIndependent/glslang_tab.cpp" break; case 124: /* parameter_type_specifier: type_specifier */ -#line 1145 "MachineIndependent/glslang.y" +#line 1146 "MachineIndependent/glslang.y" { TParameter param = { 0, new TType((yyvsp[0].interm.type)), {} }; (yyval.interm).param = param; if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 6515 "MachineIndependent/glslang_tab.cpp" +#line 6522 "MachineIndependent/glslang_tab.cpp" break; case 125: /* init_declarator_list: single_declaration */ -#line 1154 "MachineIndependent/glslang.y" +#line 1155 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 6523 "MachineIndependent/glslang_tab.cpp" +#line 6530 "MachineIndependent/glslang_tab.cpp" break; case 126: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ -#line 1157 "MachineIndependent/glslang.y" +#line 1158 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 6532 "MachineIndependent/glslang_tab.cpp" +#line 6539 "MachineIndependent/glslang_tab.cpp" break; case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ -#line 1161 "MachineIndependent/glslang.y" +#line 1162 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); } -#line 6541 "MachineIndependent/glslang_tab.cpp" +#line 6548 "MachineIndependent/glslang_tab.cpp" break; case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ -#line 1165 "MachineIndependent/glslang.y" +#line 1166 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-5].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 6551 "MachineIndependent/glslang_tab.cpp" +#line 6558 "MachineIndependent/glslang_tab.cpp" break; case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ -#line 1170 "MachineIndependent/glslang.y" +#line 1171 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 6561 "MachineIndependent/glslang_tab.cpp" +#line 6568 "MachineIndependent/glslang_tab.cpp" break; case 130: /* single_declaration: fully_specified_type */ -#line 1178 "MachineIndependent/glslang.y" +#line 1179 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 6571 "MachineIndependent/glslang_tab.cpp" +#line 6578 "MachineIndependent/glslang_tab.cpp" break; case 131: /* single_declaration: fully_specified_type IDENTIFIER */ -#line 1183 "MachineIndependent/glslang.y" +#line 1184 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-1].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); } -#line 6581 "MachineIndependent/glslang_tab.cpp" +#line 6588 "MachineIndependent/glslang_tab.cpp" break; case 132: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ -#line 1188 "MachineIndependent/glslang.y" +#line 1189 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-2].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); } -#line 6591 "MachineIndependent/glslang_tab.cpp" +#line 6598 "MachineIndependent/glslang_tab.cpp" break; case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ -#line 1193 "MachineIndependent/glslang.y" +#line 1194 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 6601 "MachineIndependent/glslang_tab.cpp" +#line 6608 "MachineIndependent/glslang_tab.cpp" break; case 134: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 1198 "MachineIndependent/glslang.y" +#line 1199 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-3].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 6611 "MachineIndependent/glslang_tab.cpp" +#line 6618 "MachineIndependent/glslang_tab.cpp" break; case 135: /* fully_specified_type: type_specifier */ -#line 1207 "MachineIndependent/glslang.y" +#line 1208 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6620,13 +6627,13 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); } - parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).isCoopmat()); + parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).isCoopmatOrvec()); } -#line 6626 "MachineIndependent/glslang_tab.cpp" +#line 6633 "MachineIndependent/glslang_tab.cpp" break; case 136: /* fully_specified_type: type_qualifier type_specifier */ -#line 1217 "MachineIndependent/glslang.y" +#line 1218 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, false, &(yyvsp[0].interm.type)); parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); @@ -6642,7 +6649,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true); - parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier, (yyvsp[0].interm.type).isCoopmat()); + parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier, (yyvsp[0].interm.type).isCoopmatOrvec()); (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6651,22 +6658,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 6655 "MachineIndependent/glslang_tab.cpp" +#line 6662 "MachineIndependent/glslang_tab.cpp" break; case 137: /* invariant_qualifier: INVARIANT */ -#line 1244 "MachineIndependent/glslang.y" +#line 1245 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 6666 "MachineIndependent/glslang_tab.cpp" +#line 6673 "MachineIndependent/glslang_tab.cpp" break; case 138: /* interpolation_qualifier: SMOOTH */ -#line 1253 "MachineIndependent/glslang.y" +#line 1254 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -6674,11 +6681,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 6678 "MachineIndependent/glslang_tab.cpp" +#line 6685 "MachineIndependent/glslang_tab.cpp" break; case 139: /* interpolation_qualifier: FLAT */ -#line 1260 "MachineIndependent/glslang.y" +#line 1261 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -6686,11 +6693,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 6690 "MachineIndependent/glslang_tab.cpp" +#line 6697 "MachineIndependent/glslang_tab.cpp" break; case 140: /* interpolation_qualifier: NOPERSPECTIVE */ -#line 1267 "MachineIndependent/glslang.y" +#line 1268 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective"); @@ -6698,11 +6705,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 6702 "MachineIndependent/glslang_tab.cpp" +#line 6709 "MachineIndependent/glslang_tab.cpp" break; case 141: /* interpolation_qualifier: EXPLICITINTERPAMD */ -#line 1274 "MachineIndependent/glslang.y" +#line 1275 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); @@ -6710,11 +6717,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.explicitInterp = true; } -#line 6714 "MachineIndependent/glslang_tab.cpp" +#line 6721 "MachineIndependent/glslang_tab.cpp" break; case 142: /* interpolation_qualifier: PERVERTEXNV */ -#line 1281 "MachineIndependent/glslang.y" +#line 1282 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); @@ -6723,11 +6730,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexNV = true; } -#line 6727 "MachineIndependent/glslang_tab.cpp" +#line 6734 "MachineIndependent/glslang_tab.cpp" break; case 143: /* interpolation_qualifier: PERVERTEXEXT */ -#line 1289 "MachineIndependent/glslang.y" +#line 1290 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexEXT"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_EXT_fragment_shader_barycentric, "fragment shader barycentric"); @@ -6736,11 +6743,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexEXT = true; } -#line 6740 "MachineIndependent/glslang_tab.cpp" +#line 6747 "MachineIndependent/glslang_tab.cpp" break; case 144: /* interpolation_qualifier: PERPRIMITIVENV */ -#line 1297 "MachineIndependent/glslang.y" +#line 1298 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); @@ -6751,11 +6758,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6755 "MachineIndependent/glslang_tab.cpp" +#line 6762 "MachineIndependent/glslang_tab.cpp" break; case 145: /* interpolation_qualifier: PERPRIMITIVEEXT */ -#line 1307 "MachineIndependent/glslang.y" +#line 1308 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveEXT"); @@ -6766,11 +6773,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6770 "MachineIndependent/glslang_tab.cpp" +#line 6777 "MachineIndependent/glslang_tab.cpp" break; case 146: /* interpolation_qualifier: PERVIEWNV */ -#line 1317 "MachineIndependent/glslang.y" +#line 1318 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); @@ -6778,11 +6785,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perViewNV = true; } -#line 6782 "MachineIndependent/glslang_tab.cpp" +#line 6789 "MachineIndependent/glslang_tab.cpp" break; case 147: /* interpolation_qualifier: PERTASKNV */ -#line 1324 "MachineIndependent/glslang.y" +#line 1325 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); @@ -6790,84 +6797,84 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perTaskNV = true; } -#line 6794 "MachineIndependent/glslang_tab.cpp" +#line 6801 "MachineIndependent/glslang_tab.cpp" break; case 148: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ -#line 1334 "MachineIndependent/glslang.y" +#line 1335 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 6802 "MachineIndependent/glslang_tab.cpp" +#line 6809 "MachineIndependent/glslang_tab.cpp" break; case 149: /* layout_qualifier_id_list: layout_qualifier_id */ -#line 1340 "MachineIndependent/glslang.y" +#line 1341 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6810 "MachineIndependent/glslang_tab.cpp" +#line 6817 "MachineIndependent/glslang_tab.cpp" break; case 150: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ -#line 1343 "MachineIndependent/glslang.y" +#line 1344 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 6820 "MachineIndependent/glslang_tab.cpp" +#line 6827 "MachineIndependent/glslang_tab.cpp" break; case 151: /* layout_qualifier_id: IDENTIFIER */ -#line 1350 "MachineIndependent/glslang.y" +#line 1351 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); } -#line 6829 "MachineIndependent/glslang_tab.cpp" +#line 6836 "MachineIndependent/glslang_tab.cpp" break; case 152: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ -#line 1354 "MachineIndependent/glslang.y" +#line 1355 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-2].lex).loc); parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); } -#line 6838 "MachineIndependent/glslang_tab.cpp" +#line 6845 "MachineIndependent/glslang_tab.cpp" break; case 153: /* layout_qualifier_id: SHARED */ -#line 1358 "MachineIndependent/glslang.y" +#line 1359 "MachineIndependent/glslang.y" { // because "shared" is both an identifier and a keyword (yyval.interm.type).init((yyvsp[0].lex).loc); TString strShared("shared"); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); } -#line 6848 "MachineIndependent/glslang_tab.cpp" +#line 6855 "MachineIndependent/glslang_tab.cpp" break; case 154: /* precise_qualifier: PRECISE */ -#line 1366 "MachineIndependent/glslang.y" +#line 1367 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.noContraction = true; } -#line 6859 "MachineIndependent/glslang_tab.cpp" +#line 6866 "MachineIndependent/glslang_tab.cpp" break; case 155: /* type_qualifier: single_type_qualifier */ -#line 1375 "MachineIndependent/glslang.y" +#line 1376 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6867 "MachineIndependent/glslang_tab.cpp" +#line 6874 "MachineIndependent/glslang_tab.cpp" break; case 156: /* type_qualifier: type_qualifier single_type_qualifier */ -#line 1378 "MachineIndependent/glslang.y" +#line 1379 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -6876,151 +6883,151 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (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 6880 "MachineIndependent/glslang_tab.cpp" +#line 6887 "MachineIndependent/glslang_tab.cpp" break; case 157: /* single_type_qualifier: storage_qualifier */ -#line 1389 "MachineIndependent/glslang.y" +#line 1390 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6888 "MachineIndependent/glslang_tab.cpp" +#line 6895 "MachineIndependent/glslang_tab.cpp" break; case 158: /* single_type_qualifier: layout_qualifier */ -#line 1392 "MachineIndependent/glslang.y" +#line 1393 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6896 "MachineIndependent/glslang_tab.cpp" +#line 6903 "MachineIndependent/glslang_tab.cpp" break; case 159: /* single_type_qualifier: precision_qualifier */ -#line 1395 "MachineIndependent/glslang.y" +#line 1396 "MachineIndependent/glslang.y" { parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6905 "MachineIndependent/glslang_tab.cpp" +#line 6912 "MachineIndependent/glslang_tab.cpp" break; case 160: /* single_type_qualifier: interpolation_qualifier */ -#line 1399 "MachineIndependent/glslang.y" +#line 1400 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6914 "MachineIndependent/glslang_tab.cpp" +#line 6921 "MachineIndependent/glslang_tab.cpp" break; case 161: /* single_type_qualifier: invariant_qualifier */ -#line 1403 "MachineIndependent/glslang.y" +#line 1404 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6923 "MachineIndependent/glslang_tab.cpp" +#line 6930 "MachineIndependent/glslang_tab.cpp" break; case 162: /* single_type_qualifier: precise_qualifier */ -#line 1407 "MachineIndependent/glslang.y" +#line 1408 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6932 "MachineIndependent/glslang_tab.cpp" +#line 6939 "MachineIndependent/glslang_tab.cpp" break; case 163: /* single_type_qualifier: non_uniform_qualifier */ -#line 1411 "MachineIndependent/glslang.y" +#line 1412 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6940 "MachineIndependent/glslang_tab.cpp" +#line 6947 "MachineIndependent/glslang_tab.cpp" break; case 164: /* single_type_qualifier: spirv_storage_class_qualifier */ -#line 1414 "MachineIndependent/glslang.y" +#line 1415 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].interm.type).loc, "spirv_storage_class"); parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6950 "MachineIndependent/glslang_tab.cpp" +#line 6957 "MachineIndependent/glslang_tab.cpp" break; case 165: /* single_type_qualifier: spirv_decorate_qualifier */ -#line 1419 "MachineIndependent/glslang.y" +#line 1420 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6959 "MachineIndependent/glslang_tab.cpp" +#line 6966 "MachineIndependent/glslang_tab.cpp" break; case 166: /* single_type_qualifier: SPIRV_BY_REFERENCE */ -#line 1423 "MachineIndependent/glslang.y" +#line 1424 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvByReference(); } -#line 6969 "MachineIndependent/glslang_tab.cpp" +#line 6976 "MachineIndependent/glslang_tab.cpp" break; case 167: /* single_type_qualifier: SPIRV_LITERAL */ -#line 1428 "MachineIndependent/glslang.y" +#line 1429 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvLiteral(); } -#line 6979 "MachineIndependent/glslang_tab.cpp" +#line 6986 "MachineIndependent/glslang_tab.cpp" break; case 168: /* storage_qualifier: CONST */ -#line 1436 "MachineIndependent/glslang.y" +#line 1437 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } -#line 6988 "MachineIndependent/glslang_tab.cpp" +#line 6995 "MachineIndependent/glslang_tab.cpp" break; case 169: /* storage_qualifier: INOUT */ -#line 1440 "MachineIndependent/glslang.y" +#line 1441 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqInOut; } -#line 6998 "MachineIndependent/glslang_tab.cpp" +#line 7005 "MachineIndependent/glslang_tab.cpp" break; case 170: /* storage_qualifier: IN */ -#line 1445 "MachineIndependent/glslang.y" +#line 1446 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "in"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqIn; } -#line 7009 "MachineIndependent/glslang_tab.cpp" +#line 7016 "MachineIndependent/glslang_tab.cpp" break; case 171: /* storage_qualifier: OUT */ -#line 1451 "MachineIndependent/glslang.y" +#line 1452 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "out"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqOut; } -#line 7020 "MachineIndependent/glslang_tab.cpp" +#line 7027 "MachineIndependent/glslang_tab.cpp" break; case 172: /* storage_qualifier: CENTROID */ -#line 1457 "MachineIndependent/glslang.y" +#line 1458 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -7028,31 +7035,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 7032 "MachineIndependent/glslang_tab.cpp" +#line 7039 "MachineIndependent/glslang_tab.cpp" break; case 173: /* storage_qualifier: UNIFORM */ -#line 1464 "MachineIndependent/glslang.y" +#line 1465 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqUniform; } -#line 7042 "MachineIndependent/glslang_tab.cpp" +#line 7049 "MachineIndependent/glslang_tab.cpp" break; case 174: /* storage_qualifier: TILEIMAGEEXT */ -#line 1469 "MachineIndependent/glslang.y" +#line 1470 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "tileImageEXT"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqTileImageEXT; } -#line 7052 "MachineIndependent/glslang_tab.cpp" +#line 7059 "MachineIndependent/glslang_tab.cpp" break; case 175: /* storage_qualifier: SHARED */ -#line 1474 "MachineIndependent/glslang.y" +#line 1475 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); @@ -7061,21 +7068,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 7065 "MachineIndependent/glslang_tab.cpp" +#line 7072 "MachineIndependent/glslang_tab.cpp" break; case 176: /* storage_qualifier: BUFFER */ -#line 1482 "MachineIndependent/glslang.y" +#line 1483 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqBuffer; } -#line 7075 "MachineIndependent/glslang_tab.cpp" +#line 7082 "MachineIndependent/glslang_tab.cpp" break; case 177: /* storage_qualifier: ATTRIBUTE */ -#line 1487 "MachineIndependent/glslang.y" +#line 1488 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -7088,11 +7095,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7092 "MachineIndependent/glslang_tab.cpp" +#line 7099 "MachineIndependent/glslang_tab.cpp" break; case 178: /* storage_qualifier: VARYING */ -#line 1499 "MachineIndependent/glslang.y" +#line 1500 "MachineIndependent/glslang.y" { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -7107,32 +7114,32 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7111 "MachineIndependent/glslang_tab.cpp" +#line 7118 "MachineIndependent/glslang_tab.cpp" break; case 179: /* storage_qualifier: PATCH */ -#line 1513 "MachineIndependent/glslang.y" +#line 1514 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.patch = true; } -#line 7122 "MachineIndependent/glslang_tab.cpp" +#line 7129 "MachineIndependent/glslang_tab.cpp" break; case 180: /* storage_qualifier: SAMPLE */ -#line 1519 "MachineIndependent/glslang.y" +#line 1520 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.sample = true; } -#line 7132 "MachineIndependent/glslang_tab.cpp" +#line 7139 "MachineIndependent/glslang_tab.cpp" break; case 181: /* storage_qualifier: HITATTRNV */ -#line 1524 "MachineIndependent/glslang.y" +#line 1525 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7141,11 +7148,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7145 "MachineIndependent/glslang_tab.cpp" +#line 7152 "MachineIndependent/glslang_tab.cpp" break; case 182: /* storage_qualifier: HITOBJECTATTRNV */ -#line 1532 "MachineIndependent/glslang.y" +#line 1533 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask @@ -7154,11 +7161,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitObjectAttrNV; } -#line 7158 "MachineIndependent/glslang_tab.cpp" +#line 7165 "MachineIndependent/glslang_tab.cpp" break; case 183: /* storage_qualifier: HITATTREXT */ -#line 1540 "MachineIndependent/glslang.y" +#line 1541 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7167,11 +7174,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7171 "MachineIndependent/glslang_tab.cpp" +#line 7178 "MachineIndependent/glslang_tab.cpp" break; case 184: /* storage_qualifier: PAYLOADNV */ -#line 1548 "MachineIndependent/glslang.y" +#line 1549 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7180,11 +7187,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7184 "MachineIndependent/glslang_tab.cpp" +#line 7191 "MachineIndependent/glslang_tab.cpp" break; case 185: /* storage_qualifier: PAYLOADEXT */ -#line 1556 "MachineIndependent/glslang.y" +#line 1557 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7193,11 +7200,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7197 "MachineIndependent/glslang_tab.cpp" +#line 7204 "MachineIndependent/glslang_tab.cpp" break; case 186: /* storage_qualifier: PAYLOADINNV */ -#line 1564 "MachineIndependent/glslang.y" +#line 1565 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7206,11 +7213,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7210 "MachineIndependent/glslang_tab.cpp" +#line 7217 "MachineIndependent/glslang_tab.cpp" break; case 187: /* storage_qualifier: PAYLOADINEXT */ -#line 1572 "MachineIndependent/glslang.y" +#line 1573 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7219,11 +7226,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7223 "MachineIndependent/glslang_tab.cpp" +#line 7230 "MachineIndependent/glslang_tab.cpp" break; case 188: /* storage_qualifier: CALLDATANV */ -#line 1580 "MachineIndependent/glslang.y" +#line 1581 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7232,11 +7239,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7236 "MachineIndependent/glslang_tab.cpp" +#line 7243 "MachineIndependent/glslang_tab.cpp" break; case 189: /* storage_qualifier: CALLDATAEXT */ -#line 1588 "MachineIndependent/glslang.y" +#line 1589 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7245,11 +7252,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7249 "MachineIndependent/glslang_tab.cpp" +#line 7256 "MachineIndependent/glslang_tab.cpp" break; case 190: /* storage_qualifier: CALLDATAINNV */ -#line 1596 "MachineIndependent/glslang.y" +#line 1597 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV"); @@ -7257,11 +7264,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7261 "MachineIndependent/glslang_tab.cpp" +#line 7268 "MachineIndependent/glslang_tab.cpp" break; case 191: /* storage_qualifier: CALLDATAINEXT */ -#line 1603 "MachineIndependent/glslang.y" +#line 1604 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT"); @@ -7269,138 +7276,138 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7273 "MachineIndependent/glslang_tab.cpp" +#line 7280 "MachineIndependent/glslang_tab.cpp" break; case 192: /* storage_qualifier: COHERENT */ -#line 1610 "MachineIndependent/glslang.y" +#line 1611 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 7282 "MachineIndependent/glslang_tab.cpp" +#line 7289 "MachineIndependent/glslang_tab.cpp" break; case 193: /* storage_qualifier: DEVICECOHERENT */ -#line 1614 "MachineIndependent/glslang.y" +#line 1615 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); (yyval.interm.type).qualifier.devicecoherent = true; } -#line 7292 "MachineIndependent/glslang_tab.cpp" +#line 7299 "MachineIndependent/glslang_tab.cpp" break; case 194: /* storage_qualifier: QUEUEFAMILYCOHERENT */ -#line 1619 "MachineIndependent/glslang.y" +#line 1620 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); (yyval.interm.type).qualifier.queuefamilycoherent = true; } -#line 7302 "MachineIndependent/glslang_tab.cpp" +#line 7309 "MachineIndependent/glslang_tab.cpp" break; case 195: /* storage_qualifier: WORKGROUPCOHERENT */ -#line 1624 "MachineIndependent/glslang.y" +#line 1625 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); (yyval.interm.type).qualifier.workgroupcoherent = true; } -#line 7312 "MachineIndependent/glslang_tab.cpp" +#line 7319 "MachineIndependent/glslang_tab.cpp" break; case 196: /* storage_qualifier: SUBGROUPCOHERENT */ -#line 1629 "MachineIndependent/glslang.y" +#line 1630 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); (yyval.interm.type).qualifier.subgroupcoherent = true; } -#line 7322 "MachineIndependent/glslang_tab.cpp" +#line 7329 "MachineIndependent/glslang_tab.cpp" break; case 197: /* storage_qualifier: NONPRIVATE */ -#line 1634 "MachineIndependent/glslang.y" +#line 1635 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); (yyval.interm.type).qualifier.nonprivate = true; } -#line 7332 "MachineIndependent/glslang_tab.cpp" +#line 7339 "MachineIndependent/glslang_tab.cpp" break; case 198: /* storage_qualifier: SHADERCALLCOHERENT */ -#line 1639 "MachineIndependent/glslang.y" +#line 1640 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent"); (yyval.interm.type).qualifier.shadercallcoherent = true; } -#line 7342 "MachineIndependent/glslang_tab.cpp" +#line 7349 "MachineIndependent/glslang_tab.cpp" break; case 199: /* storage_qualifier: VOLATILE */ -#line 1644 "MachineIndependent/glslang.y" +#line 1645 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 7351 "MachineIndependent/glslang_tab.cpp" +#line 7358 "MachineIndependent/glslang_tab.cpp" break; case 200: /* storage_qualifier: RESTRICT */ -#line 1648 "MachineIndependent/glslang.y" +#line 1649 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 7360 "MachineIndependent/glslang_tab.cpp" +#line 7367 "MachineIndependent/glslang_tab.cpp" break; case 201: /* storage_qualifier: READONLY */ -#line 1652 "MachineIndependent/glslang.y" +#line 1653 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 7369 "MachineIndependent/glslang_tab.cpp" +#line 7376 "MachineIndependent/glslang_tab.cpp" break; case 202: /* storage_qualifier: WRITEONLY */ -#line 1656 "MachineIndependent/glslang.y" +#line 1657 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 7378 "MachineIndependent/glslang_tab.cpp" +#line 7385 "MachineIndependent/glslang_tab.cpp" break; case 203: /* storage_qualifier: SUBROUTINE */ -#line 1660 "MachineIndependent/glslang.y" +#line 1661 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[0].lex).loc); } -#line 7389 "MachineIndependent/glslang_tab.cpp" +#line 7396 "MachineIndependent/glslang_tab.cpp" break; case 204: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ -#line 1666 "MachineIndependent/glslang.y" +#line 1667 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[-3].lex).loc); } -#line 7400 "MachineIndependent/glslang_tab.cpp" +#line 7407 "MachineIndependent/glslang_tab.cpp" break; case 205: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ -#line 1672 "MachineIndependent/glslang.y" +#line 1673 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskPayloadSharedEXT"); @@ -7408,73 +7415,73 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqtaskPayloadSharedEXT; } -#line 7412 "MachineIndependent/glslang_tab.cpp" +#line 7419 "MachineIndependent/glslang_tab.cpp" break; case 206: /* non_uniform_qualifier: NONUNIFORM */ -#line 1682 "MachineIndependent/glslang.y" +#line 1683 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 7421 "MachineIndependent/glslang_tab.cpp" +#line 7428 "MachineIndependent/glslang_tab.cpp" break; case 207: /* type_name_list: IDENTIFIER */ -#line 1689 "MachineIndependent/glslang.y" +#line 1690 "MachineIndependent/glslang.y" { // TODO } -#line 7429 "MachineIndependent/glslang_tab.cpp" +#line 7436 "MachineIndependent/glslang_tab.cpp" break; case 208: /* type_name_list: type_name_list COMMA IDENTIFIER */ -#line 1692 "MachineIndependent/glslang.y" +#line 1693 "MachineIndependent/glslang.y" { // TODO: 4.0 semantics: subroutines // 1) make sure each identifier is a type declared earlier with SUBROUTINE // 2) save all of the identifiers for future comparison with the declared function } -#line 7439 "MachineIndependent/glslang_tab.cpp" +#line 7446 "MachineIndependent/glslang_tab.cpp" break; case 209: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ -#line 1700 "MachineIndependent/glslang.y" +#line 1701 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters); - parseContext.coopMatTypeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type)); + parseContext.typeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type)); } -#line 7451 "MachineIndependent/glslang_tab.cpp" +#line 7458 "MachineIndependent/glslang_tab.cpp" break; case 210: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ -#line 1707 "MachineIndependent/glslang.y" +#line 1708 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; - parseContext.coopMatTypeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type)); + parseContext.typeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type)); } -#line 7464 "MachineIndependent/glslang_tab.cpp" +#line 7471 "MachineIndependent/glslang_tab.cpp" break; case 211: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ -#line 1718 "MachineIndependent/glslang.y" +#line 1719 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 7474 "MachineIndependent/glslang_tab.cpp" +#line 7481 "MachineIndependent/glslang_tab.cpp" break; case 212: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1723 "MachineIndependent/glslang.y" +#line 1724 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -7483,20 +7490,20 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7487 "MachineIndependent/glslang_tab.cpp" +#line 7494 "MachineIndependent/glslang_tab.cpp" break; case 213: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ -#line 1731 "MachineIndependent/glslang.y" +#line 1732 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 7496 "MachineIndependent/glslang_tab.cpp" +#line 7503 "MachineIndependent/glslang_tab.cpp" break; case 214: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1735 "MachineIndependent/glslang.y" +#line 1736 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); @@ -7504,46 +7511,46 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7508 "MachineIndependent/glslang_tab.cpp" +#line 7515 "MachineIndependent/glslang_tab.cpp" break; case 215: /* type_parameter_specifier_opt: type_parameter_specifier */ -#line 1745 "MachineIndependent/glslang.y" +#line 1746 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); } -#line 7516 "MachineIndependent/glslang_tab.cpp" +#line 7523 "MachineIndependent/glslang_tab.cpp" break; case 216: /* type_parameter_specifier_opt: %empty */ -#line 1748 "MachineIndependent/glslang.y" +#line 1749 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = 0; } -#line 7524 "MachineIndependent/glslang_tab.cpp" +#line 7531 "MachineIndependent/glslang_tab.cpp" break; case 217: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ -#line 1754 "MachineIndependent/glslang.y" +#line 1755 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); } -#line 7532 "MachineIndependent/glslang_tab.cpp" +#line 7539 "MachineIndependent/glslang_tab.cpp" break; case 218: /* type_parameter_specifier_list: type_specifier */ -#line 1760 "MachineIndependent/glslang.y" +#line 1761 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; (yyval.interm.typeParameters)->spirvType = (yyvsp[0].interm.type).spirvType; (yyval.interm.typeParameters)->basicType = (yyvsp[0].interm.type).basicType; } -#line 7543 "MachineIndependent/glslang_tab.cpp" +#line 7550 "MachineIndependent/glslang_tab.cpp" break; case 219: /* type_parameter_specifier_list: unary_expression */ -#line 1766 "MachineIndependent/glslang.y" +#line 1767 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; @@ -7552,11 +7559,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7556 "MachineIndependent/glslang_tab.cpp" +#line 7563 "MachineIndependent/glslang_tab.cpp" break; case 220: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ -#line 1774 "MachineIndependent/glslang.y" +#line 1775 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); @@ -7564,300 +7571,300 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7568 "MachineIndependent/glslang_tab.cpp" +#line 7575 "MachineIndependent/glslang_tab.cpp" break; case 221: /* type_specifier_nonarray: VOID */ -#line 1784 "MachineIndependent/glslang.y" +#line 1785 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 7577 "MachineIndependent/glslang_tab.cpp" +#line 7584 "MachineIndependent/glslang_tab.cpp" break; case 222: /* type_specifier_nonarray: FLOAT */ -#line 1788 "MachineIndependent/glslang.y" +#line 1789 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7586 "MachineIndependent/glslang_tab.cpp" +#line 7593 "MachineIndependent/glslang_tab.cpp" break; case 223: /* type_specifier_nonarray: INT */ -#line 1792 "MachineIndependent/glslang.y" +#line 1793 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 7595 "MachineIndependent/glslang_tab.cpp" +#line 7602 "MachineIndependent/glslang_tab.cpp" break; case 224: /* type_specifier_nonarray: UINT */ -#line 1796 "MachineIndependent/glslang.y" +#line 1797 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 7605 "MachineIndependent/glslang_tab.cpp" +#line 7612 "MachineIndependent/glslang_tab.cpp" break; case 225: /* type_specifier_nonarray: BOOL */ -#line 1801 "MachineIndependent/glslang.y" +#line 1802 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; } -#line 7614 "MachineIndependent/glslang_tab.cpp" +#line 7621 "MachineIndependent/glslang_tab.cpp" break; case 226: /* type_specifier_nonarray: VEC2 */ -#line 1805 "MachineIndependent/glslang.y" +#line 1806 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 7624 "MachineIndependent/glslang_tab.cpp" +#line 7631 "MachineIndependent/glslang_tab.cpp" break; case 227: /* type_specifier_nonarray: VEC3 */ -#line 1810 "MachineIndependent/glslang.y" +#line 1811 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 7634 "MachineIndependent/glslang_tab.cpp" +#line 7641 "MachineIndependent/glslang_tab.cpp" break; case 228: /* type_specifier_nonarray: VEC4 */ -#line 1815 "MachineIndependent/glslang.y" +#line 1816 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 7644 "MachineIndependent/glslang_tab.cpp" +#line 7651 "MachineIndependent/glslang_tab.cpp" break; case 229: /* type_specifier_nonarray: BVEC2 */ -#line 1820 "MachineIndependent/glslang.y" +#line 1821 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(2); } -#line 7654 "MachineIndependent/glslang_tab.cpp" +#line 7661 "MachineIndependent/glslang_tab.cpp" break; case 230: /* type_specifier_nonarray: BVEC3 */ -#line 1825 "MachineIndependent/glslang.y" +#line 1826 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(3); } -#line 7664 "MachineIndependent/glslang_tab.cpp" +#line 7671 "MachineIndependent/glslang_tab.cpp" break; case 231: /* type_specifier_nonarray: BVEC4 */ -#line 1830 "MachineIndependent/glslang.y" +#line 1831 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(4); } -#line 7674 "MachineIndependent/glslang_tab.cpp" +#line 7681 "MachineIndependent/glslang_tab.cpp" break; case 232: /* type_specifier_nonarray: IVEC2 */ -#line 1835 "MachineIndependent/glslang.y" +#line 1836 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 7684 "MachineIndependent/glslang_tab.cpp" +#line 7691 "MachineIndependent/glslang_tab.cpp" break; case 233: /* type_specifier_nonarray: IVEC3 */ -#line 1840 "MachineIndependent/glslang.y" +#line 1841 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 7694 "MachineIndependent/glslang_tab.cpp" +#line 7701 "MachineIndependent/glslang_tab.cpp" break; case 234: /* type_specifier_nonarray: IVEC4 */ -#line 1845 "MachineIndependent/glslang.y" +#line 1846 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 7704 "MachineIndependent/glslang_tab.cpp" +#line 7711 "MachineIndependent/glslang_tab.cpp" break; case 235: /* type_specifier_nonarray: UVEC2 */ -#line 1850 "MachineIndependent/glslang.y" +#line 1851 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 7715 "MachineIndependent/glslang_tab.cpp" +#line 7722 "MachineIndependent/glslang_tab.cpp" break; case 236: /* type_specifier_nonarray: UVEC3 */ -#line 1856 "MachineIndependent/glslang.y" +#line 1857 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 7726 "MachineIndependent/glslang_tab.cpp" +#line 7733 "MachineIndependent/glslang_tab.cpp" break; case 237: /* type_specifier_nonarray: UVEC4 */ -#line 1862 "MachineIndependent/glslang.y" +#line 1863 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 7737 "MachineIndependent/glslang_tab.cpp" +#line 7744 "MachineIndependent/glslang_tab.cpp" break; case 238: /* type_specifier_nonarray: MAT2 */ -#line 1868 "MachineIndependent/glslang.y" +#line 1869 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 7747 "MachineIndependent/glslang_tab.cpp" +#line 7754 "MachineIndependent/glslang_tab.cpp" break; case 239: /* type_specifier_nonarray: MAT3 */ -#line 1873 "MachineIndependent/glslang.y" +#line 1874 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7757 "MachineIndependent/glslang_tab.cpp" +#line 7764 "MachineIndependent/glslang_tab.cpp" break; case 240: /* type_specifier_nonarray: MAT4 */ -#line 1878 "MachineIndependent/glslang.y" +#line 1879 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7767 "MachineIndependent/glslang_tab.cpp" +#line 7774 "MachineIndependent/glslang_tab.cpp" break; case 241: /* type_specifier_nonarray: MAT2X2 */ -#line 1883 "MachineIndependent/glslang.y" +#line 1884 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 7777 "MachineIndependent/glslang_tab.cpp" +#line 7784 "MachineIndependent/glslang_tab.cpp" break; case 242: /* type_specifier_nonarray: MAT2X3 */ -#line 1888 "MachineIndependent/glslang.y" +#line 1889 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 7787 "MachineIndependent/glslang_tab.cpp" +#line 7794 "MachineIndependent/glslang_tab.cpp" break; case 243: /* type_specifier_nonarray: MAT2X4 */ -#line 1893 "MachineIndependent/glslang.y" +#line 1894 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 7797 "MachineIndependent/glslang_tab.cpp" +#line 7804 "MachineIndependent/glslang_tab.cpp" break; case 244: /* type_specifier_nonarray: MAT3X2 */ -#line 1898 "MachineIndependent/glslang.y" +#line 1899 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 7807 "MachineIndependent/glslang_tab.cpp" +#line 7814 "MachineIndependent/glslang_tab.cpp" break; case 245: /* type_specifier_nonarray: MAT3X3 */ -#line 1903 "MachineIndependent/glslang.y" +#line 1904 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7817 "MachineIndependent/glslang_tab.cpp" +#line 7824 "MachineIndependent/glslang_tab.cpp" break; case 246: /* type_specifier_nonarray: MAT3X4 */ -#line 1908 "MachineIndependent/glslang.y" +#line 1909 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 7827 "MachineIndependent/glslang_tab.cpp" +#line 7834 "MachineIndependent/glslang_tab.cpp" break; case 247: /* type_specifier_nonarray: MAT4X2 */ -#line 1913 "MachineIndependent/glslang.y" +#line 1914 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 7837 "MachineIndependent/glslang_tab.cpp" +#line 7844 "MachineIndependent/glslang_tab.cpp" break; case 248: /* type_specifier_nonarray: MAT4X3 */ -#line 1918 "MachineIndependent/glslang.y" +#line 1919 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 7847 "MachineIndependent/glslang_tab.cpp" +#line 7854 "MachineIndependent/glslang_tab.cpp" break; case 249: /* type_specifier_nonarray: MAT4X4 */ -#line 1923 "MachineIndependent/glslang.y" +#line 1924 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7857 "MachineIndependent/glslang_tab.cpp" +#line 7864 "MachineIndependent/glslang_tab.cpp" break; case 250: /* type_specifier_nonarray: DOUBLE */ -#line 1928 "MachineIndependent/glslang.y" +#line 1929 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7865,121 +7872,121 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 7869 "MachineIndependent/glslang_tab.cpp" +#line 7876 "MachineIndependent/glslang_tab.cpp" break; case 251: /* type_specifier_nonarray: FLOAT16_T */ -#line 1935 "MachineIndependent/glslang.y" +#line 1936 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; } -#line 7879 "MachineIndependent/glslang_tab.cpp" +#line 7886 "MachineIndependent/glslang_tab.cpp" break; case 252: /* type_specifier_nonarray: FLOAT32_T */ -#line 1940 "MachineIndependent/glslang.y" +#line 1941 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7889 "MachineIndependent/glslang_tab.cpp" +#line 7896 "MachineIndependent/glslang_tab.cpp" break; case 253: /* type_specifier_nonarray: FLOAT64_T */ -#line 1945 "MachineIndependent/glslang.y" +#line 1946 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 7899 "MachineIndependent/glslang_tab.cpp" +#line 7906 "MachineIndependent/glslang_tab.cpp" break; case 254: /* type_specifier_nonarray: INT8_T */ -#line 1950 "MachineIndependent/glslang.y" +#line 1951 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; } -#line 7909 "MachineIndependent/glslang_tab.cpp" +#line 7916 "MachineIndependent/glslang_tab.cpp" break; case 255: /* type_specifier_nonarray: UINT8_T */ -#line 1955 "MachineIndependent/glslang.y" +#line 1956 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; } -#line 7919 "MachineIndependent/glslang_tab.cpp" +#line 7926 "MachineIndependent/glslang_tab.cpp" break; case 256: /* type_specifier_nonarray: INT16_T */ -#line 1960 "MachineIndependent/glslang.y" +#line 1961 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; } -#line 7929 "MachineIndependent/glslang_tab.cpp" +#line 7936 "MachineIndependent/glslang_tab.cpp" break; case 257: /* type_specifier_nonarray: UINT16_T */ -#line 1965 "MachineIndependent/glslang.y" +#line 1966 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; } -#line 7939 "MachineIndependent/glslang_tab.cpp" +#line 7946 "MachineIndependent/glslang_tab.cpp" break; case 258: /* type_specifier_nonarray: INT32_T */ -#line 1970 "MachineIndependent/glslang.y" +#line 1971 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 7949 "MachineIndependent/glslang_tab.cpp" +#line 7956 "MachineIndependent/glslang_tab.cpp" break; case 259: /* type_specifier_nonarray: UINT32_T */ -#line 1975 "MachineIndependent/glslang.y" +#line 1976 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 7959 "MachineIndependent/glslang_tab.cpp" +#line 7966 "MachineIndependent/glslang_tab.cpp" break; case 260: /* type_specifier_nonarray: INT64_T */ -#line 1980 "MachineIndependent/glslang.y" +#line 1981 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; } -#line 7969 "MachineIndependent/glslang_tab.cpp" +#line 7976 "MachineIndependent/glslang_tab.cpp" break; case 261: /* type_specifier_nonarray: UINT64_T */ -#line 1985 "MachineIndependent/glslang.y" +#line 1986 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; } -#line 7979 "MachineIndependent/glslang_tab.cpp" +#line 7986 "MachineIndependent/glslang_tab.cpp" break; case 262: /* type_specifier_nonarray: DVEC2 */ -#line 1990 "MachineIndependent/glslang.y" +#line 1991 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7988,11 +7995,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 7992 "MachineIndependent/glslang_tab.cpp" +#line 7999 "MachineIndependent/glslang_tab.cpp" break; case 263: /* type_specifier_nonarray: DVEC3 */ -#line 1998 "MachineIndependent/glslang.y" +#line 1999 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8001,11 +8008,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8005 "MachineIndependent/glslang_tab.cpp" +#line 8012 "MachineIndependent/glslang_tab.cpp" break; case 264: /* type_specifier_nonarray: DVEC4 */ -#line 2006 "MachineIndependent/glslang.y" +#line 2007 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8014,374 +8021,374 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8018 "MachineIndependent/glslang_tab.cpp" +#line 8025 "MachineIndependent/glslang_tab.cpp" break; case 265: /* type_specifier_nonarray: F16VEC2 */ -#line 2014 "MachineIndependent/glslang.y" +#line 2015 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(2); } -#line 8029 "MachineIndependent/glslang_tab.cpp" +#line 8036 "MachineIndependent/glslang_tab.cpp" break; case 266: /* type_specifier_nonarray: F16VEC3 */ -#line 2020 "MachineIndependent/glslang.y" +#line 2021 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(3); } -#line 8040 "MachineIndependent/glslang_tab.cpp" +#line 8047 "MachineIndependent/glslang_tab.cpp" break; case 267: /* type_specifier_nonarray: F16VEC4 */ -#line 2026 "MachineIndependent/glslang.y" +#line 2027 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(4); } -#line 8051 "MachineIndependent/glslang_tab.cpp" +#line 8058 "MachineIndependent/glslang_tab.cpp" break; case 268: /* type_specifier_nonarray: F32VEC2 */ -#line 2032 "MachineIndependent/glslang.y" +#line 2033 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 8062 "MachineIndependent/glslang_tab.cpp" +#line 8069 "MachineIndependent/glslang_tab.cpp" break; case 269: /* type_specifier_nonarray: F32VEC3 */ -#line 2038 "MachineIndependent/glslang.y" +#line 2039 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 8073 "MachineIndependent/glslang_tab.cpp" +#line 8080 "MachineIndependent/glslang_tab.cpp" break; case 270: /* type_specifier_nonarray: F32VEC4 */ -#line 2044 "MachineIndependent/glslang.y" +#line 2045 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 8084 "MachineIndependent/glslang_tab.cpp" +#line 8091 "MachineIndependent/glslang_tab.cpp" break; case 271: /* type_specifier_nonarray: F64VEC2 */ -#line 2050 "MachineIndependent/glslang.y" +#line 2051 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 8095 "MachineIndependent/glslang_tab.cpp" +#line 8102 "MachineIndependent/glslang_tab.cpp" break; case 272: /* type_specifier_nonarray: F64VEC3 */ -#line 2056 "MachineIndependent/glslang.y" +#line 2057 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8106 "MachineIndependent/glslang_tab.cpp" +#line 8113 "MachineIndependent/glslang_tab.cpp" break; case 273: /* type_specifier_nonarray: F64VEC4 */ -#line 2062 "MachineIndependent/glslang.y" +#line 2063 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8117 "MachineIndependent/glslang_tab.cpp" +#line 8124 "MachineIndependent/glslang_tab.cpp" break; case 274: /* type_specifier_nonarray: I8VEC2 */ -#line 2068 "MachineIndependent/glslang.y" +#line 2069 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(2); } -#line 8128 "MachineIndependent/glslang_tab.cpp" +#line 8135 "MachineIndependent/glslang_tab.cpp" break; case 275: /* type_specifier_nonarray: I8VEC3 */ -#line 2074 "MachineIndependent/glslang.y" +#line 2075 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(3); } -#line 8139 "MachineIndependent/glslang_tab.cpp" +#line 8146 "MachineIndependent/glslang_tab.cpp" break; case 276: /* type_specifier_nonarray: I8VEC4 */ -#line 2080 "MachineIndependent/glslang.y" +#line 2081 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(4); } -#line 8150 "MachineIndependent/glslang_tab.cpp" +#line 8157 "MachineIndependent/glslang_tab.cpp" break; case 277: /* type_specifier_nonarray: I16VEC2 */ -#line 2086 "MachineIndependent/glslang.y" +#line 2087 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(2); } -#line 8161 "MachineIndependent/glslang_tab.cpp" +#line 8168 "MachineIndependent/glslang_tab.cpp" break; case 278: /* type_specifier_nonarray: I16VEC3 */ -#line 2092 "MachineIndependent/glslang.y" +#line 2093 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(3); } -#line 8172 "MachineIndependent/glslang_tab.cpp" +#line 8179 "MachineIndependent/glslang_tab.cpp" break; case 279: /* type_specifier_nonarray: I16VEC4 */ -#line 2098 "MachineIndependent/glslang.y" +#line 2099 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(4); } -#line 8183 "MachineIndependent/glslang_tab.cpp" +#line 8190 "MachineIndependent/glslang_tab.cpp" break; case 280: /* type_specifier_nonarray: I32VEC2 */ -#line 2104 "MachineIndependent/glslang.y" +#line 2105 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 8194 "MachineIndependent/glslang_tab.cpp" +#line 8201 "MachineIndependent/glslang_tab.cpp" break; case 281: /* type_specifier_nonarray: I32VEC3 */ -#line 2110 "MachineIndependent/glslang.y" +#line 2111 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 8205 "MachineIndependent/glslang_tab.cpp" +#line 8212 "MachineIndependent/glslang_tab.cpp" break; case 282: /* type_specifier_nonarray: I32VEC4 */ -#line 2116 "MachineIndependent/glslang.y" +#line 2117 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 8216 "MachineIndependent/glslang_tab.cpp" +#line 8223 "MachineIndependent/glslang_tab.cpp" break; case 283: /* type_specifier_nonarray: I64VEC2 */ -#line 2122 "MachineIndependent/glslang.y" +#line 2123 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(2); } -#line 8227 "MachineIndependent/glslang_tab.cpp" +#line 8234 "MachineIndependent/glslang_tab.cpp" break; case 284: /* type_specifier_nonarray: I64VEC3 */ -#line 2128 "MachineIndependent/glslang.y" +#line 2129 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(3); } -#line 8238 "MachineIndependent/glslang_tab.cpp" +#line 8245 "MachineIndependent/glslang_tab.cpp" break; case 285: /* type_specifier_nonarray: I64VEC4 */ -#line 2134 "MachineIndependent/glslang.y" +#line 2135 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(4); } -#line 8249 "MachineIndependent/glslang_tab.cpp" +#line 8256 "MachineIndependent/glslang_tab.cpp" break; case 286: /* type_specifier_nonarray: U8VEC2 */ -#line 2140 "MachineIndependent/glslang.y" +#line 2141 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(2); } -#line 8260 "MachineIndependent/glslang_tab.cpp" +#line 8267 "MachineIndependent/glslang_tab.cpp" break; case 287: /* type_specifier_nonarray: U8VEC3 */ -#line 2146 "MachineIndependent/glslang.y" +#line 2147 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(3); } -#line 8271 "MachineIndependent/glslang_tab.cpp" +#line 8278 "MachineIndependent/glslang_tab.cpp" break; case 288: /* type_specifier_nonarray: U8VEC4 */ -#line 2152 "MachineIndependent/glslang.y" +#line 2153 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(4); } -#line 8282 "MachineIndependent/glslang_tab.cpp" +#line 8289 "MachineIndependent/glslang_tab.cpp" break; case 289: /* type_specifier_nonarray: U16VEC2 */ -#line 2158 "MachineIndependent/glslang.y" +#line 2159 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(2); } -#line 8293 "MachineIndependent/glslang_tab.cpp" +#line 8300 "MachineIndependent/glslang_tab.cpp" break; case 290: /* type_specifier_nonarray: U16VEC3 */ -#line 2164 "MachineIndependent/glslang.y" +#line 2165 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(3); } -#line 8304 "MachineIndependent/glslang_tab.cpp" +#line 8311 "MachineIndependent/glslang_tab.cpp" break; case 291: /* type_specifier_nonarray: U16VEC4 */ -#line 2170 "MachineIndependent/glslang.y" +#line 2171 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(4); } -#line 8315 "MachineIndependent/glslang_tab.cpp" +#line 8322 "MachineIndependent/glslang_tab.cpp" break; case 292: /* type_specifier_nonarray: U32VEC2 */ -#line 2176 "MachineIndependent/glslang.y" +#line 2177 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 8326 "MachineIndependent/glslang_tab.cpp" +#line 8333 "MachineIndependent/glslang_tab.cpp" break; case 293: /* type_specifier_nonarray: U32VEC3 */ -#line 2182 "MachineIndependent/glslang.y" +#line 2183 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 8337 "MachineIndependent/glslang_tab.cpp" +#line 8344 "MachineIndependent/glslang_tab.cpp" break; case 294: /* type_specifier_nonarray: U32VEC4 */ -#line 2188 "MachineIndependent/glslang.y" +#line 2189 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 8348 "MachineIndependent/glslang_tab.cpp" +#line 8355 "MachineIndependent/glslang_tab.cpp" break; case 295: /* type_specifier_nonarray: U64VEC2 */ -#line 2194 "MachineIndependent/glslang.y" +#line 2195 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(2); } -#line 8359 "MachineIndependent/glslang_tab.cpp" +#line 8366 "MachineIndependent/glslang_tab.cpp" break; case 296: /* type_specifier_nonarray: U64VEC3 */ -#line 2200 "MachineIndependent/glslang.y" +#line 2201 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(3); } -#line 8370 "MachineIndependent/glslang_tab.cpp" +#line 8377 "MachineIndependent/glslang_tab.cpp" break; case 297: /* type_specifier_nonarray: U64VEC4 */ -#line 2206 "MachineIndependent/glslang.y" +#line 2207 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(4); } -#line 8381 "MachineIndependent/glslang_tab.cpp" +#line 8388 "MachineIndependent/glslang_tab.cpp" break; case 298: /* type_specifier_nonarray: DMAT2 */ -#line 2212 "MachineIndependent/glslang.y" +#line 2213 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8390,11 +8397,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8394 "MachineIndependent/glslang_tab.cpp" +#line 8401 "MachineIndependent/glslang_tab.cpp" break; case 299: /* type_specifier_nonarray: DMAT3 */ -#line 2220 "MachineIndependent/glslang.y" +#line 2221 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8403,11 +8410,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8407 "MachineIndependent/glslang_tab.cpp" +#line 8414 "MachineIndependent/glslang_tab.cpp" break; case 300: /* type_specifier_nonarray: DMAT4 */ -#line 2228 "MachineIndependent/glslang.y" +#line 2229 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8416,11 +8423,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8420 "MachineIndependent/glslang_tab.cpp" +#line 8427 "MachineIndependent/glslang_tab.cpp" break; case 301: /* type_specifier_nonarray: DMAT2X2 */ -#line 2236 "MachineIndependent/glslang.y" +#line 2237 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8429,11 +8436,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8433 "MachineIndependent/glslang_tab.cpp" +#line 8440 "MachineIndependent/glslang_tab.cpp" break; case 302: /* type_specifier_nonarray: DMAT2X3 */ -#line 2244 "MachineIndependent/glslang.y" +#line 2245 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8442,11 +8449,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 8446 "MachineIndependent/glslang_tab.cpp" +#line 8453 "MachineIndependent/glslang_tab.cpp" break; case 303: /* type_specifier_nonarray: DMAT2X4 */ -#line 2252 "MachineIndependent/glslang.y" +#line 2253 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8455,11 +8462,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 8459 "MachineIndependent/glslang_tab.cpp" +#line 8466 "MachineIndependent/glslang_tab.cpp" break; case 304: /* type_specifier_nonarray: DMAT3X2 */ -#line 2260 "MachineIndependent/glslang.y" +#line 2261 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8468,11 +8475,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 8472 "MachineIndependent/glslang_tab.cpp" +#line 8479 "MachineIndependent/glslang_tab.cpp" break; case 305: /* type_specifier_nonarray: DMAT3X3 */ -#line 2268 "MachineIndependent/glslang.y" +#line 2269 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8481,11 +8488,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8485 "MachineIndependent/glslang_tab.cpp" +#line 8492 "MachineIndependent/glslang_tab.cpp" break; case 306: /* type_specifier_nonarray: DMAT3X4 */ -#line 2276 "MachineIndependent/glslang.y" +#line 2277 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8494,11 +8501,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 8498 "MachineIndependent/glslang_tab.cpp" +#line 8505 "MachineIndependent/glslang_tab.cpp" break; case 307: /* type_specifier_nonarray: DMAT4X2 */ -#line 2284 "MachineIndependent/glslang.y" +#line 2285 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8507,11 +8514,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 8511 "MachineIndependent/glslang_tab.cpp" +#line 8518 "MachineIndependent/glslang_tab.cpp" break; case 308: /* type_specifier_nonarray: DMAT4X3 */ -#line 2292 "MachineIndependent/glslang.y" +#line 2293 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8520,11 +8527,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 8524 "MachineIndependent/glslang_tab.cpp" +#line 8531 "MachineIndependent/glslang_tab.cpp" break; case 309: /* type_specifier_nonarray: DMAT4X4 */ -#line 2300 "MachineIndependent/glslang.y" +#line 2301 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8533,2261 +8540,2261 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8537 "MachineIndependent/glslang_tab.cpp" +#line 8544 "MachineIndependent/glslang_tab.cpp" break; case 310: /* type_specifier_nonarray: F16MAT2 */ -#line 2308 "MachineIndependent/glslang.y" +#line 2309 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 8548 "MachineIndependent/glslang_tab.cpp" +#line 8555 "MachineIndependent/glslang_tab.cpp" break; case 311: /* type_specifier_nonarray: F16MAT3 */ -#line 2314 "MachineIndependent/glslang.y" +#line 2315 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 8559 "MachineIndependent/glslang_tab.cpp" +#line 8566 "MachineIndependent/glslang_tab.cpp" break; case 312: /* type_specifier_nonarray: F16MAT4 */ -#line 2320 "MachineIndependent/glslang.y" +#line 2321 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 8570 "MachineIndependent/glslang_tab.cpp" +#line 8577 "MachineIndependent/glslang_tab.cpp" break; case 313: /* type_specifier_nonarray: F16MAT2X2 */ -#line 2326 "MachineIndependent/glslang.y" +#line 2327 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 8581 "MachineIndependent/glslang_tab.cpp" +#line 8588 "MachineIndependent/glslang_tab.cpp" break; case 314: /* type_specifier_nonarray: F16MAT2X3 */ -#line 2332 "MachineIndependent/glslang.y" +#line 2333 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 3); } -#line 8592 "MachineIndependent/glslang_tab.cpp" +#line 8599 "MachineIndependent/glslang_tab.cpp" break; case 315: /* type_specifier_nonarray: F16MAT2X4 */ -#line 2338 "MachineIndependent/glslang.y" +#line 2339 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 4); } -#line 8603 "MachineIndependent/glslang_tab.cpp" +#line 8610 "MachineIndependent/glslang_tab.cpp" break; case 316: /* type_specifier_nonarray: F16MAT3X2 */ -#line 2344 "MachineIndependent/glslang.y" +#line 2345 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 2); } -#line 8614 "MachineIndependent/glslang_tab.cpp" +#line 8621 "MachineIndependent/glslang_tab.cpp" break; case 317: /* type_specifier_nonarray: F16MAT3X3 */ -#line 2350 "MachineIndependent/glslang.y" +#line 2351 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 8625 "MachineIndependent/glslang_tab.cpp" +#line 8632 "MachineIndependent/glslang_tab.cpp" break; case 318: /* type_specifier_nonarray: F16MAT3X4 */ -#line 2356 "MachineIndependent/glslang.y" +#line 2357 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 4); } -#line 8636 "MachineIndependent/glslang_tab.cpp" +#line 8643 "MachineIndependent/glslang_tab.cpp" break; case 319: /* type_specifier_nonarray: F16MAT4X2 */ -#line 2362 "MachineIndependent/glslang.y" +#line 2363 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 2); } -#line 8647 "MachineIndependent/glslang_tab.cpp" +#line 8654 "MachineIndependent/glslang_tab.cpp" break; case 320: /* type_specifier_nonarray: F16MAT4X3 */ -#line 2368 "MachineIndependent/glslang.y" +#line 2369 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 3); } -#line 8658 "MachineIndependent/glslang_tab.cpp" +#line 8665 "MachineIndependent/glslang_tab.cpp" break; case 321: /* type_specifier_nonarray: F16MAT4X4 */ -#line 2374 "MachineIndependent/glslang.y" +#line 2375 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 8669 "MachineIndependent/glslang_tab.cpp" +#line 8676 "MachineIndependent/glslang_tab.cpp" break; case 322: /* type_specifier_nonarray: F32MAT2 */ -#line 2380 "MachineIndependent/glslang.y" +#line 2381 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8680 "MachineIndependent/glslang_tab.cpp" +#line 8687 "MachineIndependent/glslang_tab.cpp" break; case 323: /* type_specifier_nonarray: F32MAT3 */ -#line 2386 "MachineIndependent/glslang.y" +#line 2387 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8691 "MachineIndependent/glslang_tab.cpp" +#line 8698 "MachineIndependent/glslang_tab.cpp" break; case 324: /* type_specifier_nonarray: F32MAT4 */ -#line 2392 "MachineIndependent/glslang.y" +#line 2393 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8702 "MachineIndependent/glslang_tab.cpp" +#line 8709 "MachineIndependent/glslang_tab.cpp" break; case 325: /* type_specifier_nonarray: F32MAT2X2 */ -#line 2398 "MachineIndependent/glslang.y" +#line 2399 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8713 "MachineIndependent/glslang_tab.cpp" +#line 8720 "MachineIndependent/glslang_tab.cpp" break; case 326: /* type_specifier_nonarray: F32MAT2X3 */ -#line 2404 "MachineIndependent/glslang.y" +#line 2405 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 8724 "MachineIndependent/glslang_tab.cpp" +#line 8731 "MachineIndependent/glslang_tab.cpp" break; case 327: /* type_specifier_nonarray: F32MAT2X4 */ -#line 2410 "MachineIndependent/glslang.y" +#line 2411 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 8735 "MachineIndependent/glslang_tab.cpp" +#line 8742 "MachineIndependent/glslang_tab.cpp" break; case 328: /* type_specifier_nonarray: F32MAT3X2 */ -#line 2416 "MachineIndependent/glslang.y" +#line 2417 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 8746 "MachineIndependent/glslang_tab.cpp" +#line 8753 "MachineIndependent/glslang_tab.cpp" break; case 329: /* type_specifier_nonarray: F32MAT3X3 */ -#line 2422 "MachineIndependent/glslang.y" +#line 2423 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8757 "MachineIndependent/glslang_tab.cpp" +#line 8764 "MachineIndependent/glslang_tab.cpp" break; case 330: /* type_specifier_nonarray: F32MAT3X4 */ -#line 2428 "MachineIndependent/glslang.y" +#line 2429 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 8768 "MachineIndependent/glslang_tab.cpp" +#line 8775 "MachineIndependent/glslang_tab.cpp" break; case 331: /* type_specifier_nonarray: F32MAT4X2 */ -#line 2434 "MachineIndependent/glslang.y" +#line 2435 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 8779 "MachineIndependent/glslang_tab.cpp" +#line 8786 "MachineIndependent/glslang_tab.cpp" break; case 332: /* type_specifier_nonarray: F32MAT4X3 */ -#line 2440 "MachineIndependent/glslang.y" +#line 2441 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 8790 "MachineIndependent/glslang_tab.cpp" +#line 8797 "MachineIndependent/glslang_tab.cpp" break; case 333: /* type_specifier_nonarray: F32MAT4X4 */ -#line 2446 "MachineIndependent/glslang.y" +#line 2447 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8801 "MachineIndependent/glslang_tab.cpp" +#line 8808 "MachineIndependent/glslang_tab.cpp" break; case 334: /* type_specifier_nonarray: F64MAT2 */ -#line 2452 "MachineIndependent/glslang.y" +#line 2453 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8812 "MachineIndependent/glslang_tab.cpp" +#line 8819 "MachineIndependent/glslang_tab.cpp" break; case 335: /* type_specifier_nonarray: F64MAT3 */ -#line 2458 "MachineIndependent/glslang.y" +#line 2459 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8823 "MachineIndependent/glslang_tab.cpp" +#line 8830 "MachineIndependent/glslang_tab.cpp" break; case 336: /* type_specifier_nonarray: F64MAT4 */ -#line 2464 "MachineIndependent/glslang.y" +#line 2465 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8834 "MachineIndependent/glslang_tab.cpp" +#line 8841 "MachineIndependent/glslang_tab.cpp" break; case 337: /* type_specifier_nonarray: F64MAT2X2 */ -#line 2470 "MachineIndependent/glslang.y" +#line 2471 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8845 "MachineIndependent/glslang_tab.cpp" +#line 8852 "MachineIndependent/glslang_tab.cpp" break; case 338: /* type_specifier_nonarray: F64MAT2X3 */ -#line 2476 "MachineIndependent/glslang.y" +#line 2477 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 8856 "MachineIndependent/glslang_tab.cpp" +#line 8863 "MachineIndependent/glslang_tab.cpp" break; case 339: /* type_specifier_nonarray: F64MAT2X4 */ -#line 2482 "MachineIndependent/glslang.y" +#line 2483 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 8867 "MachineIndependent/glslang_tab.cpp" +#line 8874 "MachineIndependent/glslang_tab.cpp" break; case 340: /* type_specifier_nonarray: F64MAT3X2 */ -#line 2488 "MachineIndependent/glslang.y" +#line 2489 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 8878 "MachineIndependent/glslang_tab.cpp" +#line 8885 "MachineIndependent/glslang_tab.cpp" break; case 341: /* type_specifier_nonarray: F64MAT3X3 */ -#line 2494 "MachineIndependent/glslang.y" +#line 2495 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8889 "MachineIndependent/glslang_tab.cpp" +#line 8896 "MachineIndependent/glslang_tab.cpp" break; case 342: /* type_specifier_nonarray: F64MAT3X4 */ -#line 2500 "MachineIndependent/glslang.y" +#line 2501 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 8900 "MachineIndependent/glslang_tab.cpp" +#line 8907 "MachineIndependent/glslang_tab.cpp" break; case 343: /* type_specifier_nonarray: F64MAT4X2 */ -#line 2506 "MachineIndependent/glslang.y" +#line 2507 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 8911 "MachineIndependent/glslang_tab.cpp" +#line 8918 "MachineIndependent/glslang_tab.cpp" break; case 344: /* type_specifier_nonarray: F64MAT4X3 */ -#line 2512 "MachineIndependent/glslang.y" +#line 2513 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 8922 "MachineIndependent/glslang_tab.cpp" +#line 8929 "MachineIndependent/glslang_tab.cpp" break; case 345: /* type_specifier_nonarray: F64MAT4X4 */ -#line 2518 "MachineIndependent/glslang.y" +#line 2519 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8933 "MachineIndependent/glslang_tab.cpp" +#line 8940 "MachineIndependent/glslang_tab.cpp" break; case 346: /* type_specifier_nonarray: ACCSTRUCTNV */ -#line 2524 "MachineIndependent/glslang.y" +#line 2525 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 8942 "MachineIndependent/glslang_tab.cpp" +#line 8949 "MachineIndependent/glslang_tab.cpp" break; case 347: /* type_specifier_nonarray: ACCSTRUCTEXT */ -#line 2528 "MachineIndependent/glslang.y" +#line 2529 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 8951 "MachineIndependent/glslang_tab.cpp" +#line 8958 "MachineIndependent/glslang_tab.cpp" break; case 348: /* type_specifier_nonarray: RAYQUERYEXT */ -#line 2532 "MachineIndependent/glslang.y" +#line 2533 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtRayQuery; } -#line 8960 "MachineIndependent/glslang_tab.cpp" +#line 8967 "MachineIndependent/glslang_tab.cpp" break; case 349: /* type_specifier_nonarray: ATOMIC_UINT */ -#line 2536 "MachineIndependent/glslang.y" +#line 2537 "MachineIndependent/glslang.y" { parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAtomicUint; } -#line 8970 "MachineIndependent/glslang_tab.cpp" +#line 8977 "MachineIndependent/glslang_tab.cpp" break; case 350: /* type_specifier_nonarray: SAMPLER1D */ -#line 2541 "MachineIndependent/glslang.y" +#line 2542 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D); } -#line 8980 "MachineIndependent/glslang_tab.cpp" +#line 8987 "MachineIndependent/glslang_tab.cpp" break; case 351: /* type_specifier_nonarray: SAMPLER2D */ -#line 2546 "MachineIndependent/glslang.y" +#line 2547 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); } -#line 8990 "MachineIndependent/glslang_tab.cpp" +#line 8997 "MachineIndependent/glslang_tab.cpp" break; case 352: /* type_specifier_nonarray: SAMPLER3D */ -#line 2551 "MachineIndependent/glslang.y" +#line 2552 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd3D); } -#line 9000 "MachineIndependent/glslang_tab.cpp" +#line 9007 "MachineIndependent/glslang_tab.cpp" break; case 353: /* type_specifier_nonarray: SAMPLERCUBE */ -#line 2556 "MachineIndependent/glslang.y" +#line 2557 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube); } -#line 9010 "MachineIndependent/glslang_tab.cpp" +#line 9017 "MachineIndependent/glslang_tab.cpp" break; case 354: /* type_specifier_nonarray: SAMPLER2DSHADOW */ -#line 2561 "MachineIndependent/glslang.y" +#line 2562 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); } -#line 9020 "MachineIndependent/glslang_tab.cpp" +#line 9027 "MachineIndependent/glslang_tab.cpp" break; case 355: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ -#line 2566 "MachineIndependent/glslang.y" +#line 2567 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); } -#line 9030 "MachineIndependent/glslang_tab.cpp" +#line 9037 "MachineIndependent/glslang_tab.cpp" break; case 356: /* type_specifier_nonarray: SAMPLER2DARRAY */ -#line 2571 "MachineIndependent/glslang.y" +#line 2572 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); } -#line 9040 "MachineIndependent/glslang_tab.cpp" +#line 9047 "MachineIndependent/glslang_tab.cpp" break; case 357: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ -#line 2576 "MachineIndependent/glslang.y" +#line 2577 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); } -#line 9050 "MachineIndependent/glslang_tab.cpp" +#line 9057 "MachineIndependent/glslang_tab.cpp" break; case 358: /* type_specifier_nonarray: SAMPLER1DSHADOW */ -#line 2581 "MachineIndependent/glslang.y" +#line 2582 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); } -#line 9060 "MachineIndependent/glslang_tab.cpp" +#line 9067 "MachineIndependent/glslang_tab.cpp" break; case 359: /* type_specifier_nonarray: SAMPLER1DARRAY */ -#line 2586 "MachineIndependent/glslang.y" +#line 2587 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); } -#line 9070 "MachineIndependent/glslang_tab.cpp" +#line 9077 "MachineIndependent/glslang_tab.cpp" break; case 360: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ -#line 2591 "MachineIndependent/glslang.y" +#line 2592 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); } -#line 9080 "MachineIndependent/glslang_tab.cpp" +#line 9087 "MachineIndependent/glslang_tab.cpp" break; case 361: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ -#line 2596 "MachineIndependent/glslang.y" +#line 2597 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); } -#line 9090 "MachineIndependent/glslang_tab.cpp" +#line 9097 "MachineIndependent/glslang_tab.cpp" break; case 362: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ -#line 2601 "MachineIndependent/glslang.y" +#line 2602 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); } -#line 9100 "MachineIndependent/glslang_tab.cpp" +#line 9107 "MachineIndependent/glslang_tab.cpp" break; case 363: /* type_specifier_nonarray: F16SAMPLER1D */ -#line 2606 "MachineIndependent/glslang.y" +#line 2607 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); } -#line 9111 "MachineIndependent/glslang_tab.cpp" +#line 9118 "MachineIndependent/glslang_tab.cpp" break; case 364: /* type_specifier_nonarray: F16SAMPLER2D */ -#line 2612 "MachineIndependent/glslang.y" +#line 2613 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); } -#line 9122 "MachineIndependent/glslang_tab.cpp" +#line 9129 "MachineIndependent/glslang_tab.cpp" break; case 365: /* type_specifier_nonarray: F16SAMPLER3D */ -#line 2618 "MachineIndependent/glslang.y" +#line 2619 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); } -#line 9133 "MachineIndependent/glslang_tab.cpp" +#line 9140 "MachineIndependent/glslang_tab.cpp" break; case 366: /* type_specifier_nonarray: F16SAMPLERCUBE */ -#line 2624 "MachineIndependent/glslang.y" +#line 2625 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); } -#line 9144 "MachineIndependent/glslang_tab.cpp" +#line 9151 "MachineIndependent/glslang_tab.cpp" break; case 367: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ -#line 2630 "MachineIndependent/glslang.y" +#line 2631 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); } -#line 9155 "MachineIndependent/glslang_tab.cpp" +#line 9162 "MachineIndependent/glslang_tab.cpp" break; case 368: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ -#line 2636 "MachineIndependent/glslang.y" +#line 2637 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); } -#line 9166 "MachineIndependent/glslang_tab.cpp" +#line 9173 "MachineIndependent/glslang_tab.cpp" break; case 369: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ -#line 2642 "MachineIndependent/glslang.y" +#line 2643 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); } -#line 9177 "MachineIndependent/glslang_tab.cpp" +#line 9184 "MachineIndependent/glslang_tab.cpp" break; case 370: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ -#line 2648 "MachineIndependent/glslang.y" +#line 2649 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); } -#line 9188 "MachineIndependent/glslang_tab.cpp" +#line 9195 "MachineIndependent/glslang_tab.cpp" break; case 371: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ -#line 2654 "MachineIndependent/glslang.y" +#line 2655 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); } -#line 9199 "MachineIndependent/glslang_tab.cpp" +#line 9206 "MachineIndependent/glslang_tab.cpp" break; case 372: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ -#line 2660 "MachineIndependent/glslang.y" +#line 2661 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); } -#line 9210 "MachineIndependent/glslang_tab.cpp" +#line 9217 "MachineIndependent/glslang_tab.cpp" break; case 373: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ -#line 2666 "MachineIndependent/glslang.y" +#line 2667 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); } -#line 9221 "MachineIndependent/glslang_tab.cpp" +#line 9228 "MachineIndependent/glslang_tab.cpp" break; case 374: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ -#line 2672 "MachineIndependent/glslang.y" +#line 2673 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); } -#line 9232 "MachineIndependent/glslang_tab.cpp" +#line 9239 "MachineIndependent/glslang_tab.cpp" break; case 375: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ -#line 2678 "MachineIndependent/glslang.y" +#line 2679 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); } -#line 9243 "MachineIndependent/glslang_tab.cpp" +#line 9250 "MachineIndependent/glslang_tab.cpp" break; case 376: /* type_specifier_nonarray: ISAMPLER1D */ -#line 2684 "MachineIndependent/glslang.y" +#line 2685 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D); } -#line 9253 "MachineIndependent/glslang_tab.cpp" +#line 9260 "MachineIndependent/glslang_tab.cpp" break; case 377: /* type_specifier_nonarray: ISAMPLER2D */ -#line 2689 "MachineIndependent/glslang.y" +#line 2690 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D); } -#line 9263 "MachineIndependent/glslang_tab.cpp" +#line 9270 "MachineIndependent/glslang_tab.cpp" break; case 378: /* type_specifier_nonarray: ISAMPLER3D */ -#line 2694 "MachineIndependent/glslang.y" +#line 2695 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd3D); } -#line 9273 "MachineIndependent/glslang_tab.cpp" +#line 9280 "MachineIndependent/glslang_tab.cpp" break; case 379: /* type_specifier_nonarray: ISAMPLERCUBE */ -#line 2699 "MachineIndependent/glslang.y" +#line 2700 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube); } -#line 9283 "MachineIndependent/glslang_tab.cpp" +#line 9290 "MachineIndependent/glslang_tab.cpp" break; case 380: /* type_specifier_nonarray: ISAMPLER2DARRAY */ -#line 2704 "MachineIndependent/glslang.y" +#line 2705 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); } -#line 9293 "MachineIndependent/glslang_tab.cpp" +#line 9300 "MachineIndependent/glslang_tab.cpp" break; case 381: /* type_specifier_nonarray: USAMPLER2D */ -#line 2709 "MachineIndependent/glslang.y" +#line 2710 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D); } -#line 9303 "MachineIndependent/glslang_tab.cpp" +#line 9310 "MachineIndependent/glslang_tab.cpp" break; case 382: /* type_specifier_nonarray: USAMPLER3D */ -#line 2714 "MachineIndependent/glslang.y" +#line 2715 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd3D); } -#line 9313 "MachineIndependent/glslang_tab.cpp" +#line 9320 "MachineIndependent/glslang_tab.cpp" break; case 383: /* type_specifier_nonarray: USAMPLERCUBE */ -#line 2719 "MachineIndependent/glslang.y" +#line 2720 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube); } -#line 9323 "MachineIndependent/glslang_tab.cpp" +#line 9330 "MachineIndependent/glslang_tab.cpp" break; case 384: /* type_specifier_nonarray: ISAMPLER1DARRAY */ -#line 2724 "MachineIndependent/glslang.y" +#line 2725 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); } -#line 9333 "MachineIndependent/glslang_tab.cpp" +#line 9340 "MachineIndependent/glslang_tab.cpp" break; case 385: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ -#line 2729 "MachineIndependent/glslang.y" +#line 2730 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); } -#line 9343 "MachineIndependent/glslang_tab.cpp" +#line 9350 "MachineIndependent/glslang_tab.cpp" break; case 386: /* type_specifier_nonarray: USAMPLER1D */ -#line 2734 "MachineIndependent/glslang.y" +#line 2735 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D); } -#line 9353 "MachineIndependent/glslang_tab.cpp" +#line 9360 "MachineIndependent/glslang_tab.cpp" break; case 387: /* type_specifier_nonarray: USAMPLER1DARRAY */ -#line 2739 "MachineIndependent/glslang.y" +#line 2740 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); } -#line 9363 "MachineIndependent/glslang_tab.cpp" +#line 9370 "MachineIndependent/glslang_tab.cpp" break; case 388: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ -#line 2744 "MachineIndependent/glslang.y" +#line 2745 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); } -#line 9373 "MachineIndependent/glslang_tab.cpp" +#line 9380 "MachineIndependent/glslang_tab.cpp" break; case 389: /* type_specifier_nonarray: TEXTURECUBEARRAY */ -#line 2749 "MachineIndependent/glslang.y" +#line 2750 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); } -#line 9383 "MachineIndependent/glslang_tab.cpp" +#line 9390 "MachineIndependent/glslang_tab.cpp" break; case 390: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ -#line 2754 "MachineIndependent/glslang.y" +#line 2755 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); } -#line 9393 "MachineIndependent/glslang_tab.cpp" +#line 9400 "MachineIndependent/glslang_tab.cpp" break; case 391: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ -#line 2759 "MachineIndependent/glslang.y" +#line 2760 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); } -#line 9403 "MachineIndependent/glslang_tab.cpp" +#line 9410 "MachineIndependent/glslang_tab.cpp" break; case 392: /* type_specifier_nonarray: USAMPLER2DARRAY */ -#line 2764 "MachineIndependent/glslang.y" +#line 2765 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); } -#line 9413 "MachineIndependent/glslang_tab.cpp" +#line 9420 "MachineIndependent/glslang_tab.cpp" break; case 393: /* type_specifier_nonarray: TEXTURE2D */ -#line 2769 "MachineIndependent/glslang.y" +#line 2770 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); } -#line 9423 "MachineIndependent/glslang_tab.cpp" +#line 9430 "MachineIndependent/glslang_tab.cpp" break; case 394: /* type_specifier_nonarray: TEXTURE3D */ -#line 2774 "MachineIndependent/glslang.y" +#line 2775 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); } -#line 9433 "MachineIndependent/glslang_tab.cpp" +#line 9440 "MachineIndependent/glslang_tab.cpp" break; case 395: /* type_specifier_nonarray: TEXTURE2DARRAY */ -#line 2779 "MachineIndependent/glslang.y" +#line 2780 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); } -#line 9443 "MachineIndependent/glslang_tab.cpp" +#line 9450 "MachineIndependent/glslang_tab.cpp" break; case 396: /* type_specifier_nonarray: TEXTURECUBE */ -#line 2784 "MachineIndependent/glslang.y" +#line 2785 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); } -#line 9453 "MachineIndependent/glslang_tab.cpp" +#line 9460 "MachineIndependent/glslang_tab.cpp" break; case 397: /* type_specifier_nonarray: ITEXTURE2D */ -#line 2789 "MachineIndependent/glslang.y" +#line 2790 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); } -#line 9463 "MachineIndependent/glslang_tab.cpp" +#line 9470 "MachineIndependent/glslang_tab.cpp" break; case 398: /* type_specifier_nonarray: ITEXTURE3D */ -#line 2794 "MachineIndependent/glslang.y" +#line 2795 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); } -#line 9473 "MachineIndependent/glslang_tab.cpp" +#line 9480 "MachineIndependent/glslang_tab.cpp" break; case 399: /* type_specifier_nonarray: ITEXTURECUBE */ -#line 2799 "MachineIndependent/glslang.y" +#line 2800 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); } -#line 9483 "MachineIndependent/glslang_tab.cpp" +#line 9490 "MachineIndependent/glslang_tab.cpp" break; case 400: /* type_specifier_nonarray: ITEXTURE2DARRAY */ -#line 2804 "MachineIndependent/glslang.y" +#line 2805 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); } -#line 9493 "MachineIndependent/glslang_tab.cpp" +#line 9500 "MachineIndependent/glslang_tab.cpp" break; case 401: /* type_specifier_nonarray: UTEXTURE2D */ -#line 2809 "MachineIndependent/glslang.y" +#line 2810 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); } -#line 9503 "MachineIndependent/glslang_tab.cpp" +#line 9510 "MachineIndependent/glslang_tab.cpp" break; case 402: /* type_specifier_nonarray: UTEXTURE3D */ -#line 2814 "MachineIndependent/glslang.y" +#line 2815 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); } -#line 9513 "MachineIndependent/glslang_tab.cpp" +#line 9520 "MachineIndependent/glslang_tab.cpp" break; case 403: /* type_specifier_nonarray: UTEXTURECUBE */ -#line 2819 "MachineIndependent/glslang.y" +#line 2820 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); } -#line 9523 "MachineIndependent/glslang_tab.cpp" +#line 9530 "MachineIndependent/glslang_tab.cpp" break; case 404: /* type_specifier_nonarray: UTEXTURE2DARRAY */ -#line 2824 "MachineIndependent/glslang.y" +#line 2825 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); } -#line 9533 "MachineIndependent/glslang_tab.cpp" +#line 9540 "MachineIndependent/glslang_tab.cpp" break; case 405: /* type_specifier_nonarray: SAMPLER */ -#line 2829 "MachineIndependent/glslang.y" +#line 2830 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(false); } -#line 9543 "MachineIndependent/glslang_tab.cpp" +#line 9550 "MachineIndependent/glslang_tab.cpp" break; case 406: /* type_specifier_nonarray: SAMPLERSHADOW */ -#line 2834 "MachineIndependent/glslang.y" +#line 2835 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(true); } -#line 9553 "MachineIndependent/glslang_tab.cpp" +#line 9560 "MachineIndependent/glslang_tab.cpp" break; case 407: /* type_specifier_nonarray: SAMPLER2DRECT */ -#line 2839 "MachineIndependent/glslang.y" +#line 2840 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect); } -#line 9563 "MachineIndependent/glslang_tab.cpp" +#line 9570 "MachineIndependent/glslang_tab.cpp" break; case 408: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ -#line 2844 "MachineIndependent/glslang.y" +#line 2845 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); } -#line 9573 "MachineIndependent/glslang_tab.cpp" +#line 9580 "MachineIndependent/glslang_tab.cpp" break; case 409: /* type_specifier_nonarray: F16SAMPLER2DRECT */ -#line 2849 "MachineIndependent/glslang.y" +#line 2850 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); } -#line 9584 "MachineIndependent/glslang_tab.cpp" +#line 9591 "MachineIndependent/glslang_tab.cpp" break; case 410: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ -#line 2855 "MachineIndependent/glslang.y" +#line 2856 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); } -#line 9595 "MachineIndependent/glslang_tab.cpp" +#line 9602 "MachineIndependent/glslang_tab.cpp" break; case 411: /* type_specifier_nonarray: ISAMPLER2DRECT */ -#line 2861 "MachineIndependent/glslang.y" +#line 2862 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdRect); } -#line 9605 "MachineIndependent/glslang_tab.cpp" +#line 9612 "MachineIndependent/glslang_tab.cpp" break; case 412: /* type_specifier_nonarray: USAMPLER2DRECT */ -#line 2866 "MachineIndependent/glslang.y" +#line 2867 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdRect); } -#line 9615 "MachineIndependent/glslang_tab.cpp" +#line 9622 "MachineIndependent/glslang_tab.cpp" break; case 413: /* type_specifier_nonarray: SAMPLERBUFFER */ -#line 2871 "MachineIndependent/glslang.y" +#line 2872 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); } -#line 9625 "MachineIndependent/glslang_tab.cpp" +#line 9632 "MachineIndependent/glslang_tab.cpp" break; case 414: /* type_specifier_nonarray: F16SAMPLERBUFFER */ -#line 2876 "MachineIndependent/glslang.y" +#line 2877 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); } -#line 9636 "MachineIndependent/glslang_tab.cpp" +#line 9643 "MachineIndependent/glslang_tab.cpp" break; case 415: /* type_specifier_nonarray: ISAMPLERBUFFER */ -#line 2882 "MachineIndependent/glslang.y" +#line 2883 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); } -#line 9646 "MachineIndependent/glslang_tab.cpp" +#line 9653 "MachineIndependent/glslang_tab.cpp" break; case 416: /* type_specifier_nonarray: USAMPLERBUFFER */ -#line 2887 "MachineIndependent/glslang.y" +#line 2888 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); } -#line 9656 "MachineIndependent/glslang_tab.cpp" +#line 9663 "MachineIndependent/glslang_tab.cpp" break; case 417: /* type_specifier_nonarray: SAMPLER2DMS */ -#line 2892 "MachineIndependent/glslang.y" +#line 2893 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); } -#line 9666 "MachineIndependent/glslang_tab.cpp" +#line 9673 "MachineIndependent/glslang_tab.cpp" break; case 418: /* type_specifier_nonarray: F16SAMPLER2DMS */ -#line 2897 "MachineIndependent/glslang.y" +#line 2898 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); } -#line 9677 "MachineIndependent/glslang_tab.cpp" +#line 9684 "MachineIndependent/glslang_tab.cpp" break; case 419: /* type_specifier_nonarray: ISAMPLER2DMS */ -#line 2903 "MachineIndependent/glslang.y" +#line 2904 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 9687 "MachineIndependent/glslang_tab.cpp" +#line 9694 "MachineIndependent/glslang_tab.cpp" break; case 420: /* type_specifier_nonarray: USAMPLER2DMS */ -#line 2908 "MachineIndependent/glslang.y" +#line 2909 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 9697 "MachineIndependent/glslang_tab.cpp" +#line 9704 "MachineIndependent/glslang_tab.cpp" break; case 421: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ -#line 2913 "MachineIndependent/glslang.y" +#line 2914 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 9707 "MachineIndependent/glslang_tab.cpp" +#line 9714 "MachineIndependent/glslang_tab.cpp" break; case 422: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ -#line 2918 "MachineIndependent/glslang.y" +#line 2919 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); } -#line 9718 "MachineIndependent/glslang_tab.cpp" +#line 9725 "MachineIndependent/glslang_tab.cpp" break; case 423: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ -#line 2924 "MachineIndependent/glslang.y" +#line 2925 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); } -#line 9728 "MachineIndependent/glslang_tab.cpp" +#line 9735 "MachineIndependent/glslang_tab.cpp" break; case 424: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ -#line 2929 "MachineIndependent/glslang.y" +#line 2930 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); } -#line 9738 "MachineIndependent/glslang_tab.cpp" +#line 9745 "MachineIndependent/glslang_tab.cpp" break; case 425: /* type_specifier_nonarray: TEXTURE1D */ -#line 2934 "MachineIndependent/glslang.y" +#line 2935 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); } -#line 9748 "MachineIndependent/glslang_tab.cpp" +#line 9755 "MachineIndependent/glslang_tab.cpp" break; case 426: /* type_specifier_nonarray: F16TEXTURE1D */ -#line 2939 "MachineIndependent/glslang.y" +#line 2940 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); } -#line 9759 "MachineIndependent/glslang_tab.cpp" +#line 9766 "MachineIndependent/glslang_tab.cpp" break; case 427: /* type_specifier_nonarray: F16TEXTURE2D */ -#line 2945 "MachineIndependent/glslang.y" +#line 2946 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); } -#line 9770 "MachineIndependent/glslang_tab.cpp" +#line 9777 "MachineIndependent/glslang_tab.cpp" break; case 428: /* type_specifier_nonarray: F16TEXTURE3D */ -#line 2951 "MachineIndependent/glslang.y" +#line 2952 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); } -#line 9781 "MachineIndependent/glslang_tab.cpp" +#line 9788 "MachineIndependent/glslang_tab.cpp" break; case 429: /* type_specifier_nonarray: F16TEXTURECUBE */ -#line 2957 "MachineIndependent/glslang.y" +#line 2958 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); } -#line 9792 "MachineIndependent/glslang_tab.cpp" +#line 9799 "MachineIndependent/glslang_tab.cpp" break; case 430: /* type_specifier_nonarray: TEXTURE1DARRAY */ -#line 2963 "MachineIndependent/glslang.y" +#line 2964 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); } -#line 9802 "MachineIndependent/glslang_tab.cpp" +#line 9809 "MachineIndependent/glslang_tab.cpp" break; case 431: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ -#line 2968 "MachineIndependent/glslang.y" +#line 2969 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); } -#line 9813 "MachineIndependent/glslang_tab.cpp" +#line 9820 "MachineIndependent/glslang_tab.cpp" break; case 432: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ -#line 2974 "MachineIndependent/glslang.y" +#line 2975 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); } -#line 9824 "MachineIndependent/glslang_tab.cpp" +#line 9831 "MachineIndependent/glslang_tab.cpp" break; case 433: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ -#line 2980 "MachineIndependent/glslang.y" +#line 2981 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); } -#line 9835 "MachineIndependent/glslang_tab.cpp" +#line 9842 "MachineIndependent/glslang_tab.cpp" break; case 434: /* type_specifier_nonarray: ITEXTURE1D */ -#line 2986 "MachineIndependent/glslang.y" +#line 2987 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 9845 "MachineIndependent/glslang_tab.cpp" +#line 9852 "MachineIndependent/glslang_tab.cpp" break; case 435: /* type_specifier_nonarray: ITEXTURE1DARRAY */ -#line 2991 "MachineIndependent/glslang.y" +#line 2992 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 9855 "MachineIndependent/glslang_tab.cpp" +#line 9862 "MachineIndependent/glslang_tab.cpp" break; case 436: /* type_specifier_nonarray: UTEXTURE1D */ -#line 2996 "MachineIndependent/glslang.y" +#line 2997 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 9865 "MachineIndependent/glslang_tab.cpp" +#line 9872 "MachineIndependent/glslang_tab.cpp" break; case 437: /* type_specifier_nonarray: UTEXTURE1DARRAY */ -#line 3001 "MachineIndependent/glslang.y" +#line 3002 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); } -#line 9875 "MachineIndependent/glslang_tab.cpp" +#line 9882 "MachineIndependent/glslang_tab.cpp" break; case 438: /* type_specifier_nonarray: TEXTURE2DRECT */ -#line 3006 "MachineIndependent/glslang.y" +#line 3007 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); } -#line 9885 "MachineIndependent/glslang_tab.cpp" +#line 9892 "MachineIndependent/glslang_tab.cpp" break; case 439: /* type_specifier_nonarray: F16TEXTURE2DRECT */ -#line 3011 "MachineIndependent/glslang.y" +#line 3012 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); } -#line 9896 "MachineIndependent/glslang_tab.cpp" +#line 9903 "MachineIndependent/glslang_tab.cpp" break; case 440: /* type_specifier_nonarray: ITEXTURE2DRECT */ -#line 3017 "MachineIndependent/glslang.y" +#line 3018 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 9906 "MachineIndependent/glslang_tab.cpp" +#line 9913 "MachineIndependent/glslang_tab.cpp" break; case 441: /* type_specifier_nonarray: UTEXTURE2DRECT */ -#line 3022 "MachineIndependent/glslang.y" +#line 3023 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); } -#line 9916 "MachineIndependent/glslang_tab.cpp" +#line 9923 "MachineIndependent/glslang_tab.cpp" break; case 442: /* type_specifier_nonarray: TEXTUREBUFFER */ -#line 3027 "MachineIndependent/glslang.y" +#line 3028 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); } -#line 9926 "MachineIndependent/glslang_tab.cpp" +#line 9933 "MachineIndependent/glslang_tab.cpp" break; case 443: /* type_specifier_nonarray: F16TEXTUREBUFFER */ -#line 3032 "MachineIndependent/glslang.y" +#line 3033 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); } -#line 9937 "MachineIndependent/glslang_tab.cpp" +#line 9944 "MachineIndependent/glslang_tab.cpp" break; case 444: /* type_specifier_nonarray: ITEXTUREBUFFER */ -#line 3038 "MachineIndependent/glslang.y" +#line 3039 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 9947 "MachineIndependent/glslang_tab.cpp" +#line 9954 "MachineIndependent/glslang_tab.cpp" break; case 445: /* type_specifier_nonarray: UTEXTUREBUFFER */ -#line 3043 "MachineIndependent/glslang.y" +#line 3044 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); } -#line 9957 "MachineIndependent/glslang_tab.cpp" +#line 9964 "MachineIndependent/glslang_tab.cpp" break; case 446: /* type_specifier_nonarray: TEXTURE2DMS */ -#line 3048 "MachineIndependent/glslang.y" +#line 3049 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); } -#line 9967 "MachineIndependent/glslang_tab.cpp" +#line 9974 "MachineIndependent/glslang_tab.cpp" break; case 447: /* type_specifier_nonarray: F16TEXTURE2DMS */ -#line 3053 "MachineIndependent/glslang.y" +#line 3054 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); } -#line 9978 "MachineIndependent/glslang_tab.cpp" +#line 9985 "MachineIndependent/glslang_tab.cpp" break; case 448: /* type_specifier_nonarray: ITEXTURE2DMS */ -#line 3059 "MachineIndependent/glslang.y" +#line 3060 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); } -#line 9988 "MachineIndependent/glslang_tab.cpp" +#line 9995 "MachineIndependent/glslang_tab.cpp" break; case 449: /* type_specifier_nonarray: UTEXTURE2DMS */ -#line 3064 "MachineIndependent/glslang.y" +#line 3065 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); } -#line 9998 "MachineIndependent/glslang_tab.cpp" +#line 10005 "MachineIndependent/glslang_tab.cpp" break; case 450: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ -#line 3069 "MachineIndependent/glslang.y" +#line 3070 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); } -#line 10008 "MachineIndependent/glslang_tab.cpp" +#line 10015 "MachineIndependent/glslang_tab.cpp" break; case 451: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ -#line 3074 "MachineIndependent/glslang.y" +#line 3075 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); } -#line 10019 "MachineIndependent/glslang_tab.cpp" +#line 10026 "MachineIndependent/glslang_tab.cpp" break; case 452: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ -#line 3080 "MachineIndependent/glslang.y" +#line 3081 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); } -#line 10029 "MachineIndependent/glslang_tab.cpp" +#line 10036 "MachineIndependent/glslang_tab.cpp" break; case 453: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ -#line 3085 "MachineIndependent/glslang.y" +#line 3086 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); } -#line 10039 "MachineIndependent/glslang_tab.cpp" +#line 10046 "MachineIndependent/glslang_tab.cpp" break; case 454: /* type_specifier_nonarray: IMAGE1D */ -#line 3090 "MachineIndependent/glslang.y" +#line 3091 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 10049 "MachineIndependent/glslang_tab.cpp" +#line 10056 "MachineIndependent/glslang_tab.cpp" break; case 455: /* type_specifier_nonarray: F16IMAGE1D */ -#line 3095 "MachineIndependent/glslang.y" +#line 3096 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); } -#line 10060 "MachineIndependent/glslang_tab.cpp" +#line 10067 "MachineIndependent/glslang_tab.cpp" break; case 456: /* type_specifier_nonarray: IIMAGE1D */ -#line 3101 "MachineIndependent/glslang.y" +#line 3102 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); } -#line 10070 "MachineIndependent/glslang_tab.cpp" +#line 10077 "MachineIndependent/glslang_tab.cpp" break; case 457: /* type_specifier_nonarray: UIMAGE1D */ -#line 3106 "MachineIndependent/glslang.y" +#line 3107 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); } -#line 10080 "MachineIndependent/glslang_tab.cpp" +#line 10087 "MachineIndependent/glslang_tab.cpp" break; case 458: /* type_specifier_nonarray: IMAGE2D */ -#line 3111 "MachineIndependent/glslang.y" +#line 3112 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); } -#line 10090 "MachineIndependent/glslang_tab.cpp" +#line 10097 "MachineIndependent/glslang_tab.cpp" break; case 459: /* type_specifier_nonarray: F16IMAGE2D */ -#line 3116 "MachineIndependent/glslang.y" +#line 3117 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); } -#line 10101 "MachineIndependent/glslang_tab.cpp" +#line 10108 "MachineIndependent/glslang_tab.cpp" break; case 460: /* type_specifier_nonarray: IIMAGE2D */ -#line 3122 "MachineIndependent/glslang.y" +#line 3123 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); } -#line 10111 "MachineIndependent/glslang_tab.cpp" +#line 10118 "MachineIndependent/glslang_tab.cpp" break; case 461: /* type_specifier_nonarray: UIMAGE2D */ -#line 3127 "MachineIndependent/glslang.y" +#line 3128 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); } -#line 10121 "MachineIndependent/glslang_tab.cpp" +#line 10128 "MachineIndependent/glslang_tab.cpp" break; case 462: /* type_specifier_nonarray: IMAGE3D */ -#line 3132 "MachineIndependent/glslang.y" +#line 3133 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); } -#line 10131 "MachineIndependent/glslang_tab.cpp" +#line 10138 "MachineIndependent/glslang_tab.cpp" break; case 463: /* type_specifier_nonarray: F16IMAGE3D */ -#line 3137 "MachineIndependent/glslang.y" +#line 3138 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); } -#line 10142 "MachineIndependent/glslang_tab.cpp" +#line 10149 "MachineIndependent/glslang_tab.cpp" break; case 464: /* type_specifier_nonarray: IIMAGE3D */ -#line 3143 "MachineIndependent/glslang.y" +#line 3144 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); } -#line 10152 "MachineIndependent/glslang_tab.cpp" +#line 10159 "MachineIndependent/glslang_tab.cpp" break; case 465: /* type_specifier_nonarray: UIMAGE3D */ -#line 3148 "MachineIndependent/glslang.y" +#line 3149 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); } -#line 10162 "MachineIndependent/glslang_tab.cpp" +#line 10169 "MachineIndependent/glslang_tab.cpp" break; case 466: /* type_specifier_nonarray: IMAGE2DRECT */ -#line 3153 "MachineIndependent/glslang.y" +#line 3154 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); } -#line 10172 "MachineIndependent/glslang_tab.cpp" +#line 10179 "MachineIndependent/glslang_tab.cpp" break; case 467: /* type_specifier_nonarray: F16IMAGE2DRECT */ -#line 3158 "MachineIndependent/glslang.y" +#line 3159 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); } -#line 10183 "MachineIndependent/glslang_tab.cpp" +#line 10190 "MachineIndependent/glslang_tab.cpp" break; case 468: /* type_specifier_nonarray: IIMAGE2DRECT */ -#line 3164 "MachineIndependent/glslang.y" +#line 3165 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); } -#line 10193 "MachineIndependent/glslang_tab.cpp" +#line 10200 "MachineIndependent/glslang_tab.cpp" break; case 469: /* type_specifier_nonarray: UIMAGE2DRECT */ -#line 3169 "MachineIndependent/glslang.y" +#line 3170 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); } -#line 10203 "MachineIndependent/glslang_tab.cpp" +#line 10210 "MachineIndependent/glslang_tab.cpp" break; case 470: /* type_specifier_nonarray: IMAGECUBE */ -#line 3174 "MachineIndependent/glslang.y" +#line 3175 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); } -#line 10213 "MachineIndependent/glslang_tab.cpp" +#line 10220 "MachineIndependent/glslang_tab.cpp" break; case 471: /* type_specifier_nonarray: F16IMAGECUBE */ -#line 3179 "MachineIndependent/glslang.y" +#line 3180 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); } -#line 10224 "MachineIndependent/glslang_tab.cpp" +#line 10231 "MachineIndependent/glslang_tab.cpp" break; case 472: /* type_specifier_nonarray: IIMAGECUBE */ -#line 3185 "MachineIndependent/glslang.y" +#line 3186 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); } -#line 10234 "MachineIndependent/glslang_tab.cpp" +#line 10241 "MachineIndependent/glslang_tab.cpp" break; case 473: /* type_specifier_nonarray: UIMAGECUBE */ -#line 3190 "MachineIndependent/glslang.y" +#line 3191 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); } -#line 10244 "MachineIndependent/glslang_tab.cpp" +#line 10251 "MachineIndependent/glslang_tab.cpp" break; case 474: /* type_specifier_nonarray: IMAGEBUFFER */ -#line 3195 "MachineIndependent/glslang.y" +#line 3196 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); } -#line 10254 "MachineIndependent/glslang_tab.cpp" +#line 10261 "MachineIndependent/glslang_tab.cpp" break; case 475: /* type_specifier_nonarray: F16IMAGEBUFFER */ -#line 3200 "MachineIndependent/glslang.y" +#line 3201 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); } -#line 10265 "MachineIndependent/glslang_tab.cpp" +#line 10272 "MachineIndependent/glslang_tab.cpp" break; case 476: /* type_specifier_nonarray: IIMAGEBUFFER */ -#line 3206 "MachineIndependent/glslang.y" +#line 3207 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); } -#line 10275 "MachineIndependent/glslang_tab.cpp" +#line 10282 "MachineIndependent/glslang_tab.cpp" break; case 477: /* type_specifier_nonarray: UIMAGEBUFFER */ -#line 3211 "MachineIndependent/glslang.y" +#line 3212 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); } -#line 10285 "MachineIndependent/glslang_tab.cpp" +#line 10292 "MachineIndependent/glslang_tab.cpp" break; case 478: /* type_specifier_nonarray: IMAGE1DARRAY */ -#line 3216 "MachineIndependent/glslang.y" +#line 3217 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); } -#line 10295 "MachineIndependent/glslang_tab.cpp" +#line 10302 "MachineIndependent/glslang_tab.cpp" break; case 479: /* type_specifier_nonarray: F16IMAGE1DARRAY */ -#line 3221 "MachineIndependent/glslang.y" +#line 3222 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); } -#line 10306 "MachineIndependent/glslang_tab.cpp" +#line 10313 "MachineIndependent/glslang_tab.cpp" break; case 480: /* type_specifier_nonarray: IIMAGE1DARRAY */ -#line 3227 "MachineIndependent/glslang.y" +#line 3228 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); } -#line 10316 "MachineIndependent/glslang_tab.cpp" +#line 10323 "MachineIndependent/glslang_tab.cpp" break; case 481: /* type_specifier_nonarray: UIMAGE1DARRAY */ -#line 3232 "MachineIndependent/glslang.y" +#line 3233 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); } -#line 10326 "MachineIndependent/glslang_tab.cpp" +#line 10333 "MachineIndependent/glslang_tab.cpp" break; case 482: /* type_specifier_nonarray: IMAGE2DARRAY */ -#line 3237 "MachineIndependent/glslang.y" +#line 3238 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); } -#line 10336 "MachineIndependent/glslang_tab.cpp" +#line 10343 "MachineIndependent/glslang_tab.cpp" break; case 483: /* type_specifier_nonarray: F16IMAGE2DARRAY */ -#line 3242 "MachineIndependent/glslang.y" +#line 3243 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); } -#line 10347 "MachineIndependent/glslang_tab.cpp" +#line 10354 "MachineIndependent/glslang_tab.cpp" break; case 484: /* type_specifier_nonarray: IIMAGE2DARRAY */ -#line 3248 "MachineIndependent/glslang.y" +#line 3249 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); } -#line 10357 "MachineIndependent/glslang_tab.cpp" +#line 10364 "MachineIndependent/glslang_tab.cpp" break; case 485: /* type_specifier_nonarray: UIMAGE2DARRAY */ -#line 3253 "MachineIndependent/glslang.y" +#line 3254 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); } -#line 10367 "MachineIndependent/glslang_tab.cpp" +#line 10374 "MachineIndependent/glslang_tab.cpp" break; case 486: /* type_specifier_nonarray: IMAGECUBEARRAY */ -#line 3258 "MachineIndependent/glslang.y" +#line 3259 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); } -#line 10377 "MachineIndependent/glslang_tab.cpp" +#line 10384 "MachineIndependent/glslang_tab.cpp" break; case 487: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ -#line 3263 "MachineIndependent/glslang.y" +#line 3264 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); } -#line 10388 "MachineIndependent/glslang_tab.cpp" +#line 10395 "MachineIndependent/glslang_tab.cpp" break; case 488: /* type_specifier_nonarray: IIMAGECUBEARRAY */ -#line 3269 "MachineIndependent/glslang.y" +#line 3270 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); } -#line 10398 "MachineIndependent/glslang_tab.cpp" +#line 10405 "MachineIndependent/glslang_tab.cpp" break; case 489: /* type_specifier_nonarray: UIMAGECUBEARRAY */ -#line 3274 "MachineIndependent/glslang.y" +#line 3275 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); } -#line 10408 "MachineIndependent/glslang_tab.cpp" +#line 10415 "MachineIndependent/glslang_tab.cpp" break; case 490: /* type_specifier_nonarray: IMAGE2DMS */ -#line 3279 "MachineIndependent/glslang.y" +#line 3280 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); } -#line 10418 "MachineIndependent/glslang_tab.cpp" +#line 10425 "MachineIndependent/glslang_tab.cpp" break; case 491: /* type_specifier_nonarray: F16IMAGE2DMS */ -#line 3284 "MachineIndependent/glslang.y" +#line 3285 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); } -#line 10429 "MachineIndependent/glslang_tab.cpp" +#line 10436 "MachineIndependent/glslang_tab.cpp" break; case 492: /* type_specifier_nonarray: IIMAGE2DMS */ -#line 3290 "MachineIndependent/glslang.y" +#line 3291 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); } -#line 10439 "MachineIndependent/glslang_tab.cpp" +#line 10446 "MachineIndependent/glslang_tab.cpp" break; case 493: /* type_specifier_nonarray: UIMAGE2DMS */ -#line 3295 "MachineIndependent/glslang.y" +#line 3296 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); } -#line 10449 "MachineIndependent/glslang_tab.cpp" +#line 10456 "MachineIndependent/glslang_tab.cpp" break; case 494: /* type_specifier_nonarray: IMAGE2DMSARRAY */ -#line 3300 "MachineIndependent/glslang.y" +#line 3301 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); } -#line 10459 "MachineIndependent/glslang_tab.cpp" +#line 10466 "MachineIndependent/glslang_tab.cpp" break; case 495: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ -#line 3305 "MachineIndependent/glslang.y" +#line 3306 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); } -#line 10470 "MachineIndependent/glslang_tab.cpp" +#line 10477 "MachineIndependent/glslang_tab.cpp" break; case 496: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ -#line 3311 "MachineIndependent/glslang.y" +#line 3312 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); } -#line 10480 "MachineIndependent/glslang_tab.cpp" +#line 10487 "MachineIndependent/glslang_tab.cpp" break; case 497: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ -#line 3316 "MachineIndependent/glslang.y" +#line 3317 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); } -#line 10490 "MachineIndependent/glslang_tab.cpp" +#line 10497 "MachineIndependent/glslang_tab.cpp" break; case 498: /* type_specifier_nonarray: I64IMAGE1D */ -#line 3321 "MachineIndependent/glslang.y" +#line 3322 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D); } -#line 10500 "MachineIndependent/glslang_tab.cpp" +#line 10507 "MachineIndependent/glslang_tab.cpp" break; case 499: /* type_specifier_nonarray: U64IMAGE1D */ -#line 3326 "MachineIndependent/glslang.y" +#line 3327 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D); } -#line 10510 "MachineIndependent/glslang_tab.cpp" +#line 10517 "MachineIndependent/glslang_tab.cpp" break; case 500: /* type_specifier_nonarray: I64IMAGE2D */ -#line 3331 "MachineIndependent/glslang.y" +#line 3332 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D); } -#line 10520 "MachineIndependent/glslang_tab.cpp" +#line 10527 "MachineIndependent/glslang_tab.cpp" break; case 501: /* type_specifier_nonarray: U64IMAGE2D */ -#line 3336 "MachineIndependent/glslang.y" +#line 3337 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D); } -#line 10530 "MachineIndependent/glslang_tab.cpp" +#line 10537 "MachineIndependent/glslang_tab.cpp" break; case 502: /* type_specifier_nonarray: I64IMAGE3D */ -#line 3341 "MachineIndependent/glslang.y" +#line 3342 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D); } -#line 10540 "MachineIndependent/glslang_tab.cpp" +#line 10547 "MachineIndependent/glslang_tab.cpp" break; case 503: /* type_specifier_nonarray: U64IMAGE3D */ -#line 3346 "MachineIndependent/glslang.y" +#line 3347 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd3D); } -#line 10550 "MachineIndependent/glslang_tab.cpp" +#line 10557 "MachineIndependent/glslang_tab.cpp" break; case 504: /* type_specifier_nonarray: I64IMAGE2DRECT */ -#line 3351 "MachineIndependent/glslang.y" +#line 3352 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdRect); } -#line 10560 "MachineIndependent/glslang_tab.cpp" +#line 10567 "MachineIndependent/glslang_tab.cpp" break; case 505: /* type_specifier_nonarray: U64IMAGE2DRECT */ -#line 3356 "MachineIndependent/glslang.y" +#line 3357 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdRect); } -#line 10570 "MachineIndependent/glslang_tab.cpp" +#line 10577 "MachineIndependent/glslang_tab.cpp" break; case 506: /* type_specifier_nonarray: I64IMAGECUBE */ -#line 3361 "MachineIndependent/glslang.y" +#line 3362 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube); } -#line 10580 "MachineIndependent/glslang_tab.cpp" +#line 10587 "MachineIndependent/glslang_tab.cpp" break; case 507: /* type_specifier_nonarray: U64IMAGECUBE */ -#line 3366 "MachineIndependent/glslang.y" +#line 3367 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube); } -#line 10590 "MachineIndependent/glslang_tab.cpp" +#line 10597 "MachineIndependent/glslang_tab.cpp" break; case 508: /* type_specifier_nonarray: I64IMAGEBUFFER */ -#line 3371 "MachineIndependent/glslang.y" +#line 3372 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdBuffer); } -#line 10600 "MachineIndependent/glslang_tab.cpp" +#line 10607 "MachineIndependent/glslang_tab.cpp" break; case 509: /* type_specifier_nonarray: U64IMAGEBUFFER */ -#line 3376 "MachineIndependent/glslang.y" +#line 3377 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdBuffer); } -#line 10610 "MachineIndependent/glslang_tab.cpp" +#line 10617 "MachineIndependent/glslang_tab.cpp" break; case 510: /* type_specifier_nonarray: I64IMAGE1DARRAY */ -#line 3381 "MachineIndependent/glslang.y" +#line 3382 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D, true); } -#line 10620 "MachineIndependent/glslang_tab.cpp" +#line 10627 "MachineIndependent/glslang_tab.cpp" break; case 511: /* type_specifier_nonarray: U64IMAGE1DARRAY */ -#line 3386 "MachineIndependent/glslang.y" +#line 3387 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D, true); } -#line 10630 "MachineIndependent/glslang_tab.cpp" +#line 10637 "MachineIndependent/glslang_tab.cpp" break; case 512: /* type_specifier_nonarray: I64IMAGE2DARRAY */ -#line 3391 "MachineIndependent/glslang.y" +#line 3392 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true); } -#line 10640 "MachineIndependent/glslang_tab.cpp" +#line 10647 "MachineIndependent/glslang_tab.cpp" break; case 513: /* type_specifier_nonarray: U64IMAGE2DARRAY */ -#line 3396 "MachineIndependent/glslang.y" +#line 3397 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true); } -#line 10650 "MachineIndependent/glslang_tab.cpp" +#line 10657 "MachineIndependent/glslang_tab.cpp" break; case 514: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ -#line 3401 "MachineIndependent/glslang.y" +#line 3402 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube, true); } -#line 10660 "MachineIndependent/glslang_tab.cpp" +#line 10667 "MachineIndependent/glslang_tab.cpp" break; case 515: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ -#line 3406 "MachineIndependent/glslang.y" +#line 3407 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube, true); } -#line 10670 "MachineIndependent/glslang_tab.cpp" +#line 10677 "MachineIndependent/glslang_tab.cpp" break; case 516: /* type_specifier_nonarray: I64IMAGE2DMS */ -#line 3411 "MachineIndependent/glslang.y" +#line 3412 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, false, false, true); } -#line 10680 "MachineIndependent/glslang_tab.cpp" +#line 10687 "MachineIndependent/glslang_tab.cpp" break; case 517: /* type_specifier_nonarray: U64IMAGE2DMS */ -#line 3416 "MachineIndependent/glslang.y" +#line 3417 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, false, false, true); } -#line 10690 "MachineIndependent/glslang_tab.cpp" +#line 10697 "MachineIndependent/glslang_tab.cpp" break; case 518: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ -#line 3421 "MachineIndependent/glslang.y" +#line 3422 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true, false, true); } -#line 10700 "MachineIndependent/glslang_tab.cpp" +#line 10707 "MachineIndependent/glslang_tab.cpp" break; case 519: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ -#line 3426 "MachineIndependent/glslang.y" +#line 3427 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true, false, true); } -#line 10710 "MachineIndependent/glslang_tab.cpp" +#line 10717 "MachineIndependent/glslang_tab.cpp" break; case 520: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ -#line 3431 "MachineIndependent/glslang.y" +#line 3432 "MachineIndependent/glslang.y" { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.external = true; } -#line 10721 "MachineIndependent/glslang_tab.cpp" +#line 10728 "MachineIndependent/glslang_tab.cpp" break; case 521: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ -#line 3437 "MachineIndependent/glslang.y" +#line 3438 "MachineIndependent/glslang.y" { // GL_EXT_YUV_target (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.yuv = true; } -#line 10732 "MachineIndependent/glslang_tab.cpp" +#line 10739 "MachineIndependent/glslang_tab.cpp" break; case 522: /* type_specifier_nonarray: ATTACHMENTEXT */ -#line 3443 "MachineIndependent/glslang.y" +#line 3444 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtFloat); } -#line 10743 "MachineIndependent/glslang_tab.cpp" +#line 10750 "MachineIndependent/glslang_tab.cpp" break; case 523: /* type_specifier_nonarray: IATTACHMENTEXT */ -#line 3449 "MachineIndependent/glslang.y" +#line 3450 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtInt); } -#line 10754 "MachineIndependent/glslang_tab.cpp" +#line 10761 "MachineIndependent/glslang_tab.cpp" break; case 524: /* type_specifier_nonarray: UATTACHMENTEXT */ -#line 3455 "MachineIndependent/glslang.y" +#line 3456 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtUint); } -#line 10765 "MachineIndependent/glslang_tab.cpp" +#line 10772 "MachineIndependent/glslang_tab.cpp" break; case 525: /* type_specifier_nonarray: SUBPASSINPUT */ -#line 3461 "MachineIndependent/glslang.y" +#line 3462 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat); } -#line 10776 "MachineIndependent/glslang_tab.cpp" +#line 10783 "MachineIndependent/glslang_tab.cpp" break; case 526: /* type_specifier_nonarray: SUBPASSINPUTMS */ -#line 3467 "MachineIndependent/glslang.y" +#line 3468 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat, true); } -#line 10787 "MachineIndependent/glslang_tab.cpp" +#line 10794 "MachineIndependent/glslang_tab.cpp" break; case 527: /* type_specifier_nonarray: F16SUBPASSINPUT */ -#line 3473 "MachineIndependent/glslang.y" +#line 3474 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -10795,11 +10802,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16); } -#line 10799 "MachineIndependent/glslang_tab.cpp" +#line 10806 "MachineIndependent/glslang_tab.cpp" break; case 528: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ -#line 3480 "MachineIndependent/glslang.y" +#line 3481 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -10807,55 +10814,55 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); } -#line 10811 "MachineIndependent/glslang_tab.cpp" +#line 10818 "MachineIndependent/glslang_tab.cpp" break; case 529: /* type_specifier_nonarray: ISUBPASSINPUT */ -#line 3487 "MachineIndependent/glslang.y" +#line 3488 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt); } -#line 10822 "MachineIndependent/glslang_tab.cpp" +#line 10829 "MachineIndependent/glslang_tab.cpp" break; case 530: /* type_specifier_nonarray: ISUBPASSINPUTMS */ -#line 3493 "MachineIndependent/glslang.y" +#line 3494 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt, true); } -#line 10833 "MachineIndependent/glslang_tab.cpp" +#line 10840 "MachineIndependent/glslang_tab.cpp" break; case 531: /* type_specifier_nonarray: USUBPASSINPUT */ -#line 3499 "MachineIndependent/glslang.y" +#line 3500 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint); } -#line 10844 "MachineIndependent/glslang_tab.cpp" +#line 10851 "MachineIndependent/glslang_tab.cpp" break; case 532: /* type_specifier_nonarray: USUBPASSINPUTMS */ -#line 3505 "MachineIndependent/glslang.y" +#line 3506 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint, true); } -#line 10855 "MachineIndependent/glslang_tab.cpp" +#line 10862 "MachineIndependent/glslang_tab.cpp" break; case 533: /* type_specifier_nonarray: FCOOPMATNV */ -#line 3511 "MachineIndependent/glslang.y" +#line 3512 "MachineIndependent/glslang.y" { parseContext.fcoopmatCheckNV((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10863,11 +10870,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10867 "MachineIndependent/glslang_tab.cpp" +#line 10874 "MachineIndependent/glslang_tab.cpp" break; case 534: /* type_specifier_nonarray: ICOOPMATNV */ -#line 3518 "MachineIndependent/glslang.y" +#line 3519 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10875,11 +10882,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10879 "MachineIndependent/glslang_tab.cpp" +#line 10886 "MachineIndependent/glslang_tab.cpp" break; case 535: /* type_specifier_nonarray: UCOOPMATNV */ -#line 3525 "MachineIndependent/glslang.y" +#line 3526 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10887,11 +10894,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10891 "MachineIndependent/glslang_tab.cpp" +#line 10898 "MachineIndependent/glslang_tab.cpp" break; case 536: /* type_specifier_nonarray: COOPMAT */ -#line 3532 "MachineIndependent/glslang.y" +#line 3533 "MachineIndependent/glslang.y" { parseContext.coopmatCheck((yyvsp[0].lex).loc, "coopmat", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10899,68 +10906,79 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = false; (yyval.interm.type).coopmatKHR = true; } -#line 10903 "MachineIndependent/glslang_tab.cpp" +#line 10910 "MachineIndependent/glslang_tab.cpp" break; case 537: /* type_specifier_nonarray: TENSORLAYOUTNV */ -#line 3539 "MachineIndependent/glslang.y" +#line 3540 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorLayoutNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorLayoutNV; } -#line 10913 "MachineIndependent/glslang_tab.cpp" +#line 10920 "MachineIndependent/glslang_tab.cpp" break; case 538: /* type_specifier_nonarray: TENSORVIEWNV */ -#line 3544 "MachineIndependent/glslang.y" +#line 3545 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorViewNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorViewNV; } -#line 10923 "MachineIndependent/glslang_tab.cpp" +#line 10930 "MachineIndependent/glslang_tab.cpp" break; case 539: /* type_specifier_nonarray: FUNCTION */ -#line 3549 "MachineIndependent/glslang.y" +#line 3550 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).basicType = EbtFunction; } -#line 10932 "MachineIndependent/glslang_tab.cpp" +#line 10939 "MachineIndependent/glslang_tab.cpp" + break; + + case 540: /* type_specifier_nonarray: COOPVECNV */ +#line 3554 "MachineIndependent/glslang.y" + { + parseContext.coopvecCheck((yyvsp[0].lex).loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtCoopvecNV; + (yyval.interm.type).coopvecNV = true; + } +#line 10950 "MachineIndependent/glslang_tab.cpp" break; - case 540: /* type_specifier_nonarray: spirv_type_specifier */ -#line 3553 "MachineIndependent/glslang.y" + case 541: /* type_specifier_nonarray: spirv_type_specifier */ +#line 3560 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 10941 "MachineIndependent/glslang_tab.cpp" +#line 10959 "MachineIndependent/glslang_tab.cpp" break; - case 541: /* type_specifier_nonarray: HITOBJECTNV */ -#line 3557 "MachineIndependent/glslang.y" + case 542: /* type_specifier_nonarray: HITOBJECTNV */ +#line 3564 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtHitObjectNV; } -#line 10950 "MachineIndependent/glslang_tab.cpp" +#line 10968 "MachineIndependent/glslang_tab.cpp" break; - case 542: /* type_specifier_nonarray: struct_specifier */ -#line 3561 "MachineIndependent/glslang.y" + case 543: /* type_specifier_nonarray: struct_specifier */ +#line 3568 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); } -#line 10960 "MachineIndependent/glslang_tab.cpp" +#line 10978 "MachineIndependent/glslang_tab.cpp" break; - case 543: /* type_specifier_nonarray: TYPE_NAME */ -#line 3566 "MachineIndependent/glslang.y" + case 544: /* type_specifier_nonarray: TYPE_NAME */ +#line 3573 "MachineIndependent/glslang.y" { // // This is for user defined type names. The lexical phase looked up the @@ -10974,47 +10992,47 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 10978 "MachineIndependent/glslang_tab.cpp" +#line 10996 "MachineIndependent/glslang_tab.cpp" break; - case 544: /* precision_qualifier: HIGH_PRECISION */ -#line 3582 "MachineIndependent/glslang.y" + case 545: /* precision_qualifier: HIGH_PRECISION */ +#line 3589 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); } -#line 10988 "MachineIndependent/glslang_tab.cpp" +#line 11006 "MachineIndependent/glslang_tab.cpp" break; - case 545: /* precision_qualifier: MEDIUM_PRECISION */ -#line 3587 "MachineIndependent/glslang.y" + case 546: /* precision_qualifier: MEDIUM_PRECISION */ +#line 3594 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); } -#line 10998 "MachineIndependent/glslang_tab.cpp" +#line 11016 "MachineIndependent/glslang_tab.cpp" break; - case 546: /* precision_qualifier: LOW_PRECISION */ -#line 3592 "MachineIndependent/glslang.y" + case 547: /* precision_qualifier: LOW_PRECISION */ +#line 3599 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); } -#line 11008 "MachineIndependent/glslang_tab.cpp" +#line 11026 "MachineIndependent/glslang_tab.cpp" break; - case 547: /* $@3: %empty */ -#line 3600 "MachineIndependent/glslang.y" + case 548: /* $@3: %empty */ +#line 3607 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 11014 "MachineIndependent/glslang_tab.cpp" +#line 11032 "MachineIndependent/glslang_tab.cpp" break; - case 548: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ -#line 3600 "MachineIndependent/glslang.y" + case 549: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ +#line 3607 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); @@ -11032,17 +11050,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11036 "MachineIndependent/glslang_tab.cpp" +#line 11054 "MachineIndependent/glslang_tab.cpp" break; - case 549: /* $@4: %empty */ -#line 3617 "MachineIndependent/glslang.y" + case 550: /* $@4: %empty */ +#line 3624 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 11042 "MachineIndependent/glslang_tab.cpp" +#line 11060 "MachineIndependent/glslang_tab.cpp" break; - case 550: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ -#line 3617 "MachineIndependent/glslang.y" + case 551: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ +#line 3624 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -11050,19 +11068,19 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11054 "MachineIndependent/glslang_tab.cpp" +#line 11072 "MachineIndependent/glslang_tab.cpp" break; - case 551: /* struct_declaration_list: struct_declaration */ -#line 3627 "MachineIndependent/glslang.y" + case 552: /* struct_declaration_list: struct_declaration */ +#line 3634 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11062 "MachineIndependent/glslang_tab.cpp" +#line 11080 "MachineIndependent/glslang_tab.cpp" break; - case 552: /* struct_declaration_list: struct_declaration_list struct_declaration */ -#line 3630 "MachineIndependent/glslang.y" + case 553: /* struct_declaration_list: struct_declaration_list struct_declaration */ +#line 3637 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11073,11 +11091,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11077 "MachineIndependent/glslang_tab.cpp" +#line 11095 "MachineIndependent/glslang_tab.cpp" break; - case 553: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ -#line 3643 "MachineIndependent/glslang.y" + case 554: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ +#line 3650 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11089,7 +11107,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); - parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmat()); + parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmatOrvec()); for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { TType type((yyvsp[-2].interm.type)); @@ -11100,11 +11118,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11104 "MachineIndependent/glslang_tab.cpp" +#line 11122 "MachineIndependent/glslang_tab.cpp" break; - case 554: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ -#line 3665 "MachineIndependent/glslang.y" + case 555: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ +#line 3672 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11118,7 +11136,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.memberQualifierCheck((yyvsp[-3].interm.type)); parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true); - parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmat()); + parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmatOrvec()); for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { TType type((yyvsp[-2].interm.type)); @@ -11129,38 +11147,38 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11133 "MachineIndependent/glslang_tab.cpp" +#line 11151 "MachineIndependent/glslang_tab.cpp" break; - case 555: /* struct_declarator_list: struct_declarator */ -#line 3692 "MachineIndependent/glslang.y" + case 556: /* struct_declarator_list: struct_declarator */ +#line 3699 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11142 "MachineIndependent/glslang_tab.cpp" +#line 11160 "MachineIndependent/glslang_tab.cpp" break; - case 556: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ -#line 3696 "MachineIndependent/glslang.y" + case 557: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ +#line 3703 "MachineIndependent/glslang.y" { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11150 "MachineIndependent/glslang_tab.cpp" +#line 11168 "MachineIndependent/glslang_tab.cpp" break; - case 557: /* struct_declarator: IDENTIFIER */ -#line 3702 "MachineIndependent/glslang.y" + case 558: /* struct_declarator: IDENTIFIER */ +#line 3709 "MachineIndependent/glslang.y" { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); } -#line 11160 "MachineIndependent/glslang_tab.cpp" +#line 11178 "MachineIndependent/glslang_tab.cpp" break; - case 558: /* struct_declarator: IDENTIFIER array_specifier */ -#line 3707 "MachineIndependent/glslang.y" + case 559: /* struct_declarator: IDENTIFIER array_specifier */ +#line 3714 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -11169,168 +11187,168 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 11173 "MachineIndependent/glslang_tab.cpp" +#line 11191 "MachineIndependent/glslang_tab.cpp" break; - case 559: /* initializer: assignment_expression */ -#line 3718 "MachineIndependent/glslang.y" + case 560: /* initializer: assignment_expression */ +#line 3725 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11181 "MachineIndependent/glslang_tab.cpp" +#line 11199 "MachineIndependent/glslang_tab.cpp" break; - case 560: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ -#line 3721 "MachineIndependent/glslang.y" + case 561: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ +#line 3728 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); } -#line 11192 "MachineIndependent/glslang_tab.cpp" +#line 11210 "MachineIndependent/glslang_tab.cpp" break; - case 561: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ -#line 3727 "MachineIndependent/glslang.y" + case 562: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ +#line 3734 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 11203 "MachineIndependent/glslang_tab.cpp" +#line 11221 "MachineIndependent/glslang_tab.cpp" break; - case 562: /* initializer: LEFT_BRACE RIGHT_BRACE */ -#line 3733 "MachineIndependent/glslang.y" + case 563: /* initializer: LEFT_BRACE RIGHT_BRACE */ +#line 3740 "MachineIndependent/glslang.y" { const char* initFeature = "empty { } initializer"; parseContext.profileRequires((yyvsp[-1].lex).loc, EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); parseContext.profileRequires((yyvsp[-1].lex).loc, ~EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); (yyval.interm.intermTypedNode) = parseContext.intermediate.makeAggregate((yyvsp[-1].lex).loc); } -#line 11214 "MachineIndependent/glslang_tab.cpp" +#line 11232 "MachineIndependent/glslang_tab.cpp" break; - case 563: /* initializer_list: initializer */ -#line 3742 "MachineIndependent/glslang.y" + case 564: /* initializer_list: initializer */ +#line 3749 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); } -#line 11222 "MachineIndependent/glslang_tab.cpp" +#line 11240 "MachineIndependent/glslang_tab.cpp" break; - case 564: /* initializer_list: initializer_list COMMA initializer */ -#line 3745 "MachineIndependent/glslang.y" + case 565: /* initializer_list: initializer_list COMMA initializer */ +#line 3752 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); } -#line 11230 "MachineIndependent/glslang_tab.cpp" +#line 11248 "MachineIndependent/glslang_tab.cpp" break; - case 565: /* declaration_statement: declaration */ -#line 3751 "MachineIndependent/glslang.y" + case 566: /* declaration_statement: declaration */ +#line 3758 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11236 "MachineIndependent/glslang_tab.cpp" +#line 11254 "MachineIndependent/glslang_tab.cpp" break; - case 566: /* statement: compound_statement */ -#line 3755 "MachineIndependent/glslang.y" + case 567: /* statement: compound_statement */ +#line 3762 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11242 "MachineIndependent/glslang_tab.cpp" +#line 11260 "MachineIndependent/glslang_tab.cpp" break; - case 567: /* statement: simple_statement */ -#line 3756 "MachineIndependent/glslang.y" + case 568: /* statement: simple_statement */ +#line 3763 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11248 "MachineIndependent/glslang_tab.cpp" +#line 11266 "MachineIndependent/glslang_tab.cpp" break; - case 568: /* simple_statement: declaration_statement */ -#line 3762 "MachineIndependent/glslang.y" + case 569: /* simple_statement: declaration_statement */ +#line 3769 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11254 "MachineIndependent/glslang_tab.cpp" +#line 11272 "MachineIndependent/glslang_tab.cpp" break; - case 569: /* simple_statement: expression_statement */ -#line 3763 "MachineIndependent/glslang.y" + case 570: /* simple_statement: expression_statement */ +#line 3770 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11260 "MachineIndependent/glslang_tab.cpp" +#line 11278 "MachineIndependent/glslang_tab.cpp" break; - case 570: /* simple_statement: selection_statement */ -#line 3764 "MachineIndependent/glslang.y" + case 571: /* simple_statement: selection_statement */ +#line 3771 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11266 "MachineIndependent/glslang_tab.cpp" +#line 11284 "MachineIndependent/glslang_tab.cpp" break; - case 571: /* simple_statement: switch_statement */ -#line 3765 "MachineIndependent/glslang.y" + case 572: /* simple_statement: switch_statement */ +#line 3772 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11272 "MachineIndependent/glslang_tab.cpp" +#line 11290 "MachineIndependent/glslang_tab.cpp" break; - case 572: /* simple_statement: case_label */ -#line 3766 "MachineIndependent/glslang.y" + case 573: /* simple_statement: case_label */ +#line 3773 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11278 "MachineIndependent/glslang_tab.cpp" +#line 11296 "MachineIndependent/glslang_tab.cpp" break; - case 573: /* simple_statement: iteration_statement */ -#line 3767 "MachineIndependent/glslang.y" + case 574: /* simple_statement: iteration_statement */ +#line 3774 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11284 "MachineIndependent/glslang_tab.cpp" +#line 11302 "MachineIndependent/glslang_tab.cpp" break; - case 574: /* simple_statement: jump_statement */ -#line 3768 "MachineIndependent/glslang.y" + case 575: /* simple_statement: jump_statement */ +#line 3775 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11290 "MachineIndependent/glslang_tab.cpp" +#line 11308 "MachineIndependent/glslang_tab.cpp" break; - case 575: /* simple_statement: demote_statement */ -#line 3769 "MachineIndependent/glslang.y" + case 576: /* simple_statement: demote_statement */ +#line 3776 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11296 "MachineIndependent/glslang_tab.cpp" +#line 11314 "MachineIndependent/glslang_tab.cpp" break; - case 576: /* demote_statement: DEMOTE SEMICOLON */ -#line 3773 "MachineIndependent/glslang.y" + case 577: /* demote_statement: DEMOTE SEMICOLON */ +#line 3780 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote"); parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc); } -#line 11306 "MachineIndependent/glslang_tab.cpp" +#line 11324 "MachineIndependent/glslang_tab.cpp" break; - case 577: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ -#line 3781 "MachineIndependent/glslang.y" + case 578: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ +#line 3788 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11312 "MachineIndependent/glslang_tab.cpp" +#line 11330 "MachineIndependent/glslang_tab.cpp" break; - case 578: /* $@5: %empty */ -#line 3782 "MachineIndependent/glslang.y" + case 579: /* $@5: %empty */ +#line 3789 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 11321 "MachineIndependent/glslang_tab.cpp" +#line 11339 "MachineIndependent/glslang_tab.cpp" break; - case 579: /* $@6: %empty */ -#line 3786 "MachineIndependent/glslang.y" + case 580: /* $@6: %empty */ +#line 3793 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 11330 "MachineIndependent/glslang_tab.cpp" +#line 11348 "MachineIndependent/glslang_tab.cpp" break; - case 580: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ -#line 3790 "MachineIndependent/glslang.y" + case 581: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ +#line 3797 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) { (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(parseContext.intermediate.getDebugInfo() ? EOpScope : EOpSequence); @@ -11338,69 +11356,69 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 11342 "MachineIndependent/glslang_tab.cpp" +#line 11360 "MachineIndependent/glslang_tab.cpp" break; - case 581: /* statement_no_new_scope: compound_statement_no_new_scope */ -#line 3800 "MachineIndependent/glslang.y" + case 582: /* statement_no_new_scope: compound_statement_no_new_scope */ +#line 3807 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11348 "MachineIndependent/glslang_tab.cpp" +#line 11366 "MachineIndependent/glslang_tab.cpp" break; - case 582: /* statement_no_new_scope: simple_statement */ -#line 3801 "MachineIndependent/glslang.y" + case 583: /* statement_no_new_scope: simple_statement */ +#line 3808 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11354 "MachineIndependent/glslang_tab.cpp" +#line 11372 "MachineIndependent/glslang_tab.cpp" break; - case 583: /* $@7: %empty */ -#line 3805 "MachineIndependent/glslang.y" + case 584: /* $@7: %empty */ +#line 3812 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 11362 "MachineIndependent/glslang_tab.cpp" +#line 11380 "MachineIndependent/glslang_tab.cpp" break; - case 584: /* statement_scoped: $@7 compound_statement */ -#line 3808 "MachineIndependent/glslang.y" + case 585: /* statement_scoped: $@7 compound_statement */ +#line 3815 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11371 "MachineIndependent/glslang_tab.cpp" +#line 11389 "MachineIndependent/glslang_tab.cpp" break; - case 585: /* $@8: %empty */ -#line 3812 "MachineIndependent/glslang.y" + case 586: /* $@8: %empty */ +#line 3819 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11381 "MachineIndependent/glslang_tab.cpp" +#line 11399 "MachineIndependent/glslang_tab.cpp" break; - case 586: /* statement_scoped: $@8 simple_statement */ -#line 3817 "MachineIndependent/glslang.y" + case 587: /* statement_scoped: $@8 simple_statement */ +#line 3824 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11392 "MachineIndependent/glslang_tab.cpp" +#line 11410 "MachineIndependent/glslang_tab.cpp" break; - case 587: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ -#line 3826 "MachineIndependent/glslang.y" + case 588: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ +#line 3833 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11400 "MachineIndependent/glslang_tab.cpp" +#line 11418 "MachineIndependent/glslang_tab.cpp" break; - case 588: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ -#line 3829 "MachineIndependent/glslang.y" + case 589: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ +#line 3836 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) { (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -11408,11 +11426,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 11412 "MachineIndependent/glslang_tab.cpp" +#line 11430 "MachineIndependent/glslang_tab.cpp" break; - case 589: /* statement_list: statement */ -#line 3839 "MachineIndependent/glslang.y" + case 590: /* statement_list: statement */ +#line 3846 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -11421,11 +11439,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 11425 "MachineIndependent/glslang_tab.cpp" +#line 11443 "MachineIndependent/glslang_tab.cpp" break; - case 590: /* statement_list: statement_list statement */ -#line 3847 "MachineIndependent/glslang.y" + case 591: /* statement_list: statement_list statement */ +#line 3854 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -11434,77 +11452,77 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 11438 "MachineIndependent/glslang_tab.cpp" +#line 11456 "MachineIndependent/glslang_tab.cpp" break; - case 591: /* expression_statement: SEMICOLON */ -#line 3858 "MachineIndependent/glslang.y" + case 592: /* expression_statement: SEMICOLON */ +#line 3865 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11444 "MachineIndependent/glslang_tab.cpp" +#line 11462 "MachineIndependent/glslang_tab.cpp" break; - case 592: /* expression_statement: expression SEMICOLON */ -#line 3859 "MachineIndependent/glslang.y" + case 593: /* expression_statement: expression SEMICOLON */ +#line 3866 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 11450 "MachineIndependent/glslang_tab.cpp" +#line 11468 "MachineIndependent/glslang_tab.cpp" break; - case 593: /* selection_statement: selection_statement_nonattributed */ -#line 3863 "MachineIndependent/glslang.y" + case 594: /* selection_statement: selection_statement_nonattributed */ +#line 3870 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11458 "MachineIndependent/glslang_tab.cpp" +#line 11476 "MachineIndependent/glslang_tab.cpp" break; - case 594: /* selection_statement: attribute selection_statement_nonattributed */ -#line 3866 "MachineIndependent/glslang.y" + case 595: /* selection_statement: attribute selection_statement_nonattributed */ +#line 3873 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11468 "MachineIndependent/glslang_tab.cpp" +#line 11486 "MachineIndependent/glslang_tab.cpp" break; - case 595: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ -#line 3873 "MachineIndependent/glslang.y" + case 596: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ +#line 3880 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); } -#line 11477 "MachineIndependent/glslang_tab.cpp" +#line 11495 "MachineIndependent/glslang_tab.cpp" break; - case 596: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ -#line 3880 "MachineIndependent/glslang.y" + case 597: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ +#line 3887 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 11486 "MachineIndependent/glslang_tab.cpp" +#line 11504 "MachineIndependent/glslang_tab.cpp" break; - case 597: /* selection_rest_statement: statement_scoped */ -#line 3884 "MachineIndependent/glslang.y" + case 598: /* selection_rest_statement: statement_scoped */ +#line 3891 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 11495 "MachineIndependent/glslang_tab.cpp" +#line 11513 "MachineIndependent/glslang_tab.cpp" break; - case 598: /* condition: expression */ -#line 3892 "MachineIndependent/glslang.y" + case 599: /* condition: expression */ +#line 3899 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 11504 "MachineIndependent/glslang_tab.cpp" +#line 11522 "MachineIndependent/glslang_tab.cpp" break; - case 599: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 3896 "MachineIndependent/glslang.y" + case 600: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 3903 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -11515,29 +11533,29 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.intermTypedNode) = 0; } -#line 11519 "MachineIndependent/glslang_tab.cpp" +#line 11537 "MachineIndependent/glslang_tab.cpp" break; - case 600: /* switch_statement: switch_statement_nonattributed */ -#line 3909 "MachineIndependent/glslang.y" + case 601: /* switch_statement: switch_statement_nonattributed */ +#line 3916 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11527 "MachineIndependent/glslang_tab.cpp" +#line 11545 "MachineIndependent/glslang_tab.cpp" break; - case 601: /* switch_statement: attribute switch_statement_nonattributed */ -#line 3912 "MachineIndependent/glslang.y" + case 602: /* switch_statement: attribute switch_statement_nonattributed */ +#line 3919 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11537 "MachineIndependent/glslang_tab.cpp" +#line 11555 "MachineIndependent/glslang_tab.cpp" break; - case 602: /* $@9: %empty */ -#line 3919 "MachineIndependent/glslang.y" + case 603: /* $@9: %empty */ +#line 3926 "MachineIndependent/glslang.y" { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -11546,11 +11564,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 11550 "MachineIndependent/glslang_tab.cpp" +#line 11568 "MachineIndependent/glslang_tab.cpp" break; - case 603: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ -#line 3927 "MachineIndependent/glslang.y" + case 604: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ +#line 3934 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -11560,27 +11578,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11564 "MachineIndependent/glslang_tab.cpp" +#line 11582 "MachineIndependent/glslang_tab.cpp" break; - case 604: /* switch_statement_list: %empty */ -#line 3939 "MachineIndependent/glslang.y" + case 605: /* switch_statement_list: %empty */ +#line 3946 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11572 "MachineIndependent/glslang_tab.cpp" +#line 11590 "MachineIndependent/glslang_tab.cpp" break; - case 605: /* switch_statement_list: statement_list */ -#line 3942 "MachineIndependent/glslang.y" + case 606: /* switch_statement_list: statement_list */ +#line 3949 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11580 "MachineIndependent/glslang_tab.cpp" +#line 11598 "MachineIndependent/glslang_tab.cpp" break; - case 606: /* case_label: CASE expression COLON */ -#line 3948 "MachineIndependent/glslang.y" + case 607: /* case_label: CASE expression COLON */ +#line 3955 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11593,11 +11611,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 11597 "MachineIndependent/glslang_tab.cpp" +#line 11615 "MachineIndependent/glslang_tab.cpp" break; - case 607: /* case_label: DEFAULT COLON */ -#line 3960 "MachineIndependent/glslang.y" + case 608: /* case_label: DEFAULT COLON */ +#line 3967 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11607,30 +11625,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 11611 "MachineIndependent/glslang_tab.cpp" +#line 11629 "MachineIndependent/glslang_tab.cpp" break; - case 608: /* iteration_statement: iteration_statement_nonattributed */ -#line 3972 "MachineIndependent/glslang.y" + case 609: /* iteration_statement: iteration_statement_nonattributed */ +#line 3979 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11619 "MachineIndependent/glslang_tab.cpp" +#line 11637 "MachineIndependent/glslang_tab.cpp" break; - case 609: /* iteration_statement: attribute iteration_statement_nonattributed */ -#line 3975 "MachineIndependent/glslang.y" + case 610: /* iteration_statement: attribute iteration_statement_nonattributed */ +#line 3982 "MachineIndependent/glslang.y" { const char * extensions[2] = { E_GL_EXT_control_flow_attributes, E_GL_EXT_control_flow_attributes2 }; parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 2, extensions, "attribute"); parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11630 "MachineIndependent/glslang_tab.cpp" +#line 11648 "MachineIndependent/glslang_tab.cpp" break; - case 610: /* $@10: %empty */ -#line 3983 "MachineIndependent/glslang.y" + case 611: /* $@10: %empty */ +#line 3990 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -11639,11 +11657,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11643 "MachineIndependent/glslang_tab.cpp" +#line 11661 "MachineIndependent/glslang_tab.cpp" break; - case 611: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ -#line 3991 "MachineIndependent/glslang.y" + case 612: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ +#line 3998 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); @@ -11651,22 +11669,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11655 "MachineIndependent/glslang_tab.cpp" +#line 11673 "MachineIndependent/glslang_tab.cpp" break; - case 612: /* $@11: %empty */ -#line 3998 "MachineIndependent/glslang.y" + case 613: /* $@11: %empty */ +#line 4005 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11666 "MachineIndependent/glslang_tab.cpp" +#line 11684 "MachineIndependent/glslang_tab.cpp" break; - case 613: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ -#line 4004 "MachineIndependent/glslang.y" + case 614: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ +#line 4011 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -11679,22 +11697,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11683 "MachineIndependent/glslang_tab.cpp" +#line 11701 "MachineIndependent/glslang_tab.cpp" break; - case 614: /* $@12: %empty */ -#line 4016 "MachineIndependent/glslang.y" + case 615: /* $@12: %empty */ +#line 4023 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11694 "MachineIndependent/glslang_tab.cpp" +#line 11712 "MachineIndependent/glslang_tab.cpp" break; - case 615: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ -#line 4022 "MachineIndependent/glslang.y" + case 616: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ +#line 4029 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -11707,81 +11725,81 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11711 "MachineIndependent/glslang_tab.cpp" +#line 11729 "MachineIndependent/glslang_tab.cpp" break; - case 616: /* for_init_statement: expression_statement */ -#line 4037 "MachineIndependent/glslang.y" + case 617: /* for_init_statement: expression_statement */ +#line 4044 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11719 "MachineIndependent/glslang_tab.cpp" +#line 11737 "MachineIndependent/glslang_tab.cpp" break; - case 617: /* for_init_statement: declaration_statement */ -#line 4040 "MachineIndependent/glslang.y" + case 618: /* for_init_statement: declaration_statement */ +#line 4047 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11727 "MachineIndependent/glslang_tab.cpp" +#line 11745 "MachineIndependent/glslang_tab.cpp" break; - case 618: /* conditionopt: condition */ -#line 4046 "MachineIndependent/glslang.y" + case 619: /* conditionopt: condition */ +#line 4053 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11735 "MachineIndependent/glslang_tab.cpp" +#line 11753 "MachineIndependent/glslang_tab.cpp" break; - case 619: /* conditionopt: %empty */ -#line 4049 "MachineIndependent/glslang.y" + case 620: /* conditionopt: %empty */ +#line 4056 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = 0; } -#line 11743 "MachineIndependent/glslang_tab.cpp" +#line 11761 "MachineIndependent/glslang_tab.cpp" break; - case 620: /* for_rest_statement: conditionopt SEMICOLON */ -#line 4055 "MachineIndependent/glslang.y" + case 621: /* for_rest_statement: conditionopt SEMICOLON */ +#line 4062 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 11752 "MachineIndependent/glslang_tab.cpp" +#line 11770 "MachineIndependent/glslang_tab.cpp" break; - case 621: /* for_rest_statement: conditionopt SEMICOLON expression */ -#line 4059 "MachineIndependent/glslang.y" + case 622: /* for_rest_statement: conditionopt SEMICOLON expression */ +#line 4066 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 11761 "MachineIndependent/glslang_tab.cpp" +#line 11779 "MachineIndependent/glslang_tab.cpp" break; - case 622: /* jump_statement: CONTINUE SEMICOLON */ -#line 4066 "MachineIndependent/glslang.y" + case 623: /* jump_statement: CONTINUE SEMICOLON */ +#line 4073 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); } -#line 11771 "MachineIndependent/glslang_tab.cpp" +#line 11789 "MachineIndependent/glslang_tab.cpp" break; - case 623: /* jump_statement: BREAK SEMICOLON */ -#line 4071 "MachineIndependent/glslang.y" + case 624: /* jump_statement: BREAK SEMICOLON */ +#line 4078 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); } -#line 11781 "MachineIndependent/glslang_tab.cpp" +#line 11799 "MachineIndependent/glslang_tab.cpp" break; - case 624: /* jump_statement: RETURN SEMICOLON */ -#line 4076 "MachineIndependent/glslang.y" + case 625: /* jump_statement: RETURN SEMICOLON */ +#line 4083 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -11789,101 +11807,101 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 11793 "MachineIndependent/glslang_tab.cpp" +#line 11811 "MachineIndependent/glslang_tab.cpp" break; - case 625: /* jump_statement: RETURN expression SEMICOLON */ -#line 4083 "MachineIndependent/glslang.y" + case 626: /* jump_statement: RETURN expression SEMICOLON */ +#line 4090 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 11801 "MachineIndependent/glslang_tab.cpp" +#line 11819 "MachineIndependent/glslang_tab.cpp" break; - case 626: /* jump_statement: DISCARD SEMICOLON */ -#line 4086 "MachineIndependent/glslang.y" + case 627: /* jump_statement: DISCARD SEMICOLON */ +#line 4093 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 11810 "MachineIndependent/glslang_tab.cpp" +#line 11828 "MachineIndependent/glslang_tab.cpp" break; - case 627: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ -#line 4090 "MachineIndependent/glslang.y" + case 628: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ +#line 4097 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc); } -#line 11819 "MachineIndependent/glslang_tab.cpp" +#line 11837 "MachineIndependent/glslang_tab.cpp" break; - case 628: /* jump_statement: TERMINATE_RAY SEMICOLON */ -#line 4094 "MachineIndependent/glslang.y" + case 629: /* jump_statement: TERMINATE_RAY SEMICOLON */ +#line 4101 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc); } -#line 11828 "MachineIndependent/glslang_tab.cpp" +#line 11846 "MachineIndependent/glslang_tab.cpp" break; - case 629: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ -#line 4098 "MachineIndependent/glslang.y" + case 630: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ +#line 4105 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc); } -#line 11837 "MachineIndependent/glslang_tab.cpp" +#line 11855 "MachineIndependent/glslang_tab.cpp" break; - case 630: /* translation_unit: external_declaration */ -#line 4107 "MachineIndependent/glslang.y" + case 631: /* translation_unit: external_declaration */ +#line 4114 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 11846 "MachineIndependent/glslang_tab.cpp" +#line 11864 "MachineIndependent/glslang_tab.cpp" break; - case 631: /* translation_unit: translation_unit external_declaration */ -#line 4111 "MachineIndependent/glslang.y" + case 632: /* translation_unit: translation_unit external_declaration */ +#line 4118 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) != nullptr) { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } } -#line 11857 "MachineIndependent/glslang_tab.cpp" +#line 11875 "MachineIndependent/glslang_tab.cpp" break; - case 632: /* external_declaration: function_definition */ -#line 4120 "MachineIndependent/glslang.y" + case 633: /* external_declaration: function_definition */ +#line 4127 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11865 "MachineIndependent/glslang_tab.cpp" +#line 11883 "MachineIndependent/glslang_tab.cpp" break; - case 633: /* external_declaration: declaration */ -#line 4123 "MachineIndependent/glslang.y" + case 634: /* external_declaration: declaration */ +#line 4130 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11873 "MachineIndependent/glslang_tab.cpp" +#line 11891 "MachineIndependent/glslang_tab.cpp" break; - case 634: /* external_declaration: SEMICOLON */ -#line 4126 "MachineIndependent/glslang.y" + case 635: /* external_declaration: SEMICOLON */ +#line 4133 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); (yyval.interm.intermNode) = nullptr; } -#line 11883 "MachineIndependent/glslang_tab.cpp" +#line 11901 "MachineIndependent/glslang_tab.cpp" break; - case 635: /* $@13: %empty */ -#line 4134 "MachineIndependent/glslang.y" + case 636: /* $@13: %empty */ +#line 4141 "MachineIndependent/glslang.y" { (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); @@ -11896,11 +11914,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; } } -#line 11900 "MachineIndependent/glslang_tab.cpp" +#line 11918 "MachineIndependent/glslang_tab.cpp" break; - case 636: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ -#line 4146 "MachineIndependent/glslang.y" + case 637: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ +#line 4153 "MachineIndependent/glslang.y" { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -11928,228 +11946,228 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; } } -#line 11932 "MachineIndependent/glslang_tab.cpp" +#line 11950 "MachineIndependent/glslang_tab.cpp" break; - case 637: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ -#line 4176 "MachineIndependent/glslang.y" + case 638: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ +#line 4183 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); } -#line 11940 "MachineIndependent/glslang_tab.cpp" +#line 11958 "MachineIndependent/glslang_tab.cpp" break; - case 638: /* attribute_list: single_attribute */ -#line 4181 "MachineIndependent/glslang.y" + case 639: /* attribute_list: single_attribute */ +#line 4188 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 11948 "MachineIndependent/glslang_tab.cpp" +#line 11966 "MachineIndependent/glslang_tab.cpp" break; - case 639: /* attribute_list: attribute_list COMMA single_attribute */ -#line 4184 "MachineIndependent/glslang.y" + case 640: /* attribute_list: attribute_list COMMA single_attribute */ +#line 4191 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 11956 "MachineIndependent/glslang_tab.cpp" +#line 11974 "MachineIndependent/glslang_tab.cpp" break; - case 640: /* single_attribute: IDENTIFIER */ -#line 4189 "MachineIndependent/glslang.y" + case 641: /* single_attribute: IDENTIFIER */ +#line 4196 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 11964 "MachineIndependent/glslang_tab.cpp" +#line 11982 "MachineIndependent/glslang_tab.cpp" break; - case 641: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ -#line 4192 "MachineIndependent/glslang.y" + case 642: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ +#line 4199 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 11972 "MachineIndependent/glslang_tab.cpp" +#line 11990 "MachineIndependent/glslang_tab.cpp" break; - case 642: /* spirv_requirements_list: spirv_requirements_parameter */ -#line 4197 "MachineIndependent/glslang.y" + case 643: /* spirv_requirements_list: spirv_requirements_parameter */ +#line 4204 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq); } -#line 11980 "MachineIndependent/glslang_tab.cpp" +#line 11998 "MachineIndependent/glslang_tab.cpp" break; - case 643: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ -#line 4200 "MachineIndependent/glslang.y" + case 644: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ +#line 4207 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq)); } -#line 11988 "MachineIndependent/glslang_tab.cpp" +#line 12006 "MachineIndependent/glslang_tab.cpp" break; - case 644: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ -#line 4205 "MachineIndependent/glslang.y" + case 645: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ +#line 4212 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr); } -#line 11996 "MachineIndependent/glslang_tab.cpp" +#line 12014 "MachineIndependent/glslang_tab.cpp" break; - case 645: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ -#line 4208 "MachineIndependent/glslang.y" + case 646: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ +#line 4215 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12004 "MachineIndependent/glslang_tab.cpp" +#line 12022 "MachineIndependent/glslang_tab.cpp" break; - case 646: /* spirv_extension_list: STRING_LITERAL */ -#line 4213 "MachineIndependent/glslang.y" + case 647: /* spirv_extension_list: STRING_LITERAL */ +#line 4220 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12012 "MachineIndependent/glslang_tab.cpp" +#line 12030 "MachineIndependent/glslang_tab.cpp" break; - case 647: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ -#line 4216 "MachineIndependent/glslang.y" + case 648: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ +#line 4223 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12020 "MachineIndependent/glslang_tab.cpp" +#line 12038 "MachineIndependent/glslang_tab.cpp" break; - case 648: /* spirv_capability_list: INTCONSTANT */ -#line 4221 "MachineIndependent/glslang.y" + case 649: /* spirv_capability_list: INTCONSTANT */ +#line 4228 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12028 "MachineIndependent/glslang_tab.cpp" +#line 12046 "MachineIndependent/glslang_tab.cpp" break; - case 649: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ -#line 4224 "MachineIndependent/glslang.y" + case 650: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ +#line 4231 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12036 "MachineIndependent/glslang_tab.cpp" +#line 12054 "MachineIndependent/glslang_tab.cpp" break; - case 650: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4229 "MachineIndependent/glslang.y" + case 651: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4236 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12045 "MachineIndependent/glslang_tab.cpp" +#line 12063 "MachineIndependent/glslang_tab.cpp" break; - case 651: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4233 "MachineIndependent/glslang.y" + case 652: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4240 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12055 "MachineIndependent/glslang_tab.cpp" +#line 12073 "MachineIndependent/glslang_tab.cpp" break; - case 652: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4238 "MachineIndependent/glslang.y" + case 653: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4245 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12064 "MachineIndependent/glslang_tab.cpp" +#line 12082 "MachineIndependent/glslang_tab.cpp" break; - case 653: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4242 "MachineIndependent/glslang.y" + case 654: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4249 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12074 "MachineIndependent/glslang_tab.cpp" +#line 12092 "MachineIndependent/glslang_tab.cpp" break; - case 654: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4247 "MachineIndependent/glslang.y" + case 655: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4254 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12083 "MachineIndependent/glslang_tab.cpp" +#line 12101 "MachineIndependent/glslang_tab.cpp" break; - case 655: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4251 "MachineIndependent/glslang.y" + case 656: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4258 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12093 "MachineIndependent/glslang_tab.cpp" +#line 12111 "MachineIndependent/glslang_tab.cpp" break; - case 656: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ -#line 4258 "MachineIndependent/glslang.y" + case 657: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ +#line 4265 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12101 "MachineIndependent/glslang_tab.cpp" +#line 12119 "MachineIndependent/glslang_tab.cpp" break; - case 657: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ -#line 4261 "MachineIndependent/glslang.y" + case 658: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ +#line 4268 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12109 "MachineIndependent/glslang_tab.cpp" +#line 12127 "MachineIndependent/glslang_tab.cpp" break; - case 658: /* spirv_execution_mode_parameter: FLOATCONSTANT */ -#line 4266 "MachineIndependent/glslang.y" + case 659: /* spirv_execution_mode_parameter: FLOATCONSTANT */ +#line 4273 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12117 "MachineIndependent/glslang_tab.cpp" +#line 12135 "MachineIndependent/glslang_tab.cpp" break; - case 659: /* spirv_execution_mode_parameter: INTCONSTANT */ -#line 4269 "MachineIndependent/glslang.y" + case 660: /* spirv_execution_mode_parameter: INTCONSTANT */ +#line 4276 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12125 "MachineIndependent/glslang_tab.cpp" +#line 12143 "MachineIndependent/glslang_tab.cpp" break; - case 660: /* spirv_execution_mode_parameter: UINTCONSTANT */ -#line 4272 "MachineIndependent/glslang.y" + case 661: /* spirv_execution_mode_parameter: UINTCONSTANT */ +#line 4279 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12133 "MachineIndependent/glslang_tab.cpp" +#line 12151 "MachineIndependent/glslang_tab.cpp" break; - case 661: /* spirv_execution_mode_parameter: BOOLCONSTANT */ -#line 4275 "MachineIndependent/glslang.y" + case 662: /* spirv_execution_mode_parameter: BOOLCONSTANT */ +#line 4282 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12141 "MachineIndependent/glslang_tab.cpp" +#line 12159 "MachineIndependent/glslang_tab.cpp" break; - case 662: /* spirv_execution_mode_parameter: STRING_LITERAL */ -#line 4278 "MachineIndependent/glslang.y" + case 663: /* spirv_execution_mode_parameter: STRING_LITERAL */ +#line 4285 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 12149 "MachineIndependent/glslang_tab.cpp" +#line 12167 "MachineIndependent/glslang_tab.cpp" break; - case 663: /* spirv_execution_mode_id_parameter_list: constant_expression */ -#line 4283 "MachineIndependent/glslang.y" + case 664: /* spirv_execution_mode_id_parameter_list: constant_expression */ +#line 4290 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12159,11 +12177,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode)); } -#line 12163 "MachineIndependent/glslang_tab.cpp" +#line 12181 "MachineIndependent/glslang_tab.cpp" break; - case 664: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ -#line 4292 "MachineIndependent/glslang.y" + case 665: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ +#line 4299 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12173,351 +12191,351 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode)); } -#line 12177 "MachineIndependent/glslang_tab.cpp" +#line 12195 "MachineIndependent/glslang_tab.cpp" break; - case 665: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4303 "MachineIndependent/glslang.y" + case 666: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4310 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12187 "MachineIndependent/glslang_tab.cpp" +#line 12205 "MachineIndependent/glslang_tab.cpp" break; - case 666: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4308 "MachineIndependent/glslang.y" + case 667: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4315 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12198 "MachineIndependent/glslang_tab.cpp" +#line 12216 "MachineIndependent/glslang_tab.cpp" break; - case 667: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4316 "MachineIndependent/glslang.y" + case 668: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4323 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12207 "MachineIndependent/glslang_tab.cpp" +#line 12225 "MachineIndependent/glslang_tab.cpp" break; - case 668: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4320 "MachineIndependent/glslang.y" + case 669: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4327 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12217 "MachineIndependent/glslang_tab.cpp" +#line 12235 "MachineIndependent/glslang_tab.cpp" break; - case 669: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4325 "MachineIndependent/glslang.y" + case 670: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4332 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12226 "MachineIndependent/glslang_tab.cpp" +#line 12244 "MachineIndependent/glslang_tab.cpp" break; - case 670: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4329 "MachineIndependent/glslang.y" + case 671: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4336 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12236 "MachineIndependent/glslang_tab.cpp" +#line 12254 "MachineIndependent/glslang_tab.cpp" break; - case 671: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4334 "MachineIndependent/glslang.y" + case 672: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4341 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12245 "MachineIndependent/glslang_tab.cpp" +#line 12263 "MachineIndependent/glslang_tab.cpp" break; - case 672: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4338 "MachineIndependent/glslang.y" + case 673: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4345 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12255 "MachineIndependent/glslang_tab.cpp" +#line 12273 "MachineIndependent/glslang_tab.cpp" break; - case 673: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4343 "MachineIndependent/glslang.y" + case 674: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4350 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12264 "MachineIndependent/glslang_tab.cpp" +#line 12282 "MachineIndependent/glslang_tab.cpp" break; - case 674: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4347 "MachineIndependent/glslang.y" + case 675: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4354 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12274 "MachineIndependent/glslang_tab.cpp" +#line 12292 "MachineIndependent/glslang_tab.cpp" break; - case 675: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ -#line 4354 "MachineIndependent/glslang.y" + case 676: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ +#line 4361 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12282 "MachineIndependent/glslang_tab.cpp" +#line 12300 "MachineIndependent/glslang_tab.cpp" break; - case 676: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ -#line 4357 "MachineIndependent/glslang.y" + case 677: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ +#line 4364 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12290 "MachineIndependent/glslang_tab.cpp" +#line 12308 "MachineIndependent/glslang_tab.cpp" break; - case 677: /* spirv_decorate_parameter: FLOATCONSTANT */ -#line 4362 "MachineIndependent/glslang.y" + case 678: /* spirv_decorate_parameter: FLOATCONSTANT */ +#line 4369 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12298 "MachineIndependent/glslang_tab.cpp" +#line 12316 "MachineIndependent/glslang_tab.cpp" break; - case 678: /* spirv_decorate_parameter: INTCONSTANT */ -#line 4365 "MachineIndependent/glslang.y" + case 679: /* spirv_decorate_parameter: INTCONSTANT */ +#line 4372 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12306 "MachineIndependent/glslang_tab.cpp" +#line 12324 "MachineIndependent/glslang_tab.cpp" break; - case 679: /* spirv_decorate_parameter: UINTCONSTANT */ -#line 4368 "MachineIndependent/glslang.y" + case 680: /* spirv_decorate_parameter: UINTCONSTANT */ +#line 4375 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12314 "MachineIndependent/glslang_tab.cpp" +#line 12332 "MachineIndependent/glslang_tab.cpp" break; - case 680: /* spirv_decorate_parameter: BOOLCONSTANT */ -#line 4371 "MachineIndependent/glslang.y" + case 681: /* spirv_decorate_parameter: BOOLCONSTANT */ +#line 4378 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12322 "MachineIndependent/glslang_tab.cpp" +#line 12340 "MachineIndependent/glslang_tab.cpp" break; - case 681: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ -#line 4376 "MachineIndependent/glslang.y" + case 682: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ +#line 4383 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12330 "MachineIndependent/glslang_tab.cpp" +#line 12348 "MachineIndependent/glslang_tab.cpp" break; - case 682: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ -#line 4379 "MachineIndependent/glslang.y" + case 683: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ +#line 4386 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12338 "MachineIndependent/glslang_tab.cpp" +#line 12356 "MachineIndependent/glslang_tab.cpp" break; - case 683: /* spirv_decorate_id_parameter: variable_identifier */ -#line 4384 "MachineIndependent/glslang.y" + case 684: /* spirv_decorate_id_parameter: variable_identifier */ +#line 4391 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getAsConstantUnion() || (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode()) (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode); else parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "only allow constants or variables which are not elements of a composite", "", ""); } -#line 12349 "MachineIndependent/glslang_tab.cpp" +#line 12367 "MachineIndependent/glslang_tab.cpp" break; - case 684: /* spirv_decorate_id_parameter: FLOATCONSTANT */ -#line 4390 "MachineIndependent/glslang.y" + case 685: /* spirv_decorate_id_parameter: FLOATCONSTANT */ +#line 4397 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12357 "MachineIndependent/glslang_tab.cpp" +#line 12375 "MachineIndependent/glslang_tab.cpp" break; - case 685: /* spirv_decorate_id_parameter: INTCONSTANT */ -#line 4393 "MachineIndependent/glslang.y" + case 686: /* spirv_decorate_id_parameter: INTCONSTANT */ +#line 4400 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12365 "MachineIndependent/glslang_tab.cpp" +#line 12383 "MachineIndependent/glslang_tab.cpp" break; - case 686: /* spirv_decorate_id_parameter: UINTCONSTANT */ -#line 4396 "MachineIndependent/glslang.y" + case 687: /* spirv_decorate_id_parameter: UINTCONSTANT */ +#line 4403 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12373 "MachineIndependent/glslang_tab.cpp" +#line 12391 "MachineIndependent/glslang_tab.cpp" break; - case 687: /* spirv_decorate_id_parameter: BOOLCONSTANT */ -#line 4399 "MachineIndependent/glslang.y" + case 688: /* spirv_decorate_id_parameter: BOOLCONSTANT */ +#line 4406 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12381 "MachineIndependent/glslang_tab.cpp" +#line 12399 "MachineIndependent/glslang_tab.cpp" break; - case 688: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ -#line 4404 "MachineIndependent/glslang.y" + case 689: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ +#line 4411 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate( parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12390 "MachineIndependent/glslang_tab.cpp" +#line 12408 "MachineIndependent/glslang_tab.cpp" break; - case 689: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ -#line 4408 "MachineIndependent/glslang.y" + case 690: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ +#line 4415 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12398 "MachineIndependent/glslang_tab.cpp" +#line 12416 "MachineIndependent/glslang_tab.cpp" break; - case 690: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4413 "MachineIndependent/glslang.y" + case 691: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4420 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12407 "MachineIndependent/glslang_tab.cpp" +#line 12425 "MachineIndependent/glslang_tab.cpp" break; - case 691: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4417 "MachineIndependent/glslang.y" + case 692: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4424 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12417 "MachineIndependent/glslang_tab.cpp" +#line 12435 "MachineIndependent/glslang_tab.cpp" break; - case 692: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4422 "MachineIndependent/glslang.y" + case 693: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4429 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 12426 "MachineIndependent/glslang_tab.cpp" +#line 12444 "MachineIndependent/glslang_tab.cpp" break; - case 693: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4426 "MachineIndependent/glslang.y" + case 694: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4433 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 12436 "MachineIndependent/glslang_tab.cpp" +#line 12454 "MachineIndependent/glslang_tab.cpp" break; - case 694: /* spirv_type_parameter_list: spirv_type_parameter */ -#line 4433 "MachineIndependent/glslang.y" + case 695: /* spirv_type_parameter_list: spirv_type_parameter */ +#line 4440 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams); } -#line 12444 "MachineIndependent/glslang_tab.cpp" +#line 12462 "MachineIndependent/glslang_tab.cpp" break; - case 695: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ -#line 4436 "MachineIndependent/glslang.y" + case 696: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ +#line 4443 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams)); } -#line 12452 "MachineIndependent/glslang_tab.cpp" +#line 12470 "MachineIndependent/glslang_tab.cpp" break; - case 696: /* spirv_type_parameter: constant_expression */ -#line 4441 "MachineIndependent/glslang.y" + case 697: /* spirv_type_parameter: constant_expression */ +#line 4448 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion()); } -#line 12460 "MachineIndependent/glslang_tab.cpp" +#line 12478 "MachineIndependent/glslang_tab.cpp" break; - case 697: /* spirv_type_parameter: type_specifier_nonarray */ -#line 4444 "MachineIndependent/glslang.y" + case 698: /* spirv_type_parameter: type_specifier_nonarray */ +#line 4451 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 12468 "MachineIndependent/glslang_tab.cpp" +#line 12486 "MachineIndependent/glslang_tab.cpp" break; - case 698: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4449 "MachineIndependent/glslang.y" + case 699: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4456 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12476 "MachineIndependent/glslang_tab.cpp" +#line 12494 "MachineIndependent/glslang_tab.cpp" break; - case 699: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4452 "MachineIndependent/glslang.y" + case 700: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4459 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12485 "MachineIndependent/glslang_tab.cpp" +#line 12503 "MachineIndependent/glslang_tab.cpp" break; - case 700: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ -#line 4458 "MachineIndependent/glslang.y" + case 701: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ +#line 4465 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst); } -#line 12493 "MachineIndependent/glslang_tab.cpp" +#line 12511 "MachineIndependent/glslang_tab.cpp" break; - case 701: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ -#line 4461 "MachineIndependent/glslang.y" + case 702: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ +#line 4468 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst)); } -#line 12501 "MachineIndependent/glslang_tab.cpp" +#line 12519 "MachineIndependent/glslang_tab.cpp" break; - case 702: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ -#line 4466 "MachineIndependent/glslang.y" + case 703: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ +#line 4473 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string); } -#line 12509 "MachineIndependent/glslang_tab.cpp" +#line 12527 "MachineIndependent/glslang_tab.cpp" break; - case 703: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ -#line 4469 "MachineIndependent/glslang.y" + case 704: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ +#line 4476 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i); } -#line 12517 "MachineIndependent/glslang_tab.cpp" +#line 12535 "MachineIndependent/glslang_tab.cpp" break; -#line 12521 "MachineIndependent/glslang_tab.cpp" +#line 12539 "MachineIndependent/glslang_tab.cpp" default: break; } @@ -12741,5 +12759,5 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); return yyresult; } -#line 4473 "MachineIndependent/glslang.y" +#line 4480 "MachineIndependent/glslang.y" diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index 7fcfe3e895..b8b86d969d 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -218,307 +218,308 @@ extern int yydebug; ICOOPMATNV = 419, /* ICOOPMATNV */ UCOOPMATNV = 420, /* UCOOPMATNV */ COOPMAT = 421, /* COOPMAT */ - HITOBJECTNV = 422, /* HITOBJECTNV */ - HITOBJECTATTRNV = 423, /* HITOBJECTATTRNV */ - TENSORLAYOUTNV = 424, /* TENSORLAYOUTNV */ - TENSORVIEWNV = 425, /* TENSORVIEWNV */ - SAMPLERCUBEARRAY = 426, /* SAMPLERCUBEARRAY */ - SAMPLERCUBEARRAYSHADOW = 427, /* SAMPLERCUBEARRAYSHADOW */ - ISAMPLERCUBEARRAY = 428, /* ISAMPLERCUBEARRAY */ - USAMPLERCUBEARRAY = 429, /* USAMPLERCUBEARRAY */ - SAMPLER1D = 430, /* SAMPLER1D */ - SAMPLER1DARRAY = 431, /* SAMPLER1DARRAY */ - SAMPLER1DARRAYSHADOW = 432, /* SAMPLER1DARRAYSHADOW */ - ISAMPLER1D = 433, /* ISAMPLER1D */ - SAMPLER1DSHADOW = 434, /* SAMPLER1DSHADOW */ - SAMPLER2DRECT = 435, /* SAMPLER2DRECT */ - SAMPLER2DRECTSHADOW = 436, /* SAMPLER2DRECTSHADOW */ - ISAMPLER2DRECT = 437, /* ISAMPLER2DRECT */ - USAMPLER2DRECT = 438, /* USAMPLER2DRECT */ - SAMPLERBUFFER = 439, /* SAMPLERBUFFER */ - ISAMPLERBUFFER = 440, /* ISAMPLERBUFFER */ - USAMPLERBUFFER = 441, /* USAMPLERBUFFER */ - SAMPLER2DMS = 442, /* SAMPLER2DMS */ - ISAMPLER2DMS = 443, /* ISAMPLER2DMS */ - USAMPLER2DMS = 444, /* USAMPLER2DMS */ - SAMPLER2DMSARRAY = 445, /* SAMPLER2DMSARRAY */ - ISAMPLER2DMSARRAY = 446, /* ISAMPLER2DMSARRAY */ - USAMPLER2DMSARRAY = 447, /* USAMPLER2DMSARRAY */ - SAMPLEREXTERNALOES = 448, /* SAMPLEREXTERNALOES */ - SAMPLEREXTERNAL2DY2YEXT = 449, /* SAMPLEREXTERNAL2DY2YEXT */ - ISAMPLER1DARRAY = 450, /* ISAMPLER1DARRAY */ - USAMPLER1D = 451, /* USAMPLER1D */ - USAMPLER1DARRAY = 452, /* USAMPLER1DARRAY */ - F16SAMPLER1D = 453, /* F16SAMPLER1D */ - F16SAMPLER2D = 454, /* F16SAMPLER2D */ - F16SAMPLER3D = 455, /* F16SAMPLER3D */ - F16SAMPLER2DRECT = 456, /* F16SAMPLER2DRECT */ - F16SAMPLERCUBE = 457, /* F16SAMPLERCUBE */ - F16SAMPLER1DARRAY = 458, /* F16SAMPLER1DARRAY */ - F16SAMPLER2DARRAY = 459, /* F16SAMPLER2DARRAY */ - F16SAMPLERCUBEARRAY = 460, /* F16SAMPLERCUBEARRAY */ - F16SAMPLERBUFFER = 461, /* F16SAMPLERBUFFER */ - F16SAMPLER2DMS = 462, /* F16SAMPLER2DMS */ - F16SAMPLER2DMSARRAY = 463, /* F16SAMPLER2DMSARRAY */ - F16SAMPLER1DSHADOW = 464, /* F16SAMPLER1DSHADOW */ - F16SAMPLER2DSHADOW = 465, /* F16SAMPLER2DSHADOW */ - F16SAMPLER1DARRAYSHADOW = 466, /* F16SAMPLER1DARRAYSHADOW */ - F16SAMPLER2DARRAYSHADOW = 467, /* F16SAMPLER2DARRAYSHADOW */ - F16SAMPLER2DRECTSHADOW = 468, /* F16SAMPLER2DRECTSHADOW */ - F16SAMPLERCUBESHADOW = 469, /* F16SAMPLERCUBESHADOW */ - F16SAMPLERCUBEARRAYSHADOW = 470, /* F16SAMPLERCUBEARRAYSHADOW */ - IMAGE1D = 471, /* IMAGE1D */ - IIMAGE1D = 472, /* IIMAGE1D */ - UIMAGE1D = 473, /* UIMAGE1D */ - IMAGE2D = 474, /* IMAGE2D */ - IIMAGE2D = 475, /* IIMAGE2D */ - UIMAGE2D = 476, /* UIMAGE2D */ - IMAGE3D = 477, /* IMAGE3D */ - IIMAGE3D = 478, /* IIMAGE3D */ - UIMAGE3D = 479, /* UIMAGE3D */ - IMAGE2DRECT = 480, /* IMAGE2DRECT */ - IIMAGE2DRECT = 481, /* IIMAGE2DRECT */ - UIMAGE2DRECT = 482, /* UIMAGE2DRECT */ - IMAGECUBE = 483, /* IMAGECUBE */ - IIMAGECUBE = 484, /* IIMAGECUBE */ - UIMAGECUBE = 485, /* UIMAGECUBE */ - IMAGEBUFFER = 486, /* IMAGEBUFFER */ - IIMAGEBUFFER = 487, /* IIMAGEBUFFER */ - UIMAGEBUFFER = 488, /* UIMAGEBUFFER */ - IMAGE1DARRAY = 489, /* IMAGE1DARRAY */ - IIMAGE1DARRAY = 490, /* IIMAGE1DARRAY */ - UIMAGE1DARRAY = 491, /* UIMAGE1DARRAY */ - IMAGE2DARRAY = 492, /* IMAGE2DARRAY */ - IIMAGE2DARRAY = 493, /* IIMAGE2DARRAY */ - UIMAGE2DARRAY = 494, /* UIMAGE2DARRAY */ - IMAGECUBEARRAY = 495, /* IMAGECUBEARRAY */ - IIMAGECUBEARRAY = 496, /* IIMAGECUBEARRAY */ - UIMAGECUBEARRAY = 497, /* UIMAGECUBEARRAY */ - IMAGE2DMS = 498, /* IMAGE2DMS */ - IIMAGE2DMS = 499, /* IIMAGE2DMS */ - UIMAGE2DMS = 500, /* UIMAGE2DMS */ - IMAGE2DMSARRAY = 501, /* IMAGE2DMSARRAY */ - IIMAGE2DMSARRAY = 502, /* IIMAGE2DMSARRAY */ - UIMAGE2DMSARRAY = 503, /* UIMAGE2DMSARRAY */ - F16IMAGE1D = 504, /* F16IMAGE1D */ - F16IMAGE2D = 505, /* F16IMAGE2D */ - F16IMAGE3D = 506, /* F16IMAGE3D */ - F16IMAGE2DRECT = 507, /* F16IMAGE2DRECT */ - F16IMAGECUBE = 508, /* F16IMAGECUBE */ - F16IMAGE1DARRAY = 509, /* F16IMAGE1DARRAY */ - F16IMAGE2DARRAY = 510, /* F16IMAGE2DARRAY */ - F16IMAGECUBEARRAY = 511, /* F16IMAGECUBEARRAY */ - F16IMAGEBUFFER = 512, /* F16IMAGEBUFFER */ - F16IMAGE2DMS = 513, /* F16IMAGE2DMS */ - F16IMAGE2DMSARRAY = 514, /* F16IMAGE2DMSARRAY */ - I64IMAGE1D = 515, /* I64IMAGE1D */ - U64IMAGE1D = 516, /* U64IMAGE1D */ - I64IMAGE2D = 517, /* I64IMAGE2D */ - U64IMAGE2D = 518, /* U64IMAGE2D */ - I64IMAGE3D = 519, /* I64IMAGE3D */ - U64IMAGE3D = 520, /* U64IMAGE3D */ - I64IMAGE2DRECT = 521, /* I64IMAGE2DRECT */ - U64IMAGE2DRECT = 522, /* U64IMAGE2DRECT */ - I64IMAGECUBE = 523, /* I64IMAGECUBE */ - U64IMAGECUBE = 524, /* U64IMAGECUBE */ - I64IMAGEBUFFER = 525, /* I64IMAGEBUFFER */ - U64IMAGEBUFFER = 526, /* U64IMAGEBUFFER */ - I64IMAGE1DARRAY = 527, /* I64IMAGE1DARRAY */ - U64IMAGE1DARRAY = 528, /* U64IMAGE1DARRAY */ - I64IMAGE2DARRAY = 529, /* I64IMAGE2DARRAY */ - U64IMAGE2DARRAY = 530, /* U64IMAGE2DARRAY */ - I64IMAGECUBEARRAY = 531, /* I64IMAGECUBEARRAY */ - U64IMAGECUBEARRAY = 532, /* U64IMAGECUBEARRAY */ - I64IMAGE2DMS = 533, /* I64IMAGE2DMS */ - U64IMAGE2DMS = 534, /* U64IMAGE2DMS */ - I64IMAGE2DMSARRAY = 535, /* I64IMAGE2DMSARRAY */ - U64IMAGE2DMSARRAY = 536, /* U64IMAGE2DMSARRAY */ - TEXTURECUBEARRAY = 537, /* TEXTURECUBEARRAY */ - ITEXTURECUBEARRAY = 538, /* ITEXTURECUBEARRAY */ - UTEXTURECUBEARRAY = 539, /* UTEXTURECUBEARRAY */ - TEXTURE1D = 540, /* TEXTURE1D */ - ITEXTURE1D = 541, /* ITEXTURE1D */ - UTEXTURE1D = 542, /* UTEXTURE1D */ - TEXTURE1DARRAY = 543, /* TEXTURE1DARRAY */ - ITEXTURE1DARRAY = 544, /* ITEXTURE1DARRAY */ - UTEXTURE1DARRAY = 545, /* UTEXTURE1DARRAY */ - TEXTURE2DRECT = 546, /* TEXTURE2DRECT */ - ITEXTURE2DRECT = 547, /* ITEXTURE2DRECT */ - UTEXTURE2DRECT = 548, /* UTEXTURE2DRECT */ - TEXTUREBUFFER = 549, /* TEXTUREBUFFER */ - ITEXTUREBUFFER = 550, /* ITEXTUREBUFFER */ - UTEXTUREBUFFER = 551, /* UTEXTUREBUFFER */ - TEXTURE2DMS = 552, /* TEXTURE2DMS */ - ITEXTURE2DMS = 553, /* ITEXTURE2DMS */ - UTEXTURE2DMS = 554, /* UTEXTURE2DMS */ - TEXTURE2DMSARRAY = 555, /* TEXTURE2DMSARRAY */ - ITEXTURE2DMSARRAY = 556, /* ITEXTURE2DMSARRAY */ - UTEXTURE2DMSARRAY = 557, /* UTEXTURE2DMSARRAY */ - F16TEXTURE1D = 558, /* F16TEXTURE1D */ - F16TEXTURE2D = 559, /* F16TEXTURE2D */ - F16TEXTURE3D = 560, /* F16TEXTURE3D */ - F16TEXTURE2DRECT = 561, /* F16TEXTURE2DRECT */ - F16TEXTURECUBE = 562, /* F16TEXTURECUBE */ - F16TEXTURE1DARRAY = 563, /* F16TEXTURE1DARRAY */ - F16TEXTURE2DARRAY = 564, /* F16TEXTURE2DARRAY */ - F16TEXTURECUBEARRAY = 565, /* F16TEXTURECUBEARRAY */ - F16TEXTUREBUFFER = 566, /* F16TEXTUREBUFFER */ - F16TEXTURE2DMS = 567, /* F16TEXTURE2DMS */ - F16TEXTURE2DMSARRAY = 568, /* F16TEXTURE2DMSARRAY */ - SUBPASSINPUT = 569, /* SUBPASSINPUT */ - SUBPASSINPUTMS = 570, /* SUBPASSINPUTMS */ - ISUBPASSINPUT = 571, /* ISUBPASSINPUT */ - ISUBPASSINPUTMS = 572, /* ISUBPASSINPUTMS */ - USUBPASSINPUT = 573, /* USUBPASSINPUT */ - USUBPASSINPUTMS = 574, /* USUBPASSINPUTMS */ - F16SUBPASSINPUT = 575, /* F16SUBPASSINPUT */ - F16SUBPASSINPUTMS = 576, /* F16SUBPASSINPUTMS */ - SPIRV_INSTRUCTION = 577, /* SPIRV_INSTRUCTION */ - SPIRV_EXECUTION_MODE = 578, /* SPIRV_EXECUTION_MODE */ - SPIRV_EXECUTION_MODE_ID = 579, /* SPIRV_EXECUTION_MODE_ID */ - SPIRV_DECORATE = 580, /* SPIRV_DECORATE */ - SPIRV_DECORATE_ID = 581, /* SPIRV_DECORATE_ID */ - SPIRV_DECORATE_STRING = 582, /* SPIRV_DECORATE_STRING */ - SPIRV_TYPE = 583, /* SPIRV_TYPE */ - SPIRV_STORAGE_CLASS = 584, /* SPIRV_STORAGE_CLASS */ - SPIRV_BY_REFERENCE = 585, /* SPIRV_BY_REFERENCE */ - SPIRV_LITERAL = 586, /* SPIRV_LITERAL */ - ATTACHMENTEXT = 587, /* ATTACHMENTEXT */ - IATTACHMENTEXT = 588, /* IATTACHMENTEXT */ - UATTACHMENTEXT = 589, /* UATTACHMENTEXT */ - LEFT_OP = 590, /* LEFT_OP */ - RIGHT_OP = 591, /* RIGHT_OP */ - INC_OP = 592, /* INC_OP */ - DEC_OP = 593, /* DEC_OP */ - LE_OP = 594, /* LE_OP */ - GE_OP = 595, /* GE_OP */ - EQ_OP = 596, /* EQ_OP */ - NE_OP = 597, /* NE_OP */ - AND_OP = 598, /* AND_OP */ - OR_OP = 599, /* OR_OP */ - XOR_OP = 600, /* XOR_OP */ - MUL_ASSIGN = 601, /* MUL_ASSIGN */ - DIV_ASSIGN = 602, /* DIV_ASSIGN */ - ADD_ASSIGN = 603, /* ADD_ASSIGN */ - MOD_ASSIGN = 604, /* MOD_ASSIGN */ - LEFT_ASSIGN = 605, /* LEFT_ASSIGN */ - RIGHT_ASSIGN = 606, /* RIGHT_ASSIGN */ - AND_ASSIGN = 607, /* AND_ASSIGN */ - XOR_ASSIGN = 608, /* XOR_ASSIGN */ - OR_ASSIGN = 609, /* OR_ASSIGN */ - SUB_ASSIGN = 610, /* SUB_ASSIGN */ - STRING_LITERAL = 611, /* STRING_LITERAL */ - LEFT_PAREN = 612, /* LEFT_PAREN */ - RIGHT_PAREN = 613, /* RIGHT_PAREN */ - LEFT_BRACKET = 614, /* LEFT_BRACKET */ - RIGHT_BRACKET = 615, /* RIGHT_BRACKET */ - LEFT_BRACE = 616, /* LEFT_BRACE */ - RIGHT_BRACE = 617, /* RIGHT_BRACE */ - DOT = 618, /* DOT */ - COMMA = 619, /* COMMA */ - COLON = 620, /* COLON */ - EQUAL = 621, /* EQUAL */ - SEMICOLON = 622, /* SEMICOLON */ - BANG = 623, /* BANG */ - DASH = 624, /* DASH */ - TILDE = 625, /* TILDE */ - PLUS = 626, /* PLUS */ - STAR = 627, /* STAR */ - SLASH = 628, /* SLASH */ - PERCENT = 629, /* PERCENT */ - LEFT_ANGLE = 630, /* LEFT_ANGLE */ - RIGHT_ANGLE = 631, /* RIGHT_ANGLE */ - VERTICAL_BAR = 632, /* VERTICAL_BAR */ - CARET = 633, /* CARET */ - AMPERSAND = 634, /* AMPERSAND */ - QUESTION = 635, /* QUESTION */ - INVARIANT = 636, /* INVARIANT */ - HIGH_PRECISION = 637, /* HIGH_PRECISION */ - MEDIUM_PRECISION = 638, /* MEDIUM_PRECISION */ - LOW_PRECISION = 639, /* LOW_PRECISION */ - PRECISION = 640, /* PRECISION */ - PACKED = 641, /* PACKED */ - RESOURCE = 642, /* RESOURCE */ - SUPERP = 643, /* SUPERP */ - FLOATCONSTANT = 644, /* FLOATCONSTANT */ - INTCONSTANT = 645, /* INTCONSTANT */ - UINTCONSTANT = 646, /* UINTCONSTANT */ - BOOLCONSTANT = 647, /* BOOLCONSTANT */ - IDENTIFIER = 648, /* IDENTIFIER */ - TYPE_NAME = 649, /* TYPE_NAME */ - CENTROID = 650, /* CENTROID */ - IN = 651, /* IN */ - OUT = 652, /* OUT */ - INOUT = 653, /* INOUT */ - STRUCT = 654, /* STRUCT */ - VOID = 655, /* VOID */ - WHILE = 656, /* WHILE */ - BREAK = 657, /* BREAK */ - CONTINUE = 658, /* CONTINUE */ - DO = 659, /* DO */ - ELSE = 660, /* ELSE */ - FOR = 661, /* FOR */ - IF = 662, /* IF */ - DISCARD = 663, /* DISCARD */ - RETURN = 664, /* RETURN */ - SWITCH = 665, /* SWITCH */ - CASE = 666, /* CASE */ - DEFAULT = 667, /* DEFAULT */ - TERMINATE_INVOCATION = 668, /* TERMINATE_INVOCATION */ - TERMINATE_RAY = 669, /* TERMINATE_RAY */ - IGNORE_INTERSECTION = 670, /* IGNORE_INTERSECTION */ - UNIFORM = 671, /* UNIFORM */ - SHARED = 672, /* SHARED */ - BUFFER = 673, /* BUFFER */ - TILEIMAGEEXT = 674, /* TILEIMAGEEXT */ - FLAT = 675, /* FLAT */ - SMOOTH = 676, /* SMOOTH */ - LAYOUT = 677, /* LAYOUT */ - DOUBLECONSTANT = 678, /* DOUBLECONSTANT */ - INT16CONSTANT = 679, /* INT16CONSTANT */ - UINT16CONSTANT = 680, /* UINT16CONSTANT */ - FLOAT16CONSTANT = 681, /* FLOAT16CONSTANT */ - INT32CONSTANT = 682, /* INT32CONSTANT */ - UINT32CONSTANT = 683, /* UINT32CONSTANT */ - INT64CONSTANT = 684, /* INT64CONSTANT */ - UINT64CONSTANT = 685, /* UINT64CONSTANT */ - SUBROUTINE = 686, /* SUBROUTINE */ - DEMOTE = 687, /* DEMOTE */ - FUNCTION = 688, /* FUNCTION */ - PAYLOADNV = 689, /* PAYLOADNV */ - PAYLOADINNV = 690, /* PAYLOADINNV */ - HITATTRNV = 691, /* HITATTRNV */ - CALLDATANV = 692, /* CALLDATANV */ - CALLDATAINNV = 693, /* CALLDATAINNV */ - PAYLOADEXT = 694, /* PAYLOADEXT */ - PAYLOADINEXT = 695, /* PAYLOADINEXT */ - HITATTREXT = 696, /* HITATTREXT */ - CALLDATAEXT = 697, /* CALLDATAEXT */ - CALLDATAINEXT = 698, /* CALLDATAINEXT */ - PATCH = 699, /* PATCH */ - SAMPLE = 700, /* SAMPLE */ - NONUNIFORM = 701, /* NONUNIFORM */ - COHERENT = 702, /* COHERENT */ - VOLATILE = 703, /* VOLATILE */ - RESTRICT = 704, /* RESTRICT */ - READONLY = 705, /* READONLY */ - WRITEONLY = 706, /* WRITEONLY */ - DEVICECOHERENT = 707, /* DEVICECOHERENT */ - QUEUEFAMILYCOHERENT = 708, /* QUEUEFAMILYCOHERENT */ - WORKGROUPCOHERENT = 709, /* WORKGROUPCOHERENT */ - SUBGROUPCOHERENT = 710, /* SUBGROUPCOHERENT */ - NONPRIVATE = 711, /* NONPRIVATE */ - SHADERCALLCOHERENT = 712, /* SHADERCALLCOHERENT */ - NOPERSPECTIVE = 713, /* NOPERSPECTIVE */ - EXPLICITINTERPAMD = 714, /* EXPLICITINTERPAMD */ - PERVERTEXEXT = 715, /* PERVERTEXEXT */ - PERVERTEXNV = 716, /* PERVERTEXNV */ - PERPRIMITIVENV = 717, /* PERPRIMITIVENV */ - PERVIEWNV = 718, /* PERVIEWNV */ - PERTASKNV = 719, /* PERTASKNV */ - PERPRIMITIVEEXT = 720, /* PERPRIMITIVEEXT */ - TASKPAYLOADWORKGROUPEXT = 721, /* TASKPAYLOADWORKGROUPEXT */ - PRECISE = 722 /* PRECISE */ + COOPVECNV = 422, /* COOPVECNV */ + HITOBJECTNV = 423, /* HITOBJECTNV */ + HITOBJECTATTRNV = 424, /* HITOBJECTATTRNV */ + TENSORLAYOUTNV = 425, /* TENSORLAYOUTNV */ + TENSORVIEWNV = 426, /* TENSORVIEWNV */ + SAMPLERCUBEARRAY = 427, /* SAMPLERCUBEARRAY */ + SAMPLERCUBEARRAYSHADOW = 428, /* SAMPLERCUBEARRAYSHADOW */ + ISAMPLERCUBEARRAY = 429, /* ISAMPLERCUBEARRAY */ + USAMPLERCUBEARRAY = 430, /* USAMPLERCUBEARRAY */ + SAMPLER1D = 431, /* SAMPLER1D */ + SAMPLER1DARRAY = 432, /* SAMPLER1DARRAY */ + SAMPLER1DARRAYSHADOW = 433, /* SAMPLER1DARRAYSHADOW */ + ISAMPLER1D = 434, /* ISAMPLER1D */ + SAMPLER1DSHADOW = 435, /* SAMPLER1DSHADOW */ + SAMPLER2DRECT = 436, /* SAMPLER2DRECT */ + SAMPLER2DRECTSHADOW = 437, /* SAMPLER2DRECTSHADOW */ + ISAMPLER2DRECT = 438, /* ISAMPLER2DRECT */ + USAMPLER2DRECT = 439, /* USAMPLER2DRECT */ + SAMPLERBUFFER = 440, /* SAMPLERBUFFER */ + ISAMPLERBUFFER = 441, /* ISAMPLERBUFFER */ + USAMPLERBUFFER = 442, /* USAMPLERBUFFER */ + SAMPLER2DMS = 443, /* SAMPLER2DMS */ + ISAMPLER2DMS = 444, /* ISAMPLER2DMS */ + USAMPLER2DMS = 445, /* USAMPLER2DMS */ + SAMPLER2DMSARRAY = 446, /* SAMPLER2DMSARRAY */ + ISAMPLER2DMSARRAY = 447, /* ISAMPLER2DMSARRAY */ + USAMPLER2DMSARRAY = 448, /* USAMPLER2DMSARRAY */ + SAMPLEREXTERNALOES = 449, /* SAMPLEREXTERNALOES */ + SAMPLEREXTERNAL2DY2YEXT = 450, /* SAMPLEREXTERNAL2DY2YEXT */ + ISAMPLER1DARRAY = 451, /* ISAMPLER1DARRAY */ + USAMPLER1D = 452, /* USAMPLER1D */ + USAMPLER1DARRAY = 453, /* USAMPLER1DARRAY */ + F16SAMPLER1D = 454, /* F16SAMPLER1D */ + F16SAMPLER2D = 455, /* F16SAMPLER2D */ + F16SAMPLER3D = 456, /* F16SAMPLER3D */ + F16SAMPLER2DRECT = 457, /* F16SAMPLER2DRECT */ + F16SAMPLERCUBE = 458, /* F16SAMPLERCUBE */ + F16SAMPLER1DARRAY = 459, /* F16SAMPLER1DARRAY */ + F16SAMPLER2DARRAY = 460, /* F16SAMPLER2DARRAY */ + F16SAMPLERCUBEARRAY = 461, /* F16SAMPLERCUBEARRAY */ + F16SAMPLERBUFFER = 462, /* F16SAMPLERBUFFER */ + F16SAMPLER2DMS = 463, /* F16SAMPLER2DMS */ + F16SAMPLER2DMSARRAY = 464, /* F16SAMPLER2DMSARRAY */ + F16SAMPLER1DSHADOW = 465, /* F16SAMPLER1DSHADOW */ + F16SAMPLER2DSHADOW = 466, /* F16SAMPLER2DSHADOW */ + F16SAMPLER1DARRAYSHADOW = 467, /* F16SAMPLER1DARRAYSHADOW */ + F16SAMPLER2DARRAYSHADOW = 468, /* F16SAMPLER2DARRAYSHADOW */ + F16SAMPLER2DRECTSHADOW = 469, /* F16SAMPLER2DRECTSHADOW */ + F16SAMPLERCUBESHADOW = 470, /* F16SAMPLERCUBESHADOW */ + F16SAMPLERCUBEARRAYSHADOW = 471, /* F16SAMPLERCUBEARRAYSHADOW */ + IMAGE1D = 472, /* IMAGE1D */ + IIMAGE1D = 473, /* IIMAGE1D */ + UIMAGE1D = 474, /* UIMAGE1D */ + IMAGE2D = 475, /* IMAGE2D */ + IIMAGE2D = 476, /* IIMAGE2D */ + UIMAGE2D = 477, /* UIMAGE2D */ + IMAGE3D = 478, /* IMAGE3D */ + IIMAGE3D = 479, /* IIMAGE3D */ + UIMAGE3D = 480, /* UIMAGE3D */ + IMAGE2DRECT = 481, /* IMAGE2DRECT */ + IIMAGE2DRECT = 482, /* IIMAGE2DRECT */ + UIMAGE2DRECT = 483, /* UIMAGE2DRECT */ + IMAGECUBE = 484, /* IMAGECUBE */ + IIMAGECUBE = 485, /* IIMAGECUBE */ + UIMAGECUBE = 486, /* UIMAGECUBE */ + IMAGEBUFFER = 487, /* IMAGEBUFFER */ + IIMAGEBUFFER = 488, /* IIMAGEBUFFER */ + UIMAGEBUFFER = 489, /* UIMAGEBUFFER */ + IMAGE1DARRAY = 490, /* IMAGE1DARRAY */ + IIMAGE1DARRAY = 491, /* IIMAGE1DARRAY */ + UIMAGE1DARRAY = 492, /* UIMAGE1DARRAY */ + IMAGE2DARRAY = 493, /* IMAGE2DARRAY */ + IIMAGE2DARRAY = 494, /* IIMAGE2DARRAY */ + UIMAGE2DARRAY = 495, /* UIMAGE2DARRAY */ + IMAGECUBEARRAY = 496, /* IMAGECUBEARRAY */ + IIMAGECUBEARRAY = 497, /* IIMAGECUBEARRAY */ + UIMAGECUBEARRAY = 498, /* UIMAGECUBEARRAY */ + IMAGE2DMS = 499, /* IMAGE2DMS */ + IIMAGE2DMS = 500, /* IIMAGE2DMS */ + UIMAGE2DMS = 501, /* UIMAGE2DMS */ + IMAGE2DMSARRAY = 502, /* IMAGE2DMSARRAY */ + IIMAGE2DMSARRAY = 503, /* IIMAGE2DMSARRAY */ + UIMAGE2DMSARRAY = 504, /* UIMAGE2DMSARRAY */ + F16IMAGE1D = 505, /* F16IMAGE1D */ + F16IMAGE2D = 506, /* F16IMAGE2D */ + F16IMAGE3D = 507, /* F16IMAGE3D */ + F16IMAGE2DRECT = 508, /* F16IMAGE2DRECT */ + F16IMAGECUBE = 509, /* F16IMAGECUBE */ + F16IMAGE1DARRAY = 510, /* F16IMAGE1DARRAY */ + F16IMAGE2DARRAY = 511, /* F16IMAGE2DARRAY */ + F16IMAGECUBEARRAY = 512, /* F16IMAGECUBEARRAY */ + F16IMAGEBUFFER = 513, /* F16IMAGEBUFFER */ + F16IMAGE2DMS = 514, /* F16IMAGE2DMS */ + F16IMAGE2DMSARRAY = 515, /* F16IMAGE2DMSARRAY */ + I64IMAGE1D = 516, /* I64IMAGE1D */ + U64IMAGE1D = 517, /* U64IMAGE1D */ + I64IMAGE2D = 518, /* I64IMAGE2D */ + U64IMAGE2D = 519, /* U64IMAGE2D */ + I64IMAGE3D = 520, /* I64IMAGE3D */ + U64IMAGE3D = 521, /* U64IMAGE3D */ + I64IMAGE2DRECT = 522, /* I64IMAGE2DRECT */ + U64IMAGE2DRECT = 523, /* U64IMAGE2DRECT */ + I64IMAGECUBE = 524, /* I64IMAGECUBE */ + U64IMAGECUBE = 525, /* U64IMAGECUBE */ + I64IMAGEBUFFER = 526, /* I64IMAGEBUFFER */ + U64IMAGEBUFFER = 527, /* U64IMAGEBUFFER */ + I64IMAGE1DARRAY = 528, /* I64IMAGE1DARRAY */ + U64IMAGE1DARRAY = 529, /* U64IMAGE1DARRAY */ + I64IMAGE2DARRAY = 530, /* I64IMAGE2DARRAY */ + U64IMAGE2DARRAY = 531, /* U64IMAGE2DARRAY */ + I64IMAGECUBEARRAY = 532, /* I64IMAGECUBEARRAY */ + U64IMAGECUBEARRAY = 533, /* U64IMAGECUBEARRAY */ + I64IMAGE2DMS = 534, /* I64IMAGE2DMS */ + U64IMAGE2DMS = 535, /* U64IMAGE2DMS */ + I64IMAGE2DMSARRAY = 536, /* I64IMAGE2DMSARRAY */ + U64IMAGE2DMSARRAY = 537, /* U64IMAGE2DMSARRAY */ + TEXTURECUBEARRAY = 538, /* TEXTURECUBEARRAY */ + ITEXTURECUBEARRAY = 539, /* ITEXTURECUBEARRAY */ + UTEXTURECUBEARRAY = 540, /* UTEXTURECUBEARRAY */ + TEXTURE1D = 541, /* TEXTURE1D */ + ITEXTURE1D = 542, /* ITEXTURE1D */ + UTEXTURE1D = 543, /* UTEXTURE1D */ + TEXTURE1DARRAY = 544, /* TEXTURE1DARRAY */ + ITEXTURE1DARRAY = 545, /* ITEXTURE1DARRAY */ + UTEXTURE1DARRAY = 546, /* UTEXTURE1DARRAY */ + TEXTURE2DRECT = 547, /* TEXTURE2DRECT */ + ITEXTURE2DRECT = 548, /* ITEXTURE2DRECT */ + UTEXTURE2DRECT = 549, /* UTEXTURE2DRECT */ + TEXTUREBUFFER = 550, /* TEXTUREBUFFER */ + ITEXTUREBUFFER = 551, /* ITEXTUREBUFFER */ + UTEXTUREBUFFER = 552, /* UTEXTUREBUFFER */ + TEXTURE2DMS = 553, /* TEXTURE2DMS */ + ITEXTURE2DMS = 554, /* ITEXTURE2DMS */ + UTEXTURE2DMS = 555, /* UTEXTURE2DMS */ + TEXTURE2DMSARRAY = 556, /* TEXTURE2DMSARRAY */ + ITEXTURE2DMSARRAY = 557, /* ITEXTURE2DMSARRAY */ + UTEXTURE2DMSARRAY = 558, /* UTEXTURE2DMSARRAY */ + F16TEXTURE1D = 559, /* F16TEXTURE1D */ + F16TEXTURE2D = 560, /* F16TEXTURE2D */ + F16TEXTURE3D = 561, /* F16TEXTURE3D */ + F16TEXTURE2DRECT = 562, /* F16TEXTURE2DRECT */ + F16TEXTURECUBE = 563, /* F16TEXTURECUBE */ + F16TEXTURE1DARRAY = 564, /* F16TEXTURE1DARRAY */ + F16TEXTURE2DARRAY = 565, /* F16TEXTURE2DARRAY */ + F16TEXTURECUBEARRAY = 566, /* F16TEXTURECUBEARRAY */ + F16TEXTUREBUFFER = 567, /* F16TEXTUREBUFFER */ + F16TEXTURE2DMS = 568, /* F16TEXTURE2DMS */ + F16TEXTURE2DMSARRAY = 569, /* F16TEXTURE2DMSARRAY */ + SUBPASSINPUT = 570, /* SUBPASSINPUT */ + SUBPASSINPUTMS = 571, /* SUBPASSINPUTMS */ + ISUBPASSINPUT = 572, /* ISUBPASSINPUT */ + ISUBPASSINPUTMS = 573, /* ISUBPASSINPUTMS */ + USUBPASSINPUT = 574, /* USUBPASSINPUT */ + USUBPASSINPUTMS = 575, /* USUBPASSINPUTMS */ + F16SUBPASSINPUT = 576, /* F16SUBPASSINPUT */ + F16SUBPASSINPUTMS = 577, /* F16SUBPASSINPUTMS */ + SPIRV_INSTRUCTION = 578, /* SPIRV_INSTRUCTION */ + SPIRV_EXECUTION_MODE = 579, /* SPIRV_EXECUTION_MODE */ + SPIRV_EXECUTION_MODE_ID = 580, /* SPIRV_EXECUTION_MODE_ID */ + SPIRV_DECORATE = 581, /* SPIRV_DECORATE */ + SPIRV_DECORATE_ID = 582, /* SPIRV_DECORATE_ID */ + SPIRV_DECORATE_STRING = 583, /* SPIRV_DECORATE_STRING */ + SPIRV_TYPE = 584, /* SPIRV_TYPE */ + SPIRV_STORAGE_CLASS = 585, /* SPIRV_STORAGE_CLASS */ + SPIRV_BY_REFERENCE = 586, /* SPIRV_BY_REFERENCE */ + SPIRV_LITERAL = 587, /* SPIRV_LITERAL */ + ATTACHMENTEXT = 588, /* ATTACHMENTEXT */ + IATTACHMENTEXT = 589, /* IATTACHMENTEXT */ + UATTACHMENTEXT = 590, /* UATTACHMENTEXT */ + LEFT_OP = 591, /* LEFT_OP */ + RIGHT_OP = 592, /* RIGHT_OP */ + INC_OP = 593, /* INC_OP */ + DEC_OP = 594, /* DEC_OP */ + LE_OP = 595, /* LE_OP */ + GE_OP = 596, /* GE_OP */ + EQ_OP = 597, /* EQ_OP */ + NE_OP = 598, /* NE_OP */ + AND_OP = 599, /* AND_OP */ + OR_OP = 600, /* OR_OP */ + XOR_OP = 601, /* XOR_OP */ + MUL_ASSIGN = 602, /* MUL_ASSIGN */ + DIV_ASSIGN = 603, /* DIV_ASSIGN */ + ADD_ASSIGN = 604, /* ADD_ASSIGN */ + MOD_ASSIGN = 605, /* MOD_ASSIGN */ + LEFT_ASSIGN = 606, /* LEFT_ASSIGN */ + RIGHT_ASSIGN = 607, /* RIGHT_ASSIGN */ + AND_ASSIGN = 608, /* AND_ASSIGN */ + XOR_ASSIGN = 609, /* XOR_ASSIGN */ + OR_ASSIGN = 610, /* OR_ASSIGN */ + SUB_ASSIGN = 611, /* SUB_ASSIGN */ + STRING_LITERAL = 612, /* STRING_LITERAL */ + LEFT_PAREN = 613, /* LEFT_PAREN */ + RIGHT_PAREN = 614, /* RIGHT_PAREN */ + LEFT_BRACKET = 615, /* LEFT_BRACKET */ + RIGHT_BRACKET = 616, /* RIGHT_BRACKET */ + LEFT_BRACE = 617, /* LEFT_BRACE */ + RIGHT_BRACE = 618, /* RIGHT_BRACE */ + DOT = 619, /* DOT */ + COMMA = 620, /* COMMA */ + COLON = 621, /* COLON */ + EQUAL = 622, /* EQUAL */ + SEMICOLON = 623, /* SEMICOLON */ + BANG = 624, /* BANG */ + DASH = 625, /* DASH */ + TILDE = 626, /* TILDE */ + PLUS = 627, /* PLUS */ + STAR = 628, /* STAR */ + SLASH = 629, /* SLASH */ + PERCENT = 630, /* PERCENT */ + LEFT_ANGLE = 631, /* LEFT_ANGLE */ + RIGHT_ANGLE = 632, /* RIGHT_ANGLE */ + VERTICAL_BAR = 633, /* VERTICAL_BAR */ + CARET = 634, /* CARET */ + AMPERSAND = 635, /* AMPERSAND */ + QUESTION = 636, /* QUESTION */ + INVARIANT = 637, /* INVARIANT */ + HIGH_PRECISION = 638, /* HIGH_PRECISION */ + MEDIUM_PRECISION = 639, /* MEDIUM_PRECISION */ + LOW_PRECISION = 640, /* LOW_PRECISION */ + PRECISION = 641, /* PRECISION */ + PACKED = 642, /* PACKED */ + RESOURCE = 643, /* RESOURCE */ + SUPERP = 644, /* SUPERP */ + FLOATCONSTANT = 645, /* FLOATCONSTANT */ + INTCONSTANT = 646, /* INTCONSTANT */ + UINTCONSTANT = 647, /* UINTCONSTANT */ + BOOLCONSTANT = 648, /* BOOLCONSTANT */ + IDENTIFIER = 649, /* IDENTIFIER */ + TYPE_NAME = 650, /* TYPE_NAME */ + CENTROID = 651, /* CENTROID */ + IN = 652, /* IN */ + OUT = 653, /* OUT */ + INOUT = 654, /* INOUT */ + STRUCT = 655, /* STRUCT */ + VOID = 656, /* VOID */ + WHILE = 657, /* WHILE */ + BREAK = 658, /* BREAK */ + CONTINUE = 659, /* CONTINUE */ + DO = 660, /* DO */ + ELSE = 661, /* ELSE */ + FOR = 662, /* FOR */ + IF = 663, /* IF */ + DISCARD = 664, /* DISCARD */ + RETURN = 665, /* RETURN */ + SWITCH = 666, /* SWITCH */ + CASE = 667, /* CASE */ + DEFAULT = 668, /* DEFAULT */ + TERMINATE_INVOCATION = 669, /* TERMINATE_INVOCATION */ + TERMINATE_RAY = 670, /* TERMINATE_RAY */ + IGNORE_INTERSECTION = 671, /* IGNORE_INTERSECTION */ + UNIFORM = 672, /* UNIFORM */ + SHARED = 673, /* SHARED */ + BUFFER = 674, /* BUFFER */ + TILEIMAGEEXT = 675, /* TILEIMAGEEXT */ + FLAT = 676, /* FLAT */ + SMOOTH = 677, /* SMOOTH */ + LAYOUT = 678, /* LAYOUT */ + DOUBLECONSTANT = 679, /* DOUBLECONSTANT */ + INT16CONSTANT = 680, /* INT16CONSTANT */ + UINT16CONSTANT = 681, /* UINT16CONSTANT */ + FLOAT16CONSTANT = 682, /* FLOAT16CONSTANT */ + INT32CONSTANT = 683, /* INT32CONSTANT */ + UINT32CONSTANT = 684, /* UINT32CONSTANT */ + INT64CONSTANT = 685, /* INT64CONSTANT */ + UINT64CONSTANT = 686, /* UINT64CONSTANT */ + SUBROUTINE = 687, /* SUBROUTINE */ + DEMOTE = 688, /* DEMOTE */ + FUNCTION = 689, /* FUNCTION */ + PAYLOADNV = 690, /* PAYLOADNV */ + PAYLOADINNV = 691, /* PAYLOADINNV */ + HITATTRNV = 692, /* HITATTRNV */ + CALLDATANV = 693, /* CALLDATANV */ + CALLDATAINNV = 694, /* CALLDATAINNV */ + PAYLOADEXT = 695, /* PAYLOADEXT */ + PAYLOADINEXT = 696, /* PAYLOADINEXT */ + HITATTREXT = 697, /* HITATTREXT */ + CALLDATAEXT = 698, /* CALLDATAEXT */ + CALLDATAINEXT = 699, /* CALLDATAINEXT */ + PATCH = 700, /* PATCH */ + SAMPLE = 701, /* SAMPLE */ + NONUNIFORM = 702, /* NONUNIFORM */ + COHERENT = 703, /* COHERENT */ + VOLATILE = 704, /* VOLATILE */ + RESTRICT = 705, /* RESTRICT */ + READONLY = 706, /* READONLY */ + WRITEONLY = 707, /* WRITEONLY */ + DEVICECOHERENT = 708, /* DEVICECOHERENT */ + QUEUEFAMILYCOHERENT = 709, /* QUEUEFAMILYCOHERENT */ + WORKGROUPCOHERENT = 710, /* WORKGROUPCOHERENT */ + SUBGROUPCOHERENT = 711, /* SUBGROUPCOHERENT */ + NONPRIVATE = 712, /* NONPRIVATE */ + SHADERCALLCOHERENT = 713, /* SHADERCALLCOHERENT */ + NOPERSPECTIVE = 714, /* NOPERSPECTIVE */ + EXPLICITINTERPAMD = 715, /* EXPLICITINTERPAMD */ + PERVERTEXEXT = 716, /* PERVERTEXEXT */ + PERVERTEXNV = 717, /* PERVERTEXNV */ + PERPRIMITIVENV = 718, /* PERPRIMITIVENV */ + PERVIEWNV = 719, /* PERVIEWNV */ + PERTASKNV = 720, /* PERTASKNV */ + PERPRIMITIVEEXT = 721, /* PERPRIMITIVEEXT */ + TASKPAYLOADWORKGROUPEXT = 722, /* TASKPAYLOADWORKGROUPEXT */ + PRECISE = 723 /* PRECISE */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -566,7 +567,7 @@ union YYSTYPE glslang::TTypeParameters* typeParameters; } interm; -#line 570 "MachineIndependent/glslang_tab.cpp.h" +#line 571 "MachineIndependent/glslang_tab.cpp.h" }; typedef union YYSTYPE YYSTYPE; diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp index 750ba7095f..df9c7d2534 100644 --- a/glslang/MachineIndependent/intermOut.cpp +++ b/glslang/MachineIndependent/intermOut.cpp @@ -643,6 +643,7 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructReference: out.debug << "Construct reference"; break; case EOpConstructCooperativeMatrixNV: out.debug << "Construct cooperative matrix NV"; break; case EOpConstructCooperativeMatrixKHR: out.debug << "Construct cooperative matrix KHR"; break; + case EOpConstructCooperativeVectorNV: out.debug << "Construct cooperative vector NV"; break; case EOpConstructAccStruct: out.debug << "Construct acceleration structure"; break; case EOpLessThan: out.debug << "Compare Less Than"; break; @@ -955,6 +956,13 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpCooperativeMatrixPerElementOpNV: out.debug << "cooperative matrix per element op"; break; case EOpCooperativeMatrixTransposeNV: out.debug << "Transpose cooperative matrix"; break; + case EOpCooperativeVectorMatMulNV: out.debug << "Cooperative vector matrix multiply NV"; break; + case EOpCooperativeVectorMatMulAddNV: out.debug << "Cooperative vector matrix multiply add NV"; break; + case EOpCooperativeVectorLoadNV: out.debug << "Load cooperative vector NV"; break; + case EOpCooperativeVectorStoreNV: out.debug << "Store cooperative vector NV"; break; + case EOpCooperativeVectorOuterProductAccumulateNV: out.debug << "Cooperative vector outer product accumulate NV"; break; + case EOpCooperativeVectorReduceSumAccumulateNV: out.debug << "Cooperative vector reduce sum accumulate NV"; break; + case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break; case EOpDebugPrintf: out.debug << "Debug printf"; break; diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h index 6b9bc04292..6509efd762 100644 --- a/glslang/MachineIndependent/parseVersions.h +++ b/glslang/MachineIndependent/parseVersions.h @@ -122,6 +122,7 @@ class TParseVersions { virtual void intcoopmatCheckNV(const TSourceLoc&, const char *op, bool builtIn = false); virtual void coopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual void tensorLayoutViewCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void coopvecCheck(const TSourceLoc&, const char* op, bool builtIn = false); bool relaxedErrors() const { return (messages & EShMsgRelaxedErrors) != 0; } bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; } bool isForwardCompatible() const { return forwardCompatible; } diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 6399712221..c347767446 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -376,6 +376,12 @@ INSTANTIATE_TEST_SUITE_P( "spv.coopmatKHR_Error.comp", "spv.coopmatKHR_constructor.comp", "spv.coopmatKHR_constructorError.comp", + "spv.coopvec.comp", + "spv.coopvec2.comp", + "spv.coopvecloadstore.comp", + "spv.coopvec_Error.comp", + "spv.coopvecTraining.comp", + "spv.coopvecTraining_Error.comp", "spv.dataOut.frag", "spv.dataOutIndirect.frag", "spv.dataOutIndirect.vert", diff --git a/known_good.json b/known_good.json index 50d8cc33fa..1aee781914 100644 --- a/known_good.json +++ b/known_good.json @@ -5,14 +5,14 @@ "site" : "github", "subrepo" : "KhronosGroup/SPIRV-Tools", "subdir" : "External/spirv-tools", - "commit": "e02275ec02b68e3d175528f768871c97ae9eee90" + "commit": "3364b982713a0440d1d342dd5eec65b122a61b71" }, { "name" : "spirv-tools/external/spirv-headers", "site" : "github", "subrepo" : "KhronosGroup/SPIRV-Headers", "subdir" : "External/spirv-tools/external/spirv-headers", - "commit" : "3f17b2af6784bfa2c5aa5dbb8e0e74a607dd8b3b" + "commit" : "767e901c986e9755a17e7939b3046fc2911a4bbd" }, { "name": "googletest",