diff --git a/3rdparty/glslang/SPIRV/GLSL.ext.NV.h b/3rdparty/glslang/SPIRV/GLSL.ext.NV.h index e4f11e4bf..d449c45b2 100644 --- a/3rdparty/glslang/SPIRV/GLSL.ext.NV.h +++ b/3rdparty/glslang/SPIRV/GLSL.ext.NV.h @@ -90,4 +90,10 @@ const char* const E_SPV_NV_displacement_micromap = "SPV_NV_displacement_micromap //SPV_NV_shader_atomic_fp16_vector const char* const E_SPV_NV_shader_atomic_fp16_vector = "SPV_NV_shader_atomic_fp16_vector"; +//SPV_NV_tensor_addressing +const char* const E_SPV_NV_tensor_addressing = "SPV_NV_tensor_addressing"; + +//SPV_NV_cooperative_matrix2 +const char* const E_SPV_NV_cooperative_matrix2 = "SPV_NV_cooperative_matrix2"; + #endif // #ifndef GLSLextNV_H diff --git a/3rdparty/glslang/SPIRV/GlslangToSpv.cpp b/3rdparty/glslang/SPIRV/GlslangToSpv.cpp index 4348fdf8d..4dc754ffd 100644 --- a/3rdparty/glslang/SPIRV/GlslangToSpv.cpp +++ b/3rdparty/glslang/SPIRV/GlslangToSpv.cpp @@ -173,7 +173,7 @@ protected: spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType); void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking, const glslang::TQualifier&, spv::Id, const std::vector& spvMembers); - spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false); + spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false, bool boolType = false); spv::Id accessChainLoad(const glslang::TType& type); void accessChainStore(const glslang::TType& type, spv::Id rvalue); void multiTypeStore(const glslang::TType&, spv::Id rValue); @@ -209,8 +209,9 @@ protected: spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand, glslang::TBasicType typeProxy); spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand, - glslang::TBasicType typeProxy); - spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType); + glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType); + spv::Id createIntWidthConversion(spv::Id operand, int vectorSize, spv::Id destType, + glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType); spv::Id makeSmearedConstant(spv::Id constant, int vectorSize); spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy, @@ -2040,6 +2041,10 @@ void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol) builder.setDebugSourceLocation(symbol->getLoc().line, symbol->getLoc().getFilename()); } + if (symbol->getBasicType() == glslang::EbtFunction) { + return; + } + SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (symbol->getType().isStruct()) glslangTypeToIdMap[symbol->getType().getStruct()] = symbol->getId(); @@ -2682,9 +2687,18 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI TranslateNonUniformDecoration(node->getType().getQualifier()) }; // it could be a conversion - if (! result) + if (! result) { result = createConversion(node->getOp(), decorations, resultType(), operand, - node->getOperand()->getBasicType()); + node->getType().getBasicType(), node->getOperand()->getBasicType()); + if (result) { + if (node->getType().isCoopMatKHR() && node->getOperand()->getAsTyped()->getType().isCoopMatKHR() && + !node->getAsTyped()->getType().sameCoopMatUse(node->getOperand()->getAsTyped()->getType())) { + // Conversions that change use need CapabilityCooperativeMatrixConversionsNV + builder.addCapability(spv::CapabilityCooperativeMatrixConversionsNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + } + } + } // if not, then possibly an operation if (! result) @@ -2806,6 +2820,18 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand); return false; + case glslang::EOpCreateTensorLayoutNV: + result = builder.createOp(spv::OpCreateTensorLayoutNV, resultType(), std::vector{}); + builder.clearAccessChain(); + builder.setAccessChainRValue(result); + return false; + + case glslang::EOpCreateTensorViewNV: + result = builder.createOp(spv::OpCreateTensorViewNV, resultType(), std::vector{}); + builder.clearAccessChain(); + builder.setAccessChainRValue(result); + return false; + default: logger->missingFunctionality("unknown glslang unary"); return true; // pick up operand as placeholder result @@ -3131,6 +3157,11 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt constructed = arguments[0]; } else constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments); + } else if (node->getOp() == glslang::EOpConstructCooperativeMatrixKHR && + node->getType().isCoopMatKHR() && node->getSequence()[0]->getAsTyped()->getType().isCoopMatKHR()) { + builder.addCapability(spv::CapabilityCooperativeMatrixConversionsNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + constructed = builder.createCooperativeMatrixConversion(resultType(), arguments[0]); } else if (node->getOp() == glslang::EOpConstructStruct || node->getOp() == glslang::EOpConstructCooperativeMatrixNV || node->getOp() == glslang::EOpConstructCooperativeMatrixKHR || @@ -3315,6 +3346,11 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpCooperativeMatrixStore: case glslang::EOpCooperativeMatrixLoadNV: case glslang::EOpCooperativeMatrixStoreNV: + case glslang::EOpCooperativeMatrixLoadTensorNV: + case glslang::EOpCooperativeMatrixStoreTensorNV: + case glslang::EOpCooperativeMatrixReduceNV: + case glslang::EOpCooperativeMatrixPerElementOpNV: + case glslang::EOpCooperativeMatrixTransposeNV: noReturnValue = true; break; case glslang::EOpBeginInvocationInterlock: @@ -3561,14 +3597,22 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt break; case glslang::EOpCooperativeMatrixLoad: case glslang::EOpCooperativeMatrixLoadNV: + case glslang::EOpCooperativeMatrixLoadTensorNV: if (arg == 0 || arg == 1) lvalue = true; break; case glslang::EOpCooperativeMatrixStore: case glslang::EOpCooperativeMatrixStoreNV: + case glslang::EOpCooperativeMatrixStoreTensorNV: if (arg == 1) lvalue = true; break; + case glslang::EOpCooperativeMatrixReduceNV: + case glslang::EOpCooperativeMatrixPerElementOpNV: + case glslang::EOpCooperativeMatrixTransposeNV: + if (arg == 0) + lvalue = true; + break; case glslang::EOpSpirvInst: if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference()) lvalue = true; @@ -3594,7 +3638,9 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt if (node->getOp() == glslang::EOpCooperativeMatrixLoad || node->getOp() == glslang::EOpCooperativeMatrixStore || node->getOp() == glslang::EOpCooperativeMatrixLoadNV || - node->getOp() == glslang::EOpCooperativeMatrixStoreNV) { + node->getOp() == glslang::EOpCooperativeMatrixStoreNV || + node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV || + node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) { if (arg == 1) { // fold "element" parameter into the access chain @@ -3616,10 +3662,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt int memoryAccess = TranslateMemoryAccess(coherentFlags); if (node->getOp() == glslang::EOpCooperativeMatrixLoad || - node->getOp() == glslang::EOpCooperativeMatrixLoadNV) + node->getOp() == glslang::EOpCooperativeMatrixLoadNV || + node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV) memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask; if (node->getOp() == glslang::EOpCooperativeMatrixStore || - node->getOp() == glslang::EOpCooperativeMatrixStoreNV) + node->getOp() == glslang::EOpCooperativeMatrixStoreNV || + node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask; if (builder.getStorageClass(builder.getAccessChain().base) == spv::StorageClassPhysicalStorageBufferEXT) { @@ -3706,6 +3754,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt } else if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvLiteral()) { // Will be translated to a literal value, make a placeholder here operands.push_back(spv::NoResult); + } else if (glslangOperands[arg]->getAsTyped()->getBasicType() == glslang::EbtFunction) { + spv::Function* function = functionMap[glslangOperands[arg]->getAsSymbolNode()->getMangledName().c_str()]; + assert(function); + operands.push_back(function->getId()); } else { operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType())); } @@ -3713,8 +3765,45 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt } builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename()); - if (node->getOp() == glslang::EOpCooperativeMatrixLoad || - node->getOp() == glslang::EOpCooperativeMatrixLoadNV) { + if (node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV) { + std::vector idImmOps; + + builder.addCapability(spv::CapabilityCooperativeMatrixTensorAddressingNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + + spv::Id object = builder.createLoad(operands[0], spv::NoPrecision); + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // Pointer + idImmOps.push_back(spv::IdImmediate(true, object)); // Object + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // tensorLayout + + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); // memoryaccess + + // initialize tensor operands to zero, then OR in flags based on the operands + size_t tensorOpIdx = idImmOps.size(); + idImmOps.push_back(spv::IdImmediate(false, 0)); + + for (uint32_t i = 3; i < operands.size(); ++i) { + if (builder.isTensorView(operands[i])) { + idImmOps[tensorOpIdx].word |= spv::TensorAddressingOperandsTensorViewMask; + } else { + // must be the decode func + idImmOps[tensorOpIdx].word |= spv::TensorAddressingOperandsDecodeFuncMask; + builder.addCapability(spv::CapabilityCooperativeMatrixBlockLoadsNV); + } + idImmOps.push_back(spv::IdImmediate(true, operands[i])); // tensorView or decodeFunc + } + + // get the pointee type + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeMatrixType(typeId)); + // do the op + spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadTensorNV, typeId, idImmOps); + // store the result to the pointer (out param 'm') + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeMatrixLoad || + node->getOp() == glslang::EOpCooperativeMatrixLoadNV) { std::vector idImmOps; idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf @@ -3742,6 +3831,28 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt // store the result to the pointer (out param 'm') builder.createStore(result, operands[0]); result = 0; + } else if (node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) { + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object + + builder.addCapability(spv::CapabilityCooperativeMatrixTensorAddressingNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // tensorLayout + + idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); // memoryaccess + + if (operands.size() > 3) { + idImmOps.push_back(spv::IdImmediate(false, spv::TensorAddressingOperandsTensorViewMask)); + idImmOps.push_back(spv::IdImmediate(true, operands[3])); // tensorView + } else { + idImmOps.push_back(spv::IdImmediate(false, 0)); + } + + builder.createNoResultOp(spv::OpCooperativeMatrixStoreTensorNV, idImmOps); + result = 0; } else if (node->getOp() == glslang::EOpCooperativeMatrixStore || node->getOp() == glslang::EOpCooperativeMatrixStoreNV) { std::vector idImmOps; @@ -3810,6 +3921,43 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt idImmOps.push_back(spv::IdImmediate(false, matrixOperands)); result = builder.createOp(spv::OpCooperativeMatrixMulAddKHR, resultType(), idImmOps); + } else if (node->getOp() == glslang::EOpCooperativeMatrixReduceNV) { + builder.addCapability(spv::CapabilityCooperativeMatrixReductionsNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + + spv::Op opcode = spv::OpCooperativeMatrixReduceNV; + unsigned mask = glslangOperands[2]->getAsConstantUnion()->getConstArray()[0].getUConst(); + + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeMatrixType(typeId)); + + result = builder.createCooperativeMatrixReduce(opcode, typeId, operands[1], mask, operands[3]); + // store the result to the pointer (out param 'm') + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeMatrixPerElementOpNV) { + builder.addCapability(spv::CapabilityCooperativeMatrixPerElementOperationsNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeMatrixType(typeId)); + + result = builder.createCooperativeMatrixPerElementOp(typeId, operands); + // store the result to the pointer + builder.createStore(result, operands[0]); + result = 0; + } else if (node->getOp() == glslang::EOpCooperativeMatrixTransposeNV) { + + builder.addCapability(spv::CapabilityCooperativeMatrixConversionsNV); + builder.addExtension(spv::E_SPV_NV_cooperative_matrix2); + + spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); + assert(builder.isCooperativeMatrixType(typeId)); + + result = builder.createUnaryOp(spv::OpCooperativeMatrixTransposeNV, typeId, operands[1]); + // store the result to the pointer + builder.createStore(result, operands[0]); + result = 0; } else if (atomic) { // Handle all atomics glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore) @@ -4691,6 +4839,32 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty break; } + case glslang::EbtTensorLayoutNV: + { + builder.addCapability(spv::CapabilityTensorAddressingNV); + builder.addExtension(spv::E_SPV_NV_tensor_addressing); + + std::vector operands; + for (uint32_t i = 0; i < 2; ++i) { + operands.push_back({true, makeArraySizeId(*type.getTypeParameters()->arraySizes, i, true)}); + } + spvType = builder.makeGenericType(spv::OpTypeTensorLayoutNV, operands); + break; + } + case glslang::EbtTensorViewNV: + { + builder.addCapability(spv::CapabilityTensorAddressingNV); + builder.addExtension(spv::E_SPV_NV_tensor_addressing); + + uint32_t dim = type.getTypeParameters()->arraySizes->getDimSize(0); + assert(dim >= 1 && dim <= 5); + std::vector operands; + for (uint32_t i = 0; i < dim + 2; ++i) { + operands.push_back({true, makeArraySizeId(*type.getTypeParameters()->arraySizes, i, true, i==1)}); + } + spvType = builder.makeGenericType(spv::OpTypeTensorViewNV, operands); + break; + } default: assert(0); break; @@ -5113,7 +5287,7 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type, // This is not quite trivial, because of specialization constants. // Sometimes, a raw constant is turned into an Id, and sometimes // a specialization constant expression is. -spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim, bool allowZero) +spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim, bool allowZero, bool boolType) { // First, see if this is sized with a node, meaning a specialization constant: glslang::TIntermTyped* specNode = arraySizes.getDimNode(dim); @@ -5131,7 +5305,11 @@ spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arra if (!allowZero) assert(size > 0); - return builder.makeUintConstant(size); + if (boolType) { + return builder.makeBoolConstant(size); + } else { + return builder.makeUintConstant(size); + } } // Wrap the builder's accessChainLoad to: @@ -7485,73 +7663,22 @@ spv::Id TGlslangToSpvTraverser::createUnaryMatrixOperation(spv::Op op, OpDecorat // for the signedness conversion. // destType is the final type that will be converted to, but this function // may only be doing part of that conversion. -spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType) +spv::Id TGlslangToSpvTraverser::createIntWidthConversion(spv::Id operand, int vectorSize, spv::Id destType, + glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType) { // Get the result type width, based on the type to convert to. - int width = 32; - switch(op) { - case glslang::EOpConvInt16ToUint8: - case glslang::EOpConvIntToUint8: - case glslang::EOpConvInt64ToUint8: - case glslang::EOpConvUint16ToInt8: - case glslang::EOpConvUintToInt8: - case glslang::EOpConvUint64ToInt8: - width = 8; - break; - case glslang::EOpConvInt8ToUint16: - case glslang::EOpConvIntToUint16: - case glslang::EOpConvInt64ToUint16: - case glslang::EOpConvUint8ToInt16: - case glslang::EOpConvUintToInt16: - case glslang::EOpConvUint64ToInt16: - width = 16; - break; - case glslang::EOpConvInt8ToUint: - case glslang::EOpConvInt16ToUint: - case glslang::EOpConvInt64ToUint: - case glslang::EOpConvUint8ToInt: - case glslang::EOpConvUint16ToInt: - case glslang::EOpConvUint64ToInt: - width = 32; - break; - case glslang::EOpConvInt8ToUint64: - case glslang::EOpConvInt16ToUint64: - case glslang::EOpConvIntToUint64: - case glslang::EOpConvUint8ToInt64: - case glslang::EOpConvUint16ToInt64: - case glslang::EOpConvUintToInt64: - width = 64; - break; - - default: - assert(false && "Default missing"); - break; - } + int width = GetNumBits(resultBasicType); // Get the conversion operation and result type, // based on the target width, but the source type. spv::Id type = spv::NoType; spv::Op convOp = spv::OpNop; - switch(op) { - case glslang::EOpConvInt8ToUint16: - case glslang::EOpConvInt8ToUint: - case glslang::EOpConvInt8ToUint64: - case glslang::EOpConvInt16ToUint8: - case glslang::EOpConvInt16ToUint: - case glslang::EOpConvInt16ToUint64: - case glslang::EOpConvIntToUint8: - case glslang::EOpConvIntToUint16: - case glslang::EOpConvIntToUint64: - case glslang::EOpConvInt64ToUint8: - case glslang::EOpConvInt64ToUint16: - case glslang::EOpConvInt64ToUint: + if (isTypeSignedInt(operandBasicType)) { convOp = spv::OpSConvert; type = builder.makeIntType(width); - break; - default: + } else { convOp = spv::OpUConvert; type = builder.makeUintType(width); - break; } if (vectorSize > 0) @@ -7566,7 +7693,7 @@ spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, } spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecorations& decorations, spv::Id destType, - spv::Id operand, glslang::TBasicType typeProxy) + spv::Id operand, glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType) { spv::Op convOp = spv::OpNop; spv::Id zero = 0; @@ -7574,317 +7701,124 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecora int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0; - switch (op) { - case glslang::EOpConvIntToBool: - case glslang::EOpConvUintToBool: - zero = builder.makeUintConstant(0); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); - case glslang::EOpConvFloatToBool: - zero = builder.makeFloatConstant(0.0F); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero); - case glslang::EOpConvBoolToFloat: - convOp = spv::OpSelect; - zero = builder.makeFloatConstant(0.0F); - one = builder.makeFloatConstant(1.0F); - break; - - case glslang::EOpConvBoolToInt: - case glslang::EOpConvBoolToInt64: - if (op == glslang::EOpConvBoolToInt64) { - zero = builder.makeInt64Constant(0); - one = builder.makeInt64Constant(1); - } else { - zero = builder.makeIntConstant(0); - one = builder.makeIntConstant(1); + if (IsOpNumericConv(op)) { + if (isTypeSignedInt(operandBasicType) && isTypeFloat(resultBasicType)) { + convOp = spv::OpConvertSToF; } - - convOp = spv::OpSelect; - break; - - case glslang::EOpConvBoolToUint: - case glslang::EOpConvBoolToUint64: - if (op == glslang::EOpConvBoolToUint64) { - zero = builder.makeUint64Constant(0); - one = builder.makeUint64Constant(1); - } else { - zero = builder.makeUintConstant(0); - one = builder.makeUintConstant(1); + if (isTypeUnsignedInt(operandBasicType) && isTypeFloat(resultBasicType)) { + convOp = spv::OpConvertUToF; } + if (isTypeFloat(operandBasicType) && isTypeSignedInt(resultBasicType)) { + convOp = spv::OpConvertFToS; + } + if (isTypeFloat(operandBasicType) && isTypeUnsignedInt(resultBasicType)) { + convOp = spv::OpConvertFToU; + } + if (isTypeSignedInt(operandBasicType) && isTypeSignedInt(resultBasicType)) { + convOp = spv::OpSConvert; + } + if (isTypeUnsignedInt(operandBasicType) && isTypeUnsignedInt(resultBasicType)) { + convOp = spv::OpUConvert; + } + if (isTypeFloat(operandBasicType) && isTypeFloat(resultBasicType)) { + convOp = spv::OpFConvert; + if (builder.isMatrixType(destType)) + return createUnaryMatrixOperation(convOp, decorations, destType, operand, operandBasicType); + } + if (isTypeInt(operandBasicType) && isTypeInt(resultBasicType) && + isTypeUnsignedInt(operandBasicType) != isTypeUnsignedInt(resultBasicType)) { - convOp = spv::OpSelect; - break; + if (GetNumBits(operandBasicType) != GetNumBits(resultBasicType)) { + // OpSConvert/OpUConvert + OpBitCast + operand = createIntWidthConversion(operand, vectorSize, destType, resultBasicType, operandBasicType); + } - case glslang::EOpConvInt8ToFloat16: - case glslang::EOpConvInt8ToFloat: - case glslang::EOpConvInt8ToDouble: - case glslang::EOpConvInt16ToFloat16: - case glslang::EOpConvInt16ToFloat: - case glslang::EOpConvInt16ToDouble: - case glslang::EOpConvIntToFloat16: - case glslang::EOpConvIntToFloat: - case glslang::EOpConvIntToDouble: - case glslang::EOpConvInt64ToFloat: - case glslang::EOpConvInt64ToDouble: - case glslang::EOpConvInt64ToFloat16: - convOp = spv::OpConvertSToF; - break; - - case glslang::EOpConvUint8ToFloat16: - case glslang::EOpConvUint8ToFloat: - case glslang::EOpConvUint8ToDouble: - case glslang::EOpConvUint16ToFloat16: - case glslang::EOpConvUint16ToFloat: - case glslang::EOpConvUint16ToDouble: - case glslang::EOpConvUintToFloat16: - case glslang::EOpConvUintToFloat: - case glslang::EOpConvUintToDouble: - case glslang::EOpConvUint64ToFloat: - case glslang::EOpConvUint64ToDouble: - case glslang::EOpConvUint64ToFloat16: - convOp = spv::OpConvertUToF; - break; - - case glslang::EOpConvFloat16ToInt8: - case glslang::EOpConvFloatToInt8: - case glslang::EOpConvDoubleToInt8: - case glslang::EOpConvFloat16ToInt16: - case glslang::EOpConvFloatToInt16: - case glslang::EOpConvDoubleToInt16: - case glslang::EOpConvFloat16ToInt: - case glslang::EOpConvFloatToInt: - case glslang::EOpConvDoubleToInt: - case glslang::EOpConvFloat16ToInt64: - case glslang::EOpConvFloatToInt64: - case glslang::EOpConvDoubleToInt64: - convOp = spv::OpConvertFToS; - break; - - case glslang::EOpConvUint8ToInt8: - case glslang::EOpConvInt8ToUint8: - case glslang::EOpConvUint16ToInt16: - case glslang::EOpConvInt16ToUint16: - case glslang::EOpConvUintToInt: - case glslang::EOpConvIntToUint: - case glslang::EOpConvUint64ToInt64: - case glslang::EOpConvInt64ToUint64: - if (builder.isInSpecConstCodeGenMode()) { - // Build zero scalar or vector for OpIAdd. - if(op == glslang::EOpConvUint8ToInt8 || op == glslang::EOpConvInt8ToUint8) { - zero = builder.makeUint8Constant(0); - } else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) { - zero = builder.makeUint16Constant(0); - } else if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) { - zero = builder.makeUint64Constant(0); + if (builder.isInSpecConstCodeGenMode()) { + uint32_t bits = GetNumBits(resultBasicType); + spv::Id zeroType = builder.makeUintType(bits); + if (bits == 64) { + zero = builder.makeInt64Constant(zeroType, 0, false); + } else { + zero = builder.makeIntConstant(zeroType, 0, false); + } + zero = makeSmearedConstant(zero, vectorSize); + // Use OpIAdd, instead of OpBitcast to do the conversion when + // generating for OpSpecConstantOp instruction. + return builder.createBinOp(spv::OpIAdd, destType, operand, zero); + } + // For normal run-time conversion instruction, use OpBitcast. + convOp = spv::OpBitcast; + } + if (resultBasicType == glslang::EbtBool) { + uint32_t bits = GetNumBits(operandBasicType); + if (isTypeInt(operandBasicType)) { + spv::Id zeroType = builder.makeUintType(bits); + if (bits == 64) { + zero = builder.makeInt64Constant(zeroType, 0, false); + } else { + zero = builder.makeIntConstant(zeroType, 0, false); + } + zero = makeSmearedConstant(zero, vectorSize); + return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); } else { - zero = builder.makeUintConstant(0); + assert(isTypeFloat(operandBasicType)); + if (bits == 64) { + zero = builder.makeDoubleConstant(0.0); + } else if (bits == 32) { + zero = builder.makeFloatConstant(0.0); + } else { + assert(bits == 16); + zero = builder.makeFloat16Constant(0.0); + } + zero = makeSmearedConstant(zero, vectorSize); + return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero); } - zero = makeSmearedConstant(zero, vectorSize); - // Use OpIAdd, instead of OpBitcast to do the conversion when - // generating for OpSpecConstantOp instruction. - return builder.createBinOp(spv::OpIAdd, destType, operand, zero); } - // For normal run-time conversion instruction, use OpBitcast. - convOp = spv::OpBitcast; - break; - - case glslang::EOpConvFloat16ToUint8: - case glslang::EOpConvFloatToUint8: - case glslang::EOpConvDoubleToUint8: - case glslang::EOpConvFloat16ToUint16: - case glslang::EOpConvFloatToUint16: - case glslang::EOpConvDoubleToUint16: - case glslang::EOpConvFloat16ToUint: - case glslang::EOpConvFloatToUint: - case glslang::EOpConvDoubleToUint: - case glslang::EOpConvFloatToUint64: - case glslang::EOpConvDoubleToUint64: - case glslang::EOpConvFloat16ToUint64: - convOp = spv::OpConvertFToU; - break; - - case glslang::EOpConvInt8ToBool: - case glslang::EOpConvUint8ToBool: - zero = builder.makeUint8Constant(0); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); - case glslang::EOpConvInt16ToBool: - case glslang::EOpConvUint16ToBool: - zero = builder.makeUint16Constant(0); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); - case glslang::EOpConvInt64ToBool: - case glslang::EOpConvUint64ToBool: - zero = builder.makeUint64Constant(0); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); - case glslang::EOpConvDoubleToBool: - zero = builder.makeDoubleConstant(0.0); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero); - case glslang::EOpConvFloat16ToBool: - zero = builder.makeFloat16Constant(0.0F); - zero = makeSmearedConstant(zero, vectorSize); - return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero); - case glslang::EOpConvBoolToDouble: - convOp = spv::OpSelect; - zero = builder.makeDoubleConstant(0.0); - one = builder.makeDoubleConstant(1.0); - break; - case glslang::EOpConvBoolToFloat16: - convOp = spv::OpSelect; - zero = builder.makeFloat16Constant(0.0F); - one = builder.makeFloat16Constant(1.0F); - break; - case glslang::EOpConvBoolToInt8: - zero = builder.makeInt8Constant(0); - one = builder.makeInt8Constant(1); - convOp = spv::OpSelect; - break; - case glslang::EOpConvBoolToUint8: - zero = builder.makeUint8Constant(0); - one = builder.makeUint8Constant(1); - convOp = spv::OpSelect; - break; - case glslang::EOpConvBoolToInt16: - zero = builder.makeInt16Constant(0); - one = builder.makeInt16Constant(1); - convOp = spv::OpSelect; - break; - case glslang::EOpConvBoolToUint16: - zero = builder.makeUint16Constant(0); - one = builder.makeUint16Constant(1); - convOp = spv::OpSelect; - break; - case glslang::EOpConvDoubleToFloat: - case glslang::EOpConvFloatToDouble: - case glslang::EOpConvDoubleToFloat16: - case glslang::EOpConvFloat16ToDouble: - case glslang::EOpConvFloatToFloat16: - case glslang::EOpConvFloat16ToFloat: - convOp = spv::OpFConvert; - if (builder.isMatrixType(destType)) - return createUnaryMatrixOperation(convOp, decorations, destType, operand, typeProxy); - break; - - case glslang::EOpConvInt8ToInt16: - case glslang::EOpConvInt8ToInt: - case glslang::EOpConvInt8ToInt64: - case glslang::EOpConvInt16ToInt8: - case glslang::EOpConvInt16ToInt: - case glslang::EOpConvInt16ToInt64: - case glslang::EOpConvIntToInt8: - case glslang::EOpConvIntToInt16: - case glslang::EOpConvIntToInt64: - case glslang::EOpConvInt64ToInt8: - case glslang::EOpConvInt64ToInt16: - case glslang::EOpConvInt64ToInt: - convOp = spv::OpSConvert; - break; - - case glslang::EOpConvUint8ToUint16: - case glslang::EOpConvUint8ToUint: - case glslang::EOpConvUint8ToUint64: - case glslang::EOpConvUint16ToUint8: - case glslang::EOpConvUint16ToUint: - case glslang::EOpConvUint16ToUint64: - case glslang::EOpConvUintToUint8: - case glslang::EOpConvUintToUint16: - case glslang::EOpConvUintToUint64: - case glslang::EOpConvUint64ToUint8: - case glslang::EOpConvUint64ToUint16: - case glslang::EOpConvUint64ToUint: - convOp = spv::OpUConvert; - break; - - case glslang::EOpConvInt8ToUint16: - case glslang::EOpConvInt8ToUint: - case glslang::EOpConvInt8ToUint64: - case glslang::EOpConvInt16ToUint8: - case glslang::EOpConvInt16ToUint: - case glslang::EOpConvInt16ToUint64: - case glslang::EOpConvIntToUint8: - case glslang::EOpConvIntToUint16: - case glslang::EOpConvIntToUint64: - case glslang::EOpConvInt64ToUint8: - case glslang::EOpConvInt64ToUint16: - case glslang::EOpConvInt64ToUint: - case glslang::EOpConvUint8ToInt16: - case glslang::EOpConvUint8ToInt: - case glslang::EOpConvUint8ToInt64: - case glslang::EOpConvUint16ToInt8: - case glslang::EOpConvUint16ToInt: - case glslang::EOpConvUint16ToInt64: - case glslang::EOpConvUintToInt8: - case glslang::EOpConvUintToInt16: - case glslang::EOpConvUintToInt64: - case glslang::EOpConvUint64ToInt8: - case glslang::EOpConvUint64ToInt16: - case glslang::EOpConvUint64ToInt: - // OpSConvert/OpUConvert + OpBitCast - operand = createIntWidthConversion(op, operand, vectorSize, destType); - - if (builder.isInSpecConstCodeGenMode()) { - // Build zero scalar or vector for OpIAdd. - switch(op) { - case glslang::EOpConvInt16ToUint8: - case glslang::EOpConvIntToUint8: - case glslang::EOpConvInt64ToUint8: - case glslang::EOpConvUint16ToInt8: - case glslang::EOpConvUintToInt8: - case glslang::EOpConvUint64ToInt8: - zero = builder.makeUint8Constant(0); - break; - case glslang::EOpConvInt8ToUint16: - case glslang::EOpConvIntToUint16: - case glslang::EOpConvInt64ToUint16: - case glslang::EOpConvUint8ToInt16: - case glslang::EOpConvUintToInt16: - case glslang::EOpConvUint64ToInt16: - zero = builder.makeUint16Constant(0); - break; - case glslang::EOpConvInt8ToUint: - case glslang::EOpConvInt16ToUint: - case glslang::EOpConvInt64ToUint: - case glslang::EOpConvUint8ToInt: - case glslang::EOpConvUint16ToInt: - case glslang::EOpConvUint64ToInt: - zero = builder.makeUintConstant(0); - break; - case glslang::EOpConvInt8ToUint64: - case glslang::EOpConvInt16ToUint64: - case glslang::EOpConvIntToUint64: - case glslang::EOpConvUint8ToInt64: - case glslang::EOpConvUint16ToInt64: - case glslang::EOpConvUintToInt64: - zero = builder.makeUint64Constant(0); - break; - default: - assert(false && "Default missing"); - break; + if (operandBasicType == glslang::EbtBool) { + uint32_t bits = GetNumBits(resultBasicType); + convOp = spv::OpSelect; + if (isTypeInt(resultBasicType)) { + spv::Id zeroType = isTypeSignedInt(resultBasicType) ? builder.makeIntType(bits) : builder.makeUintType(bits); + if (bits == 64) { + zero = builder.makeInt64Constant(zeroType, 0, false); + one = builder.makeInt64Constant(zeroType, 1, false); + } else { + zero = builder.makeIntConstant(zeroType, 0, false); + one = builder.makeIntConstant(zeroType, 1, false); + } + } else { + assert(isTypeFloat(resultBasicType)); + if (bits == 64) { + zero = builder.makeDoubleConstant(0.0); + one = builder.makeDoubleConstant(1.0); + } else if (bits == 32) { + zero = builder.makeFloatConstant(0.0); + one = builder.makeFloatConstant(1.0); + } else { + assert(bits == 16); + zero = builder.makeFloat16Constant(0.0); + one = builder.makeFloat16Constant(1.0); + } } - zero = makeSmearedConstant(zero, vectorSize); - // Use OpIAdd, instead of OpBitcast to do the conversion when - // generating for OpSpecConstantOp instruction. - return builder.createBinOp(spv::OpIAdd, destType, operand, zero); } - // For normal run-time conversion instruction, use OpBitcast. - convOp = spv::OpBitcast; - break; - case glslang::EOpConvUint64ToPtr: - convOp = spv::OpConvertUToPtr; - break; - case glslang::EOpConvPtrToUint64: - convOp = spv::OpConvertPtrToU; - break; - case glslang::EOpConvPtrToUvec2: - case glslang::EOpConvUvec2ToPtr: - convOp = spv::OpBitcast; - break; + } - default: - break; + if (convOp == spv::OpNop) { + switch (op) { + case glslang::EOpConvUint64ToPtr: + convOp = spv::OpConvertUToPtr; + break; + case glslang::EOpConvPtrToUint64: + convOp = spv::OpConvertPtrToU; + break; + case glslang::EOpConvPtrToUvec2: + case glslang::EOpConvUvec2ToPtr: + convOp = spv::OpBitcast; + break; + + default: + break; + } } spv::Id result = 0; @@ -8805,7 +8739,13 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: builder.promoteScalar(precision, operands.front(), operands.back()); break; case glslang::EOpModf: - libCall = spv::GLSLstd450Modf; + { + libCall = spv::GLSLstd450ModfStruct; + assert(builder.isFloatType(builder.getScalarTypeId(typeId0))); + // The returned struct has two members of the same type as the first argument + typeId = builder.makeStructResultType(typeId0, typeId0); + consumedOperands = 1; + } break; case glslang::EOpMax: if (isFloat) @@ -9373,6 +9313,34 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: addImageProcessing2QCOMDecoration(operands[0], true); addImageProcessing2QCOMDecoration(operands[2], true); break; + case glslang::EOpCreateTensorLayoutNV: + return builder.createOp(spv::OpCreateTensorLayoutNV, typeId, std::vector{}); + case glslang::EOpCreateTensorViewNV: + return builder.createOp(spv::OpCreateTensorViewNV, typeId, std::vector{}); + case glslang::EOpTensorLayoutSetBlockSizeNV: + opCode = spv::OpTensorLayoutSetBlockSizeNV; + break; + case glslang::EOpTensorLayoutSetDimensionNV: + opCode = spv::OpTensorLayoutSetDimensionNV; + break; + case glslang::EOpTensorLayoutSetStrideNV: + opCode = spv::OpTensorLayoutSetStrideNV; + break; + case glslang::EOpTensorLayoutSliceNV: + opCode = spv::OpTensorLayoutSliceNV; + break; + case glslang::EOpTensorLayoutSetClampValueNV: + opCode = spv::OpTensorLayoutSetClampValueNV; + break; + case glslang::EOpTensorViewSetDimensionNV: + opCode = spv::OpTensorViewSetDimensionNV; + break; + case glslang::EOpTensorViewSetStrideNV: + opCode = spv::OpTensorViewSetStrideNV; + break; + case glslang::EOpTensorViewSetClipNV: + opCode = spv::OpTensorViewSetClipNV; + break; default: return 0; } @@ -9428,6 +9396,13 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: builder.createStore(builder.createCompositeExtract(id, typeId0, 0), operands[3]); builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]); break; + case glslang::EOpModf: + { + assert(operands.size() == 2); + builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[1]); + id = builder.createCompositeExtract(id, typeId0, 0); + } + break; case glslang::EOpFrexp: { assert(operands.size() == 2); @@ -9672,6 +9647,10 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol } } + if (symbol->getBasicType() == glslang::EbtFunction) { + return 0; + } + id = createSpvVariable(symbol, forcedType.first); if (mayNeedToReuseBuiltIn) { @@ -10228,12 +10207,13 @@ bool TGlslangToSpvTraverser::isTrivial(const glslang::TIntermTyped* node) return false; } + if (IsOpNumericConv(node->getAsOperator()->getOp()) && + node->getType().getBasicType() == glslang::EbtBool) { + return true; + } + switch (node->getAsOperator()->getOp()) { case glslang::EOpLogicalNot: - case glslang::EOpConvIntToBool: - case glslang::EOpConvUintToBool: - case glslang::EOpConvFloatToBool: - case glslang::EOpConvDoubleToBool: case glslang::EOpEqual: case glslang::EOpNotEqual: case glslang::EOpLessThan: diff --git a/3rdparty/glslang/SPIRV/SPVRemapper.cpp b/3rdparty/glslang/SPIRV/SPVRemapper.cpp index 2ef3bf756..84527641a 100644 --- a/3rdparty/glslang/SPIRV/SPVRemapper.cpp +++ b/3rdparty/glslang/SPIRV/SPVRemapper.cpp @@ -650,6 +650,40 @@ namespace spv { case spv::OperandExecutionMode: return nextInst; + case spv::OperandMemoryAccess: + { + uint32_t mask = spv[word]; + if (mask & uint32_t(spv::MemoryAccessMask::MemoryAccessAlignedMask)) { + ++word; + --numOperands; + } + if (mask & uint32_t(spv::MemoryAccessMask::MemoryAccessMakePointerAvailableMask | + spv::MemoryAccessMask::MemoryAccessMakePointerVisibleMask)) { + idFn(asId(word+1)); + ++word; + --numOperands; + } + ++word; + } + break; + + case spv::OperandTensorAddressingOperands: + { + uint32_t mask = spv[word]; + if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorAddressingOperandsTensorViewMask)) { + idFn(asId(word+1)); + ++word; + --numOperands; + } + if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorAddressingOperandsDecodeFuncMask)) { + idFn(asId(word+1)); + ++word; + --numOperands; + } + ++word; + } + break; + // Single word operands we simply ignore, as they hold no IDs case spv::OperandLiteralNumber: case spv::OperandSource: @@ -674,7 +708,6 @@ namespace spv { case spv::OperandSelect: case spv::OperandLoop: case spv::OperandFunction: - case spv::OperandMemoryAccess: case spv::OperandGroupOperation: case spv::OperandKernelEnqueueFlags: case spv::OperandKernelProfilingInfo: diff --git a/3rdparty/glslang/SPIRV/SpvBuilder.cpp b/3rdparty/glslang/SPIRV/SpvBuilder.cpp index 500c78f99..e23ccabe4 100644 --- a/3rdparty/glslang/SPIRV/SpvBuilder.cpp +++ b/3rdparty/glslang/SPIRV/SpvBuilder.cpp @@ -3466,6 +3466,41 @@ Id Builder::createCompositeConstruct(Id typeId, const std::vector& constitue return op->getResultId(); } +// coopmat conversion +Id Builder::createCooperativeMatrixConversion(Id typeId, Id source) +{ + Instruction* op = new Instruction(getUniqueId(), typeId, OpCooperativeMatrixConvertNV); + op->addIdOperand(source); + addInstruction(std::unique_ptr(op)); + + return op->getResultId(); +} + +// coopmat reduce +Id Builder::createCooperativeMatrixReduce(Op opcode, Id typeId, Id source, unsigned int mask, Id func) +{ + Instruction* op = new Instruction(getUniqueId(), typeId, opcode); + op->addIdOperand(source); + op->addImmediateOperand(mask); + op->addIdOperand(func); + addInstruction(std::unique_ptr(op)); + + return op->getResultId(); +} + +// coopmat per-element operation +Id Builder::createCooperativeMatrixPerElementOp(Id typeId, const std::vector& operands) +{ + Instruction* op = new Instruction(getUniqueId(), typeId, spv::OpCooperativeMatrixPerElementOpNV); + // skip operand[0], which is where the result is stored + for (uint32_t i = 1; i < operands.size(); ++i) { + op->addIdOperand(operands[i]); + } + addInstruction(std::unique_ptr(op)); + + return op->getResultId(); +} + // Vector or scalar constructor Id Builder::createConstructor(Decoration precision, const std::vector& sources, Id resultTypeId) { diff --git a/3rdparty/glslang/SPIRV/SpvBuilder.h b/3rdparty/glslang/SPIRV/SpvBuilder.h index 4bae1d5c1..44377acb2 100644 --- a/3rdparty/glslang/SPIRV/SpvBuilder.h +++ b/3rdparty/glslang/SPIRV/SpvBuilder.h @@ -288,6 +288,7 @@ public: bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); } bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); } bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); } + bool isTensorView(Id resultId)const { return isTensorViewType(getTypeId(resultId)); } bool isBoolType(Id typeId) { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); } @@ -308,6 +309,7 @@ public: { return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV; } + bool isTensorViewType(Id typeId) const { return getTypeClass(typeId) == OpTypeTensorViewNV; } bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; } @@ -372,6 +374,8 @@ public: // For making new constants (will return old constant if the requested one was already made). Id makeNullConstant(Id typeId); Id makeBoolConstant(bool b, bool specConstant = false); + Id makeIntConstant(Id typeId, unsigned value, bool specConstant); + Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); Id makeInt8Constant(int i, bool specConstant = false) { return makeIntConstant(makeIntType(8), (unsigned)i, specConstant); } Id makeUint8Constant(unsigned u, bool specConstant = false) @@ -609,6 +613,11 @@ public: // matrix constructor Id createMatrixConstructor(Decoration precision, const std::vector& sources, Id constructee); + // coopmat conversion + Id createCooperativeMatrixConversion(Id typeId, Id source); + Id createCooperativeMatrixReduce(Op opcode, Id typeId, Id source, unsigned int mask, Id func); + Id createCooperativeMatrixPerElementOp(Id typeId, const std::vector& operands); + // Helper to use for building nested control flow with if-then-else. class If { public: @@ -887,8 +896,6 @@ public: void setUseReplicatedComposites(bool use) { useReplicatedComposites = use; } protected: - Id makeIntConstant(Id typeId, unsigned value, bool specConstant); - Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value); Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2); Id findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps); diff --git a/3rdparty/glslang/SPIRV/SpvTools.cpp b/3rdparty/glslang/SPIRV/SpvTools.cpp index 8cd03ef5d..a7a1a73a4 100644 --- a/3rdparty/glslang/SPIRV/SpvTools.cpp +++ b/3rdparty/glslang/SPIRV/SpvTools.cpp @@ -71,6 +71,8 @@ spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLog return spv_target_env::SPV_ENV_VULKAN_1_2; case glslang::EShTargetVulkan_1_3: return spv_target_env::SPV_ENV_VULKAN_1_3; + case glslang::EShTargetVulkan_1_4: + return spv_target_env::SPV_ENV_VULKAN_1_4; default: break; } diff --git a/3rdparty/glslang/SPIRV/disassemble.cpp b/3rdparty/glslang/SPIRV/disassemble.cpp index be364b339..606e8899d 100644 --- a/3rdparty/glslang/SPIRV/disassemble.cpp +++ b/3rdparty/glslang/SPIRV/disassemble.cpp @@ -36,6 +36,7 @@ // Disassembler for SPIR-V. // +#include #include #include #include @@ -338,6 +339,18 @@ int SpirvStream::disassembleString() return decoderes.first; } +static uint32_t popcount(uint32_t mask) +{ + uint32_t count = 0; + while (mask) { + if (mask & 1) { + count++; + } + mask >>= 1; + } + return count; +} + void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, int numOperands) { // Process the opcode @@ -552,18 +565,41 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, numOperands -= disassembleString(); return; case OperandMemoryAccess: - outputMask(OperandMemoryAccess, stream[word++]); - --numOperands; - // Aligned is the only memory access operand that uses an immediate - // value, and it is also the first operand that uses a value at all. - if (stream[word-1] & MemoryAccessAlignedMask) { - disassembleImmediates(1); - numOperands--; - if (numOperands) + { + outputMask(OperandMemoryAccess, stream[word++]); + --numOperands; + // Put a space after "None" if there are any remaining operands + if (numOperands && stream[word-1] == 0) { out << " "; + } + uint32_t mask = stream[word-1]; + // Aligned is the only memory access operand that uses an immediate + // value, and it is also the first operand that uses a value at all. + if (mask & MemoryAccessAlignedMask) { + disassembleImmediates(1); + numOperands--; + if (numOperands) + out << " "; + } + + uint32_t bitCount = popcount(mask & (MemoryAccessMakePointerAvailableMask | MemoryAccessMakePointerVisibleMask)); + disassembleIds(bitCount); + numOperands -= bitCount; } - disassembleIds(numOperands); - return; + break; + case OperandTensorAddressingOperands: + { + outputMask(OperandTensorAddressingOperands, stream[word++]); + --numOperands; + // Put a space after "None" if there are any remaining operands + if (numOperands && stream[word-1] == 0) { + out << " "; + } + uint32_t bitCount = popcount(stream[word-1]); + disassembleIds(bitCount); + numOperands -= bitCount; + } + break; default: assert(operandClass >= OperandSource && operandClass < OperandOpcode); diff --git a/3rdparty/glslang/SPIRV/doc.cpp b/3rdparty/glslang/SPIRV/doc.cpp index 2051486b8..dce8a71a9 100644 --- a/3rdparty/glslang/SPIRV/doc.cpp +++ b/3rdparty/glslang/SPIRV/doc.cpp @@ -818,6 +818,18 @@ const char* CooperativeMatrixOperandsString(int op) } } +const int TensorAddressingOperandsCeiling = 3; + +const char* TensorAddressingOperandsString(int op) +{ + switch (op) { + case TensorAddressingOperandsTensorViewShift: return "TensorView"; + case TensorAddressingOperandsDecodeFuncShift: return "DecodeFunc"; + + default: return "Bad"; + } +} + const char* ScopeString(int mem) { switch (mem) { @@ -1025,6 +1037,13 @@ const char* CapabilityString(int info) case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; + case CapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV"; + case CapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV"; + case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV"; + case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV"; + case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV"; + case CapabilityTensorAddressingNV: return "TensorAddressingNV"; + case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; case CapabilityFragmentShaderSampleInterlockEXT: return "CapabilityFragmentShaderSampleInterlockEXT"; @@ -1536,6 +1555,25 @@ const char* OpcodeString(int op) case OpDemoteToHelperInvocationEXT: return "OpDemoteToHelperInvocationEXT"; case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; + case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV"; + case OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV"; + case OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV"; + case OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV"; + case OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV"; + case OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV"; + case OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV"; + case OpTypeTensorViewNV: return "OpTypeTensorViewNV"; + case OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV"; + case OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV"; + case OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV"; + case OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV"; + case OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV"; + case OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV"; + case OpCreateTensorViewNV: return "OpCreateTensorViewNV"; + case OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV"; + case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV"; + case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV"; + case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; @@ -1613,6 +1651,7 @@ EnumParameters SelectionControlParams[SelectControlCeiling]; EnumParameters FunctionControlParams[FunctionControlCeiling]; EnumParameters MemoryAccessParams[MemoryAccessCeiling]; EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling]; +EnumParameters TensorAddressingOperandsParams[TensorAddressingOperandsCeiling]; // Set up all the parameterizing descriptions of the opcodes, operands, etc. void Parameterize() @@ -1712,6 +1751,9 @@ void Parameterize() InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false); InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false); InstructionDesc[OpAssumeTrueKHR].setResultAndType(false, false); + InstructionDesc[OpTypeTensorLayoutNV].setResultAndType(true, false); + InstructionDesc[OpTypeTensorViewNV].setResultAndType(true, false); + InstructionDesc[OpCooperativeMatrixStoreTensorNV].setResultAndType(false, false); // Specific additional context-dependent operands ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <>'"); @@ -1781,6 +1823,7 @@ void Parameterize() OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true); OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr); OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true); + OperandClassParams[OperandTensorAddressingOperands].set(TensorAddressingOperandsCeiling, TensorAddressingOperandsString, TensorAddressingOperandsParams, true); OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr); // set name of operator, an initial set of style operands, and the description @@ -3488,6 +3531,67 @@ void Parameterize() InstructionDesc[OpConstantCompositeReplicateEXT].operands.push(OperandId, "'Value'"); InstructionDesc[OpSpecConstantCompositeReplicateEXT].operands.push(OperandId, "'Value'"); InstructionDesc[OpCompositeConstructReplicateEXT].operands.push(OperandId, "'Value'"); + + InstructionDesc[OpCooperativeMatrixConvertNV].operands.push(OperandId, "'Value'"); + + InstructionDesc[OpCooperativeMatrixTransposeNV].operands.push(OperandId, "'Matrix'"); + + InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'Matrix'"); + InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandLiteralNumber, "'ReduceMask'"); + InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'CombineFunc'"); + + InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandId, "'Matrix'"); + InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandId, "'Operation'"); + InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandVariableIds, "'Operands'"); + + InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'Object'"); + InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'"); + + InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'Pointer'"); + InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'Object'"); + InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandMemoryAccess, "'Memory Access'"); + InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'"); + + InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'Matrix'"); + InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandLiteralNumber, "'ReduceMask'"); + + InstructionDesc[OpTypeTensorLayoutNV].operands.push(OperandId, "'Dim'"); + InstructionDesc[OpTypeTensorLayoutNV].operands.push(OperandId, "'ClampMode'"); + + InstructionDesc[OpTypeTensorViewNV].operands.push(OperandId, "'Dim'"); + InstructionDesc[OpTypeTensorViewNV].operands.push(OperandId, "'HasDimensions'"); + InstructionDesc[OpTypeTensorViewNV].operands.push(OperandVariableIds, "'p'"); + + InstructionDesc[OpTensorLayoutSetBlockSizeNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpTensorLayoutSetBlockSizeNV].operands.push(OperandVariableIds, "'BlockSize'"); + + InstructionDesc[OpTensorLayoutSetDimensionNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpTensorLayoutSetDimensionNV].operands.push(OperandVariableIds, "'Dim'"); + + InstructionDesc[OpTensorLayoutSetStrideNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpTensorLayoutSetStrideNV].operands.push(OperandVariableIds, "'Stride'"); + + InstructionDesc[OpTensorLayoutSliceNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpTensorLayoutSliceNV].operands.push(OperandVariableIds, "'Operands'"); + + InstructionDesc[OpTensorLayoutSetClampValueNV].operands.push(OperandId, "'TensorLayout'"); + InstructionDesc[OpTensorLayoutSetClampValueNV].operands.push(OperandId, "'Value'"); + + InstructionDesc[OpTensorViewSetDimensionNV].operands.push(OperandId, "'TensorView'"); + InstructionDesc[OpTensorViewSetDimensionNV].operands.push(OperandVariableIds, "'Dim'"); + + InstructionDesc[OpTensorViewSetStrideNV].operands.push(OperandId, "'TensorView'"); + InstructionDesc[OpTensorViewSetStrideNV].operands.push(OperandVariableIds, "'Stride'"); + + InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'TensorView'"); + InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipRowOffset'"); + InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipRowSpan'"); + InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColOffset'"); + InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColSpan'"); }); } diff --git a/3rdparty/glslang/SPIRV/doc.h b/3rdparty/glslang/SPIRV/doc.h index 521529913..8cd388a17 100644 --- a/3rdparty/glslang/SPIRV/doc.h +++ b/3rdparty/glslang/SPIRV/doc.h @@ -157,6 +157,7 @@ enum OperandClass { OperandKernelProfilingInfo, OperandCapability, OperandCooperativeMatrixOperands, + OperandTensorAddressingOperands, OperandOpcode, diff --git a/3rdparty/glslang/SPIRV/spirv.hpp b/3rdparty/glslang/SPIRV/spirv.hpp index 157fee194..0f28bb51c 100644 --- a/3rdparty/glslang/SPIRV/spirv.hpp +++ b/3rdparty/glslang/SPIRV/spirv.hpp @@ -1,19 +1,19 @@ // Copyright (c) 2014-2024 The Khronos Group Inc. -// +// // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and/or associated documentation files (the "Materials"), // to deal in the Materials without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Materials, and to permit persons to whom the // Materials are furnished to do so, subject to the following conditions: -// +// // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Materials. -// +// // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS // STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND -// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ -// +// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +// // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -27,7 +27,7 @@ // Enumeration tokens for SPIR-V, in various styles: // C, C++, C++11, JSON, Lua, Python, C#, D, Beef -// +// // - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL // - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL // - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL @@ -38,7 +38,7 @@ // - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL // - Beef will use enum classes in the Specification class located in the "Spv" namespace, // e.g.: Spv.Specification.SourceLanguage.GLSL -// +// // Some tokens act like mask values, which can be OR'd together, // while others are mutually exclusive. The mask-like ones have // "Mask" in their name, and a parallel enum that has the shift @@ -69,6 +69,11 @@ enum SourceLanguage { SourceLanguageHLSL = 5, SourceLanguageCPP_for_OpenCL = 6, SourceLanguageSYCL = 7, + SourceLanguageHERO_C = 8, + SourceLanguageNZSL = 9, + SourceLanguageWGSL = 10, + SourceLanguageSlang = 11, + SourceLanguageZig = 12, SourceLanguageMax = 0x7fffffff, }; @@ -168,6 +173,12 @@ enum ExecutionMode { ExecutionModeRoundingModeRTZ = 4463, ExecutionModeEarlyAndLateFragmentTestsAMD = 5017, ExecutionModeStencilRefReplacingEXT = 5027, + ExecutionModeCoalescingAMDX = 5069, + ExecutionModeIsApiEntryAMDX = 5070, + ExecutionModeMaxNodeRecursionAMDX = 5071, + ExecutionModeStaticNumWorkgroupsAMDX = 5072, + ExecutionModeShaderIndexAMDX = 5073, + ExecutionModeMaxNumWorkgroupsAMDX = 5077, ExecutionModeStencilRefUnchangedFrontAMD = 5079, ExecutionModeStencilRefGreaterFrontAMD = 5080, ExecutionModeStencilRefLessFrontAMD = 5081, @@ -176,11 +187,14 @@ enum ExecutionMode { ExecutionModeStencilRefLessBackAMD = 5084, ExecutionModeQuadDerivativesKHR = 5088, ExecutionModeRequireFullQuadsKHR = 5089, + ExecutionModeSharesInputWithAMDX = 5102, ExecutionModeOutputLinesEXT = 5269, ExecutionModeOutputLinesNV = 5269, ExecutionModeOutputPrimitivesEXT = 5270, ExecutionModeOutputPrimitivesNV = 5270, + ExecutionModeDerivativeGroupQuadsKHR = 5289, ExecutionModeDerivativeGroupQuadsNV = 5289, + ExecutionModeDerivativeGroupLinearKHR = 5290, ExecutionModeDerivativeGroupLinearNV = 5290, ExecutionModeOutputTrianglesEXT = 5298, ExecutionModeOutputTrianglesNV = 5298, @@ -201,8 +215,13 @@ enum ExecutionMode { ExecutionModeNumSIMDWorkitemsINTEL = 5896, ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903, ExecutionModeMaximallyReconvergesKHR = 6023, + ExecutionModeFPFastMathDefault = 6028, ExecutionModeStreamingInterfaceINTEL = 6154, + ExecutionModeRegisterMapInterfaceINTEL = 6160, ExecutionModeNamedBarrierCountINTEL = 6417, + ExecutionModeMaximumRegistersINTEL = 6461, + ExecutionModeMaximumRegistersIdINTEL = 6462, + ExecutionModeNamedMaximumRegistersINTEL = 6463, ExecutionModeMax = 0x7fffffff, }; @@ -221,6 +240,7 @@ enum StorageClass { StorageClassImage = 11, StorageClassStorageBuffer = 12, StorageClassTileImageEXT = 4172, + StorageClassNodePayloadAMDX = 5068, StorageClassCallableDataKHR = 5328, StorageClassCallableDataNV = 5328, StorageClassIncomingCallableDataKHR = 5329, @@ -358,6 +378,9 @@ enum ImageChannelDataType { ImageChannelDataTypeFloat = 14, ImageChannelDataTypeUnormInt24 = 15, ImageChannelDataTypeUnormInt101010_2 = 16, + ImageChannelDataTypeUnsignedIntRaw10EXT = 19, + ImageChannelDataTypeUnsignedIntRaw12EXT = 20, + ImageChannelDataTypeUnormInt2_101010EXT = 21, ImageChannelDataTypeMax = 0x7fffffff, }; @@ -415,8 +438,11 @@ enum FPFastMathModeShift { FPFastMathModeNSZShift = 2, FPFastMathModeAllowRecipShift = 3, FPFastMathModeFastShift = 4, + FPFastMathModeAllowContractShift = 16, FPFastMathModeAllowContractFastINTELShift = 16, + FPFastMathModeAllowReassocShift = 17, FPFastMathModeAllowReassocINTELShift = 17, + FPFastMathModeAllowTransformShift = 18, FPFastMathModeMax = 0x7fffffff, }; @@ -427,8 +453,11 @@ enum FPFastMathModeMask : unsigned { FPFastMathModeNSZMask = 0x00000004, FPFastMathModeAllowRecipMask = 0x00000008, FPFastMathModeFastMask = 0x00000010, + FPFastMathModeAllowContractMask = 0x00010000, FPFastMathModeAllowContractFastINTELMask = 0x00010000, + FPFastMathModeAllowReassocMask = 0x00020000, FPFastMathModeAllowReassocINTELMask = 0x00020000, + FPFastMathModeAllowTransformMask = 0x00040000, }; enum FPRoundingMode { @@ -520,6 +549,14 @@ enum Decoration { DecorationBlockMatchTextureQCOM = 4488, DecorationBlockMatchSamplerQCOM = 4499, DecorationExplicitInterpAMD = 4999, + DecorationNodeSharesPayloadLimitsWithAMDX = 5019, + DecorationNodeMaxPayloadsAMDX = 5020, + DecorationTrackFinishWritingAMDX = 5078, + DecorationPayloadNodeNameAMDX = 5091, + DecorationPayloadNodeBaseIndexAMDX = 5098, + DecorationPayloadNodeSparseArrayAMDX = 5099, + DecorationPayloadNodeArraySizeAMDX = 5100, + DecorationPayloadDispatchIndirectAMDX = 5105, DecorationOverrideCoverageNV = 5248, DecorationPassthroughNV = 5250, DecorationViewportRelativeNV = 5252, @@ -569,6 +606,9 @@ enum Decoration { DecorationMergeINTEL = 5834, DecorationBankBitsINTEL = 5835, DecorationForcePow2DepthINTEL = 5836, + DecorationStridesizeINTEL = 5883, + DecorationWordsizeINTEL = 5884, + DecorationTrueDualPortINTEL = 5885, DecorationBurstCoalesceINTEL = 5899, DecorationCacheSizeINTEL = 5900, DecorationDontStaticallyCoalesceINTEL = 5901, @@ -587,6 +627,10 @@ enum Decoration { DecorationSingleElementVectorINTEL = 6085, DecorationVectorComputeCallableFunctionINTEL = 6087, DecorationMediaBlockIOINTEL = 6140, + DecorationStallFreeINTEL = 6151, + DecorationFPMaxErrorDecorationINTEL = 6170, + DecorationLatencyControlLabelINTEL = 6172, + DecorationLatencyControlConstraintINTEL = 6173, DecorationConduitKernelArgumentINTEL = 6175, DecorationRegisterMapKernelArgumentINTEL = 6176, DecorationMMHostInterfaceAddressWidthINTEL = 6177, @@ -596,6 +640,11 @@ enum Decoration { DecorationMMHostInterfaceMaxBurstINTEL = 6181, DecorationMMHostInterfaceWaitRequestINTEL = 6182, DecorationStableKernelArgumentINTEL = 6183, + DecorationHostAccessINTEL = 6188, + DecorationInitModeINTEL = 6190, + DecorationImplementInRegisterMapINTEL = 6191, + DecorationCacheControlLoadINTEL = 6442, + DecorationCacheControlStoreINTEL = 6443, DecorationMax = 0x7fffffff, }; @@ -671,6 +720,8 @@ enum BuiltIn { BuiltInBaryCoordSmoothSampleAMD = 4997, BuiltInBaryCoordPullModelAMD = 4998, BuiltInFragStencilRefEXT = 5014, + BuiltInRemainingRecursionLevelsAMDX = 5021, + BuiltInShaderIndexAMDX = 5073, BuiltInViewportMaskNV = 5253, BuiltInSecondaryPositionNV = 5257, BuiltInSecondaryViewportMaskNV = 5258, @@ -802,6 +853,7 @@ enum FunctionControlShift { FunctionControlDontInlineShift = 1, FunctionControlPureShift = 2, FunctionControlConstShift = 3, + FunctionControlOptNoneEXTShift = 16, FunctionControlOptNoneINTELShift = 16, FunctionControlMax = 0x7fffffff, }; @@ -812,6 +864,7 @@ enum FunctionControlMask : unsigned { FunctionControlDontInlineMask = 0x00000002, FunctionControlPureMask = 0x00000004, FunctionControlConstMask = 0x00000008, + FunctionControlOptNoneEXTMask = 0x00010000, FunctionControlOptNoneINTELMask = 0x00010000, }; @@ -1032,6 +1085,7 @@ enum Capability { CapabilityRoundingModeRTZ = 4468, CapabilityRayQueryProvisionalKHR = 4471, CapabilityRayQueryKHR = 4472, + CapabilityUntypedPointersKHR = 4473, CapabilityRayTraversalPrimitiveCullingKHR = 4478, CapabilityRayTracingKHR = 4479, CapabilityTextureSampleWeightedQCOM = 4484, @@ -1045,6 +1099,7 @@ enum Capability { CapabilityImageReadWriteLodAMD = 5015, CapabilityInt64ImageEXT = 5016, CapabilityShaderClockKHR = 5055, + CapabilityShaderEnqueueAMDX = 5067, CapabilityQuadControlKHR = 5087, CapabilitySampleMaskOverrideCoverageNV = 5249, CapabilityGeometryShaderPassthroughNV = 5251, @@ -1059,6 +1114,7 @@ enum Capability { CapabilityMeshShadingEXT = 5283, CapabilityFragmentBarycentricKHR = 5284, CapabilityFragmentBarycentricNV = 5284, + CapabilityComputeDerivativeGroupQuadsKHR = 5288, CapabilityComputeDerivativeGroupQuadsNV = 5288, CapabilityFragmentDensityEXT = 5291, CapabilityShadingRateNV = 5291, @@ -1096,6 +1152,7 @@ enum Capability { CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, CapabilityPhysicalStorageBufferAddresses = 5347, CapabilityPhysicalStorageBufferAddressesEXT = 5347, + CapabilityComputeDerivativeGroupLinearKHR = 5350, CapabilityComputeDerivativeGroupLinearNV = 5350, CapabilityRayTracingProvisionalKHR = 5353, CapabilityCooperativeMatrixNV = 5357, @@ -1112,6 +1169,13 @@ enum Capability { CapabilityRayQueryPositionFetchKHR = 5391, CapabilityAtomicFloat16VectorNV = 5404, CapabilityRayTracingDisplacementMicromapNV = 5409, + CapabilityRawAccessChainsNV = 5414, + CapabilityCooperativeMatrixReductionsNV = 5430, + CapabilityCooperativeMatrixConversionsNV = 5431, + CapabilityCooperativeMatrixPerElementOperationsNV = 5432, + CapabilityCooperativeMatrixTensorAddressingNV = 5433, + CapabilityCooperativeMatrixBlockLoadsNV = 5434, + CapabilityTensorAddressingNV = 5439, CapabilitySubgroupShuffleINTEL = 5568, CapabilitySubgroupBufferBlockIOINTEL = 5569, CapabilitySubgroupImageBlockIOINTEL = 5570, @@ -1167,15 +1231,29 @@ enum Capability { CapabilityReplicatedCompositesEXT = 6024, CapabilityBitInstructions = 6025, CapabilityGroupNonUniformRotateKHR = 6026, + CapabilityFloatControls2 = 6029, CapabilityAtomicFloat32AddEXT = 6033, CapabilityAtomicFloat64AddEXT = 6034, - CapabilityLongConstantCompositeINTEL = 6089, + CapabilityLongCompositesINTEL = 6089, + CapabilityOptNoneEXT = 6094, CapabilityOptNoneINTEL = 6094, CapabilityAtomicFloat16AddEXT = 6095, CapabilityDebugInfoModuleINTEL = 6114, + CapabilityBFloat16ConversionINTEL = 6115, CapabilitySplitBarrierINTEL = 6141, + CapabilityArithmeticFenceEXT = 6144, + CapabilityFPGAClusterAttributesV2INTEL = 6150, + CapabilityFPGAKernelAttributesv2INTEL = 6161, + CapabilityFPMaxErrorINTEL = 6169, + CapabilityFPGALatencyControlINTEL = 6171, CapabilityFPGAArgumentInterfacesINTEL = 6174, + CapabilityGlobalVariableHostAccessINTEL = 6187, + CapabilityGlobalVariableFPGADecorationsINTEL = 6189, + CapabilitySubgroupBufferPrefetchINTEL = 6220, CapabilityGroupUniformArithmeticKHR = 6400, + CapabilityMaskedGatherScatterINTEL = 6427, + CapabilityCacheControlsINTEL = 6441, + CapabilityRegisterLimitsINTEL = 6460, CapabilityMax = 0x7fffffff, }; @@ -1315,6 +1393,93 @@ enum CooperativeMatrixUse { CooperativeMatrixUseMax = 0x7fffffff, }; +enum CooperativeMatrixReduceShift { + CooperativeMatrixReduceRowShift = 0, + CooperativeMatrixReduceColumnShift = 1, + CooperativeMatrixReduce2x2Shift = 2, + CooperativeMatrixReduceMax = 0x7fffffff, +}; + +enum CooperativeMatrixReduceMask : unsigned { + CooperativeMatrixReduceMaskNone = 0, + CooperativeMatrixReduceRowMask = 0x00000001, + CooperativeMatrixReduceColumnMask = 0x00000002, + CooperativeMatrixReduce2x2Mask = 0x00000004, +}; + +enum TensorClampMode { + TensorClampModeUndefined = 0, + TensorClampModeConstant = 1, + TensorClampModeClampToEdge = 2, + TensorClampModeRepeat = 3, + TensorClampModeRepeatMirrored = 4, + TensorClampModeMax = 0x7fffffff, +}; + +enum TensorAddressingOperandsShift { + TensorAddressingOperandsTensorViewShift = 0, + TensorAddressingOperandsDecodeFuncShift = 1, + TensorAddressingOperandsMax = 0x7fffffff, +}; + +enum TensorAddressingOperandsMask : unsigned { + TensorAddressingOperandsMaskNone = 0, + TensorAddressingOperandsTensorViewMask = 0x00000001, + TensorAddressingOperandsDecodeFuncMask = 0x00000002, +}; + +enum InitializationModeQualifier { + InitializationModeQualifierInitOnDeviceReprogramINTEL = 0, + InitializationModeQualifierInitOnDeviceResetINTEL = 1, + InitializationModeQualifierMax = 0x7fffffff, +}; + +enum HostAccessQualifier { + HostAccessQualifierNoneINTEL = 0, + HostAccessQualifierReadINTEL = 1, + HostAccessQualifierWriteINTEL = 2, + HostAccessQualifierReadWriteINTEL = 3, + HostAccessQualifierMax = 0x7fffffff, +}; + +enum LoadCacheControl { + LoadCacheControlUncachedINTEL = 0, + LoadCacheControlCachedINTEL = 1, + LoadCacheControlStreamingINTEL = 2, + LoadCacheControlInvalidateAfterReadINTEL = 3, + LoadCacheControlConstCachedINTEL = 4, + LoadCacheControlMax = 0x7fffffff, +}; + +enum StoreCacheControl { + StoreCacheControlUncachedINTEL = 0, + StoreCacheControlWriteThroughINTEL = 1, + StoreCacheControlWriteBackINTEL = 2, + StoreCacheControlStreamingINTEL = 3, + StoreCacheControlMax = 0x7fffffff, +}; + +enum NamedMaximumNumberOfRegisters { + NamedMaximumNumberOfRegistersAutoINTEL = 0, + NamedMaximumNumberOfRegistersMax = 0x7fffffff, +}; + +enum RawAccessChainOperandsShift { + RawAccessChainOperandsRobustnessPerComponentNVShift = 0, + RawAccessChainOperandsRobustnessPerElementNVShift = 1, + RawAccessChainOperandsMax = 0x7fffffff, +}; + +enum RawAccessChainOperandsMask : unsigned { + RawAccessChainOperandsMaskNone = 0, + RawAccessChainOperandsRobustnessPerComponentNVMask = 0x00000001, + RawAccessChainOperandsRobustnessPerElementNVMask = 0x00000002, +}; + +enum FPEncoding { + FPEncodingMax = 0x7fffffff, +}; + enum Op { OpNop = 0, OpUndef = 1, @@ -1664,8 +1829,16 @@ enum Op { OpDepthAttachmentReadEXT = 4161, OpStencilAttachmentReadEXT = 4162, OpTerminateInvocation = 4416, + OpTypeUntypedPointerKHR = 4417, + OpUntypedVariableKHR = 4418, + OpUntypedAccessChainKHR = 4419, + OpUntypedInBoundsAccessChainKHR = 4420, OpSubgroupBallotKHR = 4421, OpSubgroupFirstInvocationKHR = 4422, + OpUntypedPtrAccessChainKHR = 4423, + OpUntypedInBoundsPtrAccessChainKHR = 4424, + OpUntypedArrayLengthKHR = 4425, + OpUntypedPrefetchKHR = 4426, OpSubgroupAllKHR = 4428, OpSubgroupAnyKHR = 4429, OpSubgroupAllEqualKHR = 4430, @@ -1723,6 +1896,14 @@ enum Op { OpFragmentMaskFetchAMD = 5011, OpFragmentFetchAMD = 5012, OpReadClockKHR = 5056, + OpAllocateNodePayloadsAMDX = 5074, + OpEnqueueNodePayloadsAMDX = 5075, + OpTypeNodePayloadArrayAMDX = 5076, + OpFinishWritingNodePayloadAMDX = 5078, + OpNodePayloadArrayLengthAMDX = 5090, + OpIsNodePayloadValidAMDX = 5101, + OpConstantStringAMDX = 5103, + OpSpecConstantStringAMDX = 5104, OpGroupNonUniformQuadAllKHR = 5110, OpGroupNonUniformQuadAnyKHR = 5111, OpHitObjectRecordHitMotionNV = 5249, @@ -1759,6 +1940,7 @@ enum Op { OpReorderThreadWithHintNV = 5280, OpTypeHitObjectNV = 5281, OpImageSampleFootprintNV = 5283, + OpCooperativeMatrixConvertNV = 5293, OpEmitMeshTasksEXT = 5294, OpSetMeshOutputsEXT = 5295, OpGroupNonUniformPartitionNV = 5296, @@ -1783,9 +1965,26 @@ enum Op { OpCooperativeMatrixLengthNV = 5362, OpBeginInvocationInterlockEXT = 5364, OpEndInvocationInterlockEXT = 5365, + OpCooperativeMatrixReduceNV = 5366, + OpCooperativeMatrixLoadTensorNV = 5367, + OpCooperativeMatrixStoreTensorNV = 5368, + OpCooperativeMatrixPerElementOpNV = 5369, + OpTypeTensorLayoutNV = 5370, + OpTypeTensorViewNV = 5371, + OpCreateTensorLayoutNV = 5372, + OpTensorLayoutSetDimensionNV = 5373, + OpTensorLayoutSetStrideNV = 5374, + OpTensorLayoutSliceNV = 5375, + OpTensorLayoutSetClampValueNV = 5376, + OpCreateTensorViewNV = 5377, + OpTensorViewSetDimensionNV = 5378, + OpTensorViewSetStrideNV = 5379, OpDemoteToHelperInvocation = 5380, OpDemoteToHelperInvocationEXT = 5380, OpIsHelperInvocationEXT = 5381, + OpTensorViewSetClipNV = 5382, + OpTensorLayoutSetBlockSizeNV = 5384, + OpCooperativeMatrixTransposeNV = 5390, OpConvertUToImageNV = 5391, OpConvertUToSamplerNV = 5392, OpConvertImageToUNV = 5393, @@ -1793,6 +1992,7 @@ enum Op { OpConvertUToSampledImageNV = 5395, OpConvertSampledImageToUNV = 5396, OpSamplerImageAddressingModeNV = 5397, + OpRawAccessChainNV = 5398, OpSubgroupShuffleINTEL = 5571, OpSubgroupShuffleDownINTEL = 5572, OpSubgroupShuffleUpINTEL = 5573, @@ -2034,8 +2234,13 @@ enum Op { OpTypeStructContinuedINTEL = 6090, OpConstantCompositeContinuedINTEL = 6091, OpSpecConstantCompositeContinuedINTEL = 6092, + OpCompositeConstructContinuedINTEL = 6096, + OpConvertFToBF16INTEL = 6116, + OpConvertBF16ToFINTEL = 6117, OpControlBarrierArriveINTEL = 6142, OpControlBarrierWaitINTEL = 6143, + OpArithmeticFenceEXT = 6145, + OpSubgroupBlockPrefetchINTEL = 6221, OpGroupIMulKHR = 6401, OpGroupFMulKHR = 6402, OpGroupBitwiseAndKHR = 6403, @@ -2044,6 +2249,8 @@ enum Op { OpGroupLogicalAndKHR = 6406, OpGroupLogicalOrKHR = 6407, OpGroupLogicalXorKHR = 6408, + OpMaskedGatherINTEL = 6428, + OpMaskedScatterINTEL = 6429, OpMax = 0x7fffffff, }; @@ -2399,18 +2606,26 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpPtrEqual: *hasResult = true; *hasResultType = true; break; case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; case OpPtrDiff: *hasResult = true; *hasResultType = true; break; - case OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; case OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break; + case OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; + case OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedAccessChainKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedInBoundsAccessChainKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break; + case OpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break; case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break; case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; @@ -2456,6 +2671,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; case OpReadClockKHR: *hasResult = true; *hasResultType = true; break; + case OpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break; + case OpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break; + case OpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break; + case OpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break; + case OpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break; + case OpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break; + case OpConstantStringAMDX: *hasResult = true; *hasResultType = false; break; + case OpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break; case OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break; case OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break; case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break; @@ -2492,18 +2715,21 @@ 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 OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break; case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break; case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break; case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; - case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; + case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; + case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; + case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; case OpTraceNV: *hasResult = false; *hasResultType = false; break; case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break; case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; - case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; + case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; @@ -2512,8 +2738,25 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break; + case OpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break; + case OpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break; + case OpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break; + case OpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break; + case OpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break; + case OpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break; + case OpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break; + case OpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break; + case OpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break; + case OpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break; case OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break; case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; + case OpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break; + case OpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixTransposeNV: *hasResult = true; *hasResultType = true; break; case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break; case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break; case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break; @@ -2521,6 +2764,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break; case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break; case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break; + case OpRawAccessChainNV: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; @@ -2760,8 +3004,13 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break; case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break; case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break; + case OpCompositeConstructContinuedINTEL: *hasResult = true; *hasResultType = true; break; + case OpConvertFToBF16INTEL: *hasResult = true; *hasResultType = true; break; + case OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break; case OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break; case OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break; + case OpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break; case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break; case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break; case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break; @@ -2770,22 +3019,1856 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break; case OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break; case OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break; + case OpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break; + case OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; } } - -inline const char* ScopeToString(Scope value) { - switch (value) { - case ScopeCrossDevice: return "CrossDevice"; - case ScopeDevice: return "Device"; - case ScopeWorkgroup: return "Workgroup"; - case ScopeSubgroup: return "Subgroup"; - case ScopeInvocation: return "Invocation"; - case ScopeQueueFamily: return "QueueFamily"; - case ScopeShaderCallKHR: return "ShaderCallKHR"; - default: return "Unknown"; - } -} - +inline const char* SourceLanguageToString(SourceLanguage value) { + switch (value) { + case SourceLanguageUnknown: return "Unknown"; + case SourceLanguageESSL: return "ESSL"; + case SourceLanguageGLSL: return "GLSL"; + case SourceLanguageOpenCL_C: return "OpenCL_C"; + case SourceLanguageOpenCL_CPP: return "OpenCL_CPP"; + case SourceLanguageHLSL: return "HLSL"; + case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; + case SourceLanguageSYCL: return "SYCL"; + case SourceLanguageHERO_C: return "HERO_C"; + case SourceLanguageNZSL: return "NZSL"; + case SourceLanguageWGSL: return "WGSL"; + case SourceLanguageSlang: return "Slang"; + case SourceLanguageZig: return "Zig"; + default: return "Unknown"; + } +} + +inline const char* ExecutionModelToString(ExecutionModel value) { + switch (value) { + case ExecutionModelVertex: return "Vertex"; + case ExecutionModelTessellationControl: return "TessellationControl"; + case ExecutionModelTessellationEvaluation: return "TessellationEvaluation"; + case ExecutionModelGeometry: return "Geometry"; + case ExecutionModelFragment: return "Fragment"; + case ExecutionModelGLCompute: return "GLCompute"; + case ExecutionModelKernel: return "Kernel"; + case ExecutionModelTaskNV: return "TaskNV"; + case ExecutionModelMeshNV: return "MeshNV"; + case ExecutionModelRayGenerationKHR: return "RayGenerationKHR"; + case ExecutionModelIntersectionKHR: return "IntersectionKHR"; + case ExecutionModelAnyHitKHR: return "AnyHitKHR"; + case ExecutionModelClosestHitKHR: return "ClosestHitKHR"; + case ExecutionModelMissKHR: return "MissKHR"; + case ExecutionModelCallableKHR: return "CallableKHR"; + case ExecutionModelTaskEXT: return "TaskEXT"; + case ExecutionModelMeshEXT: return "MeshEXT"; + default: return "Unknown"; + } +} + +inline const char* AddressingModelToString(AddressingModel value) { + switch (value) { + case AddressingModelLogical: return "Logical"; + case AddressingModelPhysical32: return "Physical32"; + case AddressingModelPhysical64: return "Physical64"; + case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; + default: return "Unknown"; + } +} + +inline const char* MemoryModelToString(MemoryModel value) { + switch (value) { + case MemoryModelSimple: return "Simple"; + case MemoryModelGLSL450: return "GLSL450"; + case MemoryModelOpenCL: return "OpenCL"; + case MemoryModelVulkan: return "Vulkan"; + default: return "Unknown"; + } +} + +inline const char* ExecutionModeToString(ExecutionMode value) { + switch (value) { + case ExecutionModeInvocations: return "Invocations"; + case ExecutionModeSpacingEqual: return "SpacingEqual"; + case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; + case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; + case ExecutionModeVertexOrderCw: return "VertexOrderCw"; + case ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; + case ExecutionModePixelCenterInteger: return "PixelCenterInteger"; + case ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; + case ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; + case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; + case ExecutionModePointMode: return "PointMode"; + case ExecutionModeXfb: return "Xfb"; + case ExecutionModeDepthReplacing: return "DepthReplacing"; + case ExecutionModeDepthGreater: return "DepthGreater"; + case ExecutionModeDepthLess: return "DepthLess"; + case ExecutionModeDepthUnchanged: return "DepthUnchanged"; + case ExecutionModeLocalSize: return "LocalSize"; + case ExecutionModeLocalSizeHint: return "LocalSizeHint"; + case ExecutionModeInputPoints: return "InputPoints"; + case ExecutionModeInputLines: return "InputLines"; + case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; + case ExecutionModeTriangles: return "Triangles"; + case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; + case ExecutionModeQuads: return "Quads"; + case ExecutionModeIsolines: return "Isolines"; + case ExecutionModeOutputVertices: return "OutputVertices"; + case ExecutionModeOutputPoints: return "OutputPoints"; + case ExecutionModeOutputLineStrip: return "OutputLineStrip"; + case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; + case ExecutionModeVecTypeHint: return "VecTypeHint"; + case ExecutionModeContractionOff: return "ContractionOff"; + case ExecutionModeInitializer: return "Initializer"; + case ExecutionModeFinalizer: return "Finalizer"; + case ExecutionModeSubgroupSize: return "SubgroupSize"; + case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; + case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; + case ExecutionModeLocalSizeId: return "LocalSizeId"; + case ExecutionModeLocalSizeHintId: return "LocalSizeHintId"; + case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; + case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; + case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; + case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; + case ExecutionModePostDepthCoverage: return "PostDepthCoverage"; + case ExecutionModeDenormPreserve: return "DenormPreserve"; + case ExecutionModeDenormFlushToZero: return "DenormFlushToZero"; + case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; + case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; + case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; + case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; + case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; + case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; + case ExecutionModeIsApiEntryAMDX: return "IsApiEntryAMDX"; + case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; + case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; + case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; + case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; + case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; + case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; + case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; + case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; + case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; + case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; + case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; + case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; + case ExecutionModeSharesInputWithAMDX: return "SharesInputWithAMDX"; + case ExecutionModeOutputLinesEXT: return "OutputLinesEXT"; + case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; + case ExecutionModeDerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR"; + case ExecutionModeDerivativeGroupLinearKHR: return "DerivativeGroupLinearKHR"; + case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; + case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; + case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; + case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; + case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; + case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; + case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; + case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; + case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; + case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; + case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; + case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; + case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; + case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; + case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; + case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; + case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; + case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; + case ExecutionModeFPFastMathDefault: return "FPFastMathDefault"; + case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; + case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; + case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; + case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; + case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; + case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; + default: return "Unknown"; + } +} + +inline const char* StorageClassToString(StorageClass value) { + switch (value) { + case StorageClassUniformConstant: return "UniformConstant"; + case StorageClassInput: return "Input"; + case StorageClassUniform: return "Uniform"; + case StorageClassOutput: return "Output"; + case StorageClassWorkgroup: return "Workgroup"; + case StorageClassCrossWorkgroup: return "CrossWorkgroup"; + case StorageClassPrivate: return "Private"; + case StorageClassFunction: return "Function"; + case StorageClassGeneric: return "Generic"; + case StorageClassPushConstant: return "PushConstant"; + case StorageClassAtomicCounter: return "AtomicCounter"; + case StorageClassImage: return "Image"; + case StorageClassStorageBuffer: return "StorageBuffer"; + case StorageClassTileImageEXT: return "TileImageEXT"; + case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; + case StorageClassCallableDataKHR: return "CallableDataKHR"; + case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; + case StorageClassRayPayloadKHR: return "RayPayloadKHR"; + case StorageClassHitAttributeKHR: return "HitAttributeKHR"; + case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; + case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; + case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; + case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; + case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; + case StorageClassCodeSectionINTEL: return "CodeSectionINTEL"; + case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; + case StorageClassHostOnlyINTEL: return "HostOnlyINTEL"; + default: return "Unknown"; + } +} + +inline const char* DimToString(Dim value) { + switch (value) { + case Dim1D: return "1D"; + case Dim2D: return "2D"; + case Dim3D: return "3D"; + case DimCube: return "Cube"; + case DimRect: return "Rect"; + case DimBuffer: return "Buffer"; + case DimSubpassData: return "SubpassData"; + case DimTileImageDataEXT: return "TileImageDataEXT"; + default: return "Unknown"; + } +} + +inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) { + switch (value) { + case SamplerAddressingModeNone: return "None"; + case SamplerAddressingModeClampToEdge: return "ClampToEdge"; + case SamplerAddressingModeClamp: return "Clamp"; + case SamplerAddressingModeRepeat: return "Repeat"; + case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; + default: return "Unknown"; + } +} + +inline const char* SamplerFilterModeToString(SamplerFilterMode value) { + switch (value) { + case SamplerFilterModeNearest: return "Nearest"; + case SamplerFilterModeLinear: return "Linear"; + default: return "Unknown"; + } +} + +inline const char* ImageFormatToString(ImageFormat value) { + switch (value) { + case ImageFormatUnknown: return "Unknown"; + case ImageFormatRgba32f: return "Rgba32f"; + case ImageFormatRgba16f: return "Rgba16f"; + case ImageFormatR32f: return "R32f"; + case ImageFormatRgba8: return "Rgba8"; + case ImageFormatRgba8Snorm: return "Rgba8Snorm"; + case ImageFormatRg32f: return "Rg32f"; + case ImageFormatRg16f: return "Rg16f"; + case ImageFormatR11fG11fB10f: return "R11fG11fB10f"; + case ImageFormatR16f: return "R16f"; + case ImageFormatRgba16: return "Rgba16"; + case ImageFormatRgb10A2: return "Rgb10A2"; + case ImageFormatRg16: return "Rg16"; + case ImageFormatRg8: return "Rg8"; + case ImageFormatR16: return "R16"; + case ImageFormatR8: return "R8"; + case ImageFormatRgba16Snorm: return "Rgba16Snorm"; + case ImageFormatRg16Snorm: return "Rg16Snorm"; + case ImageFormatRg8Snorm: return "Rg8Snorm"; + case ImageFormatR16Snorm: return "R16Snorm"; + case ImageFormatR8Snorm: return "R8Snorm"; + case ImageFormatRgba32i: return "Rgba32i"; + case ImageFormatRgba16i: return "Rgba16i"; + case ImageFormatRgba8i: return "Rgba8i"; + case ImageFormatR32i: return "R32i"; + case ImageFormatRg32i: return "Rg32i"; + case ImageFormatRg16i: return "Rg16i"; + case ImageFormatRg8i: return "Rg8i"; + case ImageFormatR16i: return "R16i"; + case ImageFormatR8i: return "R8i"; + case ImageFormatRgba32ui: return "Rgba32ui"; + case ImageFormatRgba16ui: return "Rgba16ui"; + case ImageFormatRgba8ui: return "Rgba8ui"; + case ImageFormatR32ui: return "R32ui"; + case ImageFormatRgb10a2ui: return "Rgb10a2ui"; + case ImageFormatRg32ui: return "Rg32ui"; + case ImageFormatRg16ui: return "Rg16ui"; + case ImageFormatRg8ui: return "Rg8ui"; + case ImageFormatR16ui: return "R16ui"; + case ImageFormatR8ui: return "R8ui"; + case ImageFormatR64ui: return "R64ui"; + case ImageFormatR64i: return "R64i"; + default: return "Unknown"; + } +} + +inline const char* ImageChannelOrderToString(ImageChannelOrder value) { + switch (value) { + case ImageChannelOrderR: return "R"; + case ImageChannelOrderA: return "A"; + case ImageChannelOrderRG: return "RG"; + case ImageChannelOrderRA: return "RA"; + case ImageChannelOrderRGB: return "RGB"; + case ImageChannelOrderRGBA: return "RGBA"; + case ImageChannelOrderBGRA: return "BGRA"; + case ImageChannelOrderARGB: return "ARGB"; + case ImageChannelOrderIntensity: return "Intensity"; + case ImageChannelOrderLuminance: return "Luminance"; + case ImageChannelOrderRx: return "Rx"; + case ImageChannelOrderRGx: return "RGx"; + case ImageChannelOrderRGBx: return "RGBx"; + case ImageChannelOrderDepth: return "Depth"; + case ImageChannelOrderDepthStencil: return "DepthStencil"; + case ImageChannelOrdersRGB: return "sRGB"; + case ImageChannelOrdersRGBx: return "sRGBx"; + case ImageChannelOrdersRGBA: return "sRGBA"; + case ImageChannelOrdersBGRA: return "sBGRA"; + case ImageChannelOrderABGR: return "ABGR"; + default: return "Unknown"; + } +} + +inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) { + switch (value) { + case ImageChannelDataTypeSnormInt8: return "SnormInt8"; + case ImageChannelDataTypeSnormInt16: return "SnormInt16"; + case ImageChannelDataTypeUnormInt8: return "UnormInt8"; + case ImageChannelDataTypeUnormInt16: return "UnormInt16"; + case ImageChannelDataTypeUnormShort565: return "UnormShort565"; + case ImageChannelDataTypeUnormShort555: return "UnormShort555"; + case ImageChannelDataTypeUnormInt101010: return "UnormInt101010"; + case ImageChannelDataTypeSignedInt8: return "SignedInt8"; + case ImageChannelDataTypeSignedInt16: return "SignedInt16"; + case ImageChannelDataTypeSignedInt32: return "SignedInt32"; + case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; + case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; + case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; + case ImageChannelDataTypeHalfFloat: return "HalfFloat"; + case ImageChannelDataTypeFloat: return "Float"; + case ImageChannelDataTypeUnormInt24: return "UnormInt24"; + case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; + case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; + case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; + case ImageChannelDataTypeUnormInt2_101010EXT: return "UnormInt2_101010EXT"; + default: return "Unknown"; + } +} + +inline const char* FPRoundingModeToString(FPRoundingMode value) { + switch (value) { + case FPRoundingModeRTE: return "RTE"; + case FPRoundingModeRTZ: return "RTZ"; + case FPRoundingModeRTP: return "RTP"; + case FPRoundingModeRTN: return "RTN"; + default: return "Unknown"; + } +} + +inline const char* LinkageTypeToString(LinkageType value) { + switch (value) { + case LinkageTypeExport: return "Export"; + case LinkageTypeImport: return "Import"; + case LinkageTypeLinkOnceODR: return "LinkOnceODR"; + default: return "Unknown"; + } +} + +inline const char* AccessQualifierToString(AccessQualifier value) { + switch (value) { + case AccessQualifierReadOnly: return "ReadOnly"; + case AccessQualifierWriteOnly: return "WriteOnly"; + case AccessQualifierReadWrite: return "ReadWrite"; + default: return "Unknown"; + } +} + +inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) { + switch (value) { + case FunctionParameterAttributeZext: return "Zext"; + case FunctionParameterAttributeSext: return "Sext"; + case FunctionParameterAttributeByVal: return "ByVal"; + case FunctionParameterAttributeSret: return "Sret"; + case FunctionParameterAttributeNoAlias: return "NoAlias"; + case FunctionParameterAttributeNoCapture: return "NoCapture"; + case FunctionParameterAttributeNoWrite: return "NoWrite"; + case FunctionParameterAttributeNoReadWrite: return "NoReadWrite"; + case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; + default: return "Unknown"; + } +} + +inline const char* DecorationToString(Decoration value) { + switch (value) { + case DecorationRelaxedPrecision: return "RelaxedPrecision"; + case DecorationSpecId: return "SpecId"; + case DecorationBlock: return "Block"; + case DecorationBufferBlock: return "BufferBlock"; + case DecorationRowMajor: return "RowMajor"; + case DecorationColMajor: return "ColMajor"; + case DecorationArrayStride: return "ArrayStride"; + case DecorationMatrixStride: return "MatrixStride"; + case DecorationGLSLShared: return "GLSLShared"; + case DecorationGLSLPacked: return "GLSLPacked"; + case DecorationCPacked: return "CPacked"; + case DecorationBuiltIn: return "BuiltIn"; + case DecorationNoPerspective: return "NoPerspective"; + case DecorationFlat: return "Flat"; + case DecorationPatch: return "Patch"; + case DecorationCentroid: return "Centroid"; + case DecorationSample: return "Sample"; + case DecorationInvariant: return "Invariant"; + case DecorationRestrict: return "Restrict"; + case DecorationAliased: return "Aliased"; + case DecorationVolatile: return "Volatile"; + case DecorationConstant: return "Constant"; + case DecorationCoherent: return "Coherent"; + case DecorationNonWritable: return "NonWritable"; + case DecorationNonReadable: return "NonReadable"; + case DecorationUniform: return "Uniform"; + case DecorationUniformId: return "UniformId"; + case DecorationSaturatedConversion: return "SaturatedConversion"; + case DecorationStream: return "Stream"; + case DecorationLocation: return "Location"; + case DecorationComponent: return "Component"; + case DecorationIndex: return "Index"; + case DecorationBinding: return "Binding"; + case DecorationDescriptorSet: return "DescriptorSet"; + case DecorationOffset: return "Offset"; + case DecorationXfbBuffer: return "XfbBuffer"; + case DecorationXfbStride: return "XfbStride"; + case DecorationFuncParamAttr: return "FuncParamAttr"; + case DecorationFPRoundingMode: return "FPRoundingMode"; + case DecorationFPFastMathMode: return "FPFastMathMode"; + case DecorationLinkageAttributes: return "LinkageAttributes"; + case DecorationNoContraction: return "NoContraction"; + case DecorationInputAttachmentIndex: return "InputAttachmentIndex"; + case DecorationAlignment: return "Alignment"; + case DecorationMaxByteOffset: return "MaxByteOffset"; + case DecorationAlignmentId: return "AlignmentId"; + case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; + case DecorationNoSignedWrap: return "NoSignedWrap"; + case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; + case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; + case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; + case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; + case DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; + case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; + case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; + case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; + case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; + case DecorationPayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX"; + case DecorationPayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX"; + case DecorationPayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX"; + case DecorationPayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX"; + case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; + case DecorationPassthroughNV: return "PassthroughNV"; + case DecorationViewportRelativeNV: return "ViewportRelativeNV"; + case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; + case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; + case DecorationPerViewNV: return "PerViewNV"; + case DecorationPerTaskNV: return "PerTaskNV"; + case DecorationPerVertexKHR: return "PerVertexKHR"; + case DecorationNonUniform: return "NonUniform"; + case DecorationRestrictPointer: return "RestrictPointer"; + case DecorationAliasedPointer: return "AliasedPointer"; + case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; + case DecorationBindlessSamplerNV: return "BindlessSamplerNV"; + case DecorationBindlessImageNV: return "BindlessImageNV"; + case DecorationBoundSamplerNV: return "BoundSamplerNV"; + case DecorationBoundImageNV: return "BoundImageNV"; + case DecorationSIMTCallINTEL: return "SIMTCallINTEL"; + case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; + case DecorationClobberINTEL: return "ClobberINTEL"; + case DecorationSideEffectsINTEL: return "SideEffectsINTEL"; + case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; + case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; + case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; + case DecorationStackCallINTEL: return "StackCallINTEL"; + case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; + case DecorationCounterBuffer: return "CounterBuffer"; + case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; + case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; + case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; + case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; + case DecorationRegisterINTEL: return "RegisterINTEL"; + case DecorationMemoryINTEL: return "MemoryINTEL"; + case DecorationNumbanksINTEL: return "NumbanksINTEL"; + case DecorationBankwidthINTEL: return "BankwidthINTEL"; + case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; + case DecorationSinglepumpINTEL: return "SinglepumpINTEL"; + case DecorationDoublepumpINTEL: return "DoublepumpINTEL"; + case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; + case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; + case DecorationMergeINTEL: return "MergeINTEL"; + case DecorationBankBitsINTEL: return "BankBitsINTEL"; + case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; + case DecorationStridesizeINTEL: return "StridesizeINTEL"; + case DecorationWordsizeINTEL: return "WordsizeINTEL"; + case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; + case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; + case DecorationCacheSizeINTEL: return "CacheSizeINTEL"; + case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; + case DecorationPrefetchINTEL: return "PrefetchINTEL"; + case DecorationStallEnableINTEL: return "StallEnableINTEL"; + case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; + case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; + case DecorationAliasScopeINTEL: return "AliasScopeINTEL"; + case DecorationNoAliasINTEL: return "NoAliasINTEL"; + case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; + case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; + case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; + case DecorationBufferLocationINTEL: return "BufferLocationINTEL"; + case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; + case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; + case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; + case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; + case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; + case DecorationStallFreeINTEL: return "StallFreeINTEL"; + case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; + case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; + case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; + case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; + case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; + case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; + case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; + case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; + case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; + case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; + case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; + case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; + case DecorationHostAccessINTEL: return "HostAccessINTEL"; + case DecorationInitModeINTEL: return "InitModeINTEL"; + case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; + case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; + case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; + default: return "Unknown"; + } +} + +inline const char* BuiltInToString(BuiltIn value) { + switch (value) { + case BuiltInPosition: return "Position"; + case BuiltInPointSize: return "PointSize"; + case BuiltInClipDistance: return "ClipDistance"; + case BuiltInCullDistance: return "CullDistance"; + case BuiltInVertexId: return "VertexId"; + case BuiltInInstanceId: return "InstanceId"; + case BuiltInPrimitiveId: return "PrimitiveId"; + case BuiltInInvocationId: return "InvocationId"; + case BuiltInLayer: return "Layer"; + case BuiltInViewportIndex: return "ViewportIndex"; + case BuiltInTessLevelOuter: return "TessLevelOuter"; + case BuiltInTessLevelInner: return "TessLevelInner"; + case BuiltInTessCoord: return "TessCoord"; + case BuiltInPatchVertices: return "PatchVertices"; + case BuiltInFragCoord: return "FragCoord"; + case BuiltInPointCoord: return "PointCoord"; + case BuiltInFrontFacing: return "FrontFacing"; + case BuiltInSampleId: return "SampleId"; + case BuiltInSamplePosition: return "SamplePosition"; + case BuiltInSampleMask: return "SampleMask"; + case BuiltInFragDepth: return "FragDepth"; + case BuiltInHelperInvocation: return "HelperInvocation"; + case BuiltInNumWorkgroups: return "NumWorkgroups"; + case BuiltInWorkgroupSize: return "WorkgroupSize"; + case BuiltInWorkgroupId: return "WorkgroupId"; + case BuiltInLocalInvocationId: return "LocalInvocationId"; + case BuiltInGlobalInvocationId: return "GlobalInvocationId"; + case BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; + case BuiltInWorkDim: return "WorkDim"; + case BuiltInGlobalSize: return "GlobalSize"; + case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; + case BuiltInGlobalOffset: return "GlobalOffset"; + case BuiltInGlobalLinearId: return "GlobalLinearId"; + case BuiltInSubgroupSize: return "SubgroupSize"; + case BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; + case BuiltInNumSubgroups: return "NumSubgroups"; + case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; + case BuiltInSubgroupId: return "SubgroupId"; + case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; + case BuiltInVertexIndex: return "VertexIndex"; + case BuiltInInstanceIndex: return "InstanceIndex"; + case BuiltInCoreIDARM: return "CoreIDARM"; + case BuiltInCoreCountARM: return "CoreCountARM"; + case BuiltInCoreMaxIDARM: return "CoreMaxIDARM"; + case BuiltInWarpIDARM: return "WarpIDARM"; + case BuiltInWarpMaxIDARM: return "WarpMaxIDARM"; + case BuiltInSubgroupEqMask: return "SubgroupEqMask"; + case BuiltInSubgroupGeMask: return "SubgroupGeMask"; + case BuiltInSubgroupGtMask: return "SubgroupGtMask"; + case BuiltInSubgroupLeMask: return "SubgroupLeMask"; + case BuiltInSubgroupLtMask: return "SubgroupLtMask"; + case BuiltInBaseVertex: return "BaseVertex"; + case BuiltInBaseInstance: return "BaseInstance"; + case BuiltInDrawIndex: return "DrawIndex"; + case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; + case BuiltInDeviceIndex: return "DeviceIndex"; + case BuiltInViewIndex: return "ViewIndex"; + case BuiltInShadingRateKHR: return "ShadingRateKHR"; + case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; + case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; + case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; + case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; + case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; + case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; + case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; + case BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; + case BuiltInRemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX"; + case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; + case BuiltInViewportMaskNV: return "ViewportMaskNV"; + case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; + case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; + case BuiltInPositionPerViewNV: return "PositionPerViewNV"; + case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; + case BuiltInFullyCoveredEXT: return "FullyCoveredEXT"; + case BuiltInTaskCountNV: return "TaskCountNV"; + case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; + case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; + case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; + case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; + case BuiltInLayerPerViewNV: return "LayerPerViewNV"; + case BuiltInMeshViewCountNV: return "MeshViewCountNV"; + case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; + case BuiltInBaryCoordKHR: return "BaryCoordKHR"; + case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; + case BuiltInFragSizeEXT: return "FragSizeEXT"; + case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; + case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; + case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; + case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; + case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; + case BuiltInLaunchIdKHR: return "LaunchIdKHR"; + case BuiltInLaunchSizeKHR: return "LaunchSizeKHR"; + case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; + case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; + case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; + case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; + case BuiltInRayTminKHR: return "RayTminKHR"; + case BuiltInRayTmaxKHR: return "RayTmaxKHR"; + case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; + case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; + case BuiltInWorldToObjectKHR: return "WorldToObjectKHR"; + case BuiltInHitTNV: return "HitTNV"; + case BuiltInHitKindKHR: return "HitKindKHR"; + case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; + case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; + case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; + case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; + case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; + case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; + case BuiltInWarpsPerSMNV: return "WarpsPerSMNV"; + case BuiltInSMCountNV: return "SMCountNV"; + case BuiltInWarpIDNV: return "WarpIDNV"; + case BuiltInSMIDNV: return "SMIDNV"; + case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; + case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; + case BuiltInCullMaskKHR: return "CullMaskKHR"; + default: return "Unknown"; + } +} + +inline const char* ScopeToString(Scope value) { + switch (value) { + case ScopeCrossDevice: return "CrossDevice"; + case ScopeDevice: return "Device"; + case ScopeWorkgroup: return "Workgroup"; + case ScopeSubgroup: return "Subgroup"; + case ScopeInvocation: return "Invocation"; + case ScopeQueueFamily: return "QueueFamily"; + case ScopeShaderCallKHR: return "ShaderCallKHR"; + default: return "Unknown"; + } +} + +inline const char* GroupOperationToString(GroupOperation value) { + switch (value) { + case GroupOperationReduce: return "Reduce"; + case GroupOperationInclusiveScan: return "InclusiveScan"; + case GroupOperationExclusiveScan: return "ExclusiveScan"; + case GroupOperationClusteredReduce: return "ClusteredReduce"; + case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; + case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; + case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; + default: return "Unknown"; + } +} + +inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) { + switch (value) { + case KernelEnqueueFlagsNoWait: return "NoWait"; + case KernelEnqueueFlagsWaitKernel: return "WaitKernel"; + case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; + default: return "Unknown"; + } +} + +inline const char* CapabilityToString(Capability value) { + switch (value) { + case CapabilityMatrix: return "Matrix"; + case CapabilityShader: return "Shader"; + case CapabilityGeometry: return "Geometry"; + case CapabilityTessellation: return "Tessellation"; + case CapabilityAddresses: return "Addresses"; + case CapabilityLinkage: return "Linkage"; + case CapabilityKernel: return "Kernel"; + case CapabilityVector16: return "Vector16"; + case CapabilityFloat16Buffer: return "Float16Buffer"; + case CapabilityFloat16: return "Float16"; + case CapabilityFloat64: return "Float64"; + case CapabilityInt64: return "Int64"; + case CapabilityInt64Atomics: return "Int64Atomics"; + case CapabilityImageBasic: return "ImageBasic"; + case CapabilityImageReadWrite: return "ImageReadWrite"; + case CapabilityImageMipmap: return "ImageMipmap"; + case CapabilityPipes: return "Pipes"; + case CapabilityGroups: return "Groups"; + case CapabilityDeviceEnqueue: return "DeviceEnqueue"; + case CapabilityLiteralSampler: return "LiteralSampler"; + case CapabilityAtomicStorage: return "AtomicStorage"; + case CapabilityInt16: return "Int16"; + case CapabilityTessellationPointSize: return "TessellationPointSize"; + case CapabilityGeometryPointSize: return "GeometryPointSize"; + case CapabilityImageGatherExtended: return "ImageGatherExtended"; + case CapabilityStorageImageMultisample: return "StorageImageMultisample"; + case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; + case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; + case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; + case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; + case CapabilityClipDistance: return "ClipDistance"; + case CapabilityCullDistance: return "CullDistance"; + case CapabilityImageCubeArray: return "ImageCubeArray"; + case CapabilitySampleRateShading: return "SampleRateShading"; + case CapabilityImageRect: return "ImageRect"; + case CapabilitySampledRect: return "SampledRect"; + case CapabilityGenericPointer: return "GenericPointer"; + case CapabilityInt8: return "Int8"; + case CapabilityInputAttachment: return "InputAttachment"; + case CapabilitySparseResidency: return "SparseResidency"; + case CapabilityMinLod: return "MinLod"; + case CapabilitySampled1D: return "Sampled1D"; + case CapabilityImage1D: return "Image1D"; + case CapabilitySampledCubeArray: return "SampledCubeArray"; + case CapabilitySampledBuffer: return "SampledBuffer"; + case CapabilityImageBuffer: return "ImageBuffer"; + case CapabilityImageMSArray: return "ImageMSArray"; + case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; + case CapabilityImageQuery: return "ImageQuery"; + case CapabilityDerivativeControl: return "DerivativeControl"; + case CapabilityInterpolationFunction: return "InterpolationFunction"; + case CapabilityTransformFeedback: return "TransformFeedback"; + case CapabilityGeometryStreams: return "GeometryStreams"; + case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; + case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; + case CapabilityMultiViewport: return "MultiViewport"; + case CapabilitySubgroupDispatch: return "SubgroupDispatch"; + case CapabilityNamedBarrier: return "NamedBarrier"; + case CapabilityPipeStorage: return "PipeStorage"; + case CapabilityGroupNonUniform: return "GroupNonUniform"; + case CapabilityGroupNonUniformVote: return "GroupNonUniformVote"; + case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; + case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; + case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; + case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; + case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; + case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; + case CapabilityShaderLayer: return "ShaderLayer"; + case CapabilityShaderViewportIndex: return "ShaderViewportIndex"; + case CapabilityUniformDecoration: return "UniformDecoration"; + case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; + case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; + case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; + case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; + case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; + case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; + case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; + case CapabilityDrawParameters: return "DrawParameters"; + case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; + case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; + case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; + case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; + case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; + case CapabilityStorageUniform16: return "StorageUniform16"; + case CapabilityStoragePushConstant16: return "StoragePushConstant16"; + case CapabilityStorageInputOutput16: return "StorageInputOutput16"; + case CapabilityDeviceGroup: return "DeviceGroup"; + case CapabilityMultiView: return "MultiView"; + case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; + case CapabilityVariablePointers: return "VariablePointers"; + case CapabilityAtomicStorageOps: return "AtomicStorageOps"; + case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; + case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; + case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; + case CapabilityStoragePushConstant8: return "StoragePushConstant8"; + case CapabilityDenormPreserve: return "DenormPreserve"; + case CapabilityDenormFlushToZero: return "DenormFlushToZero"; + case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; + case CapabilityRoundingModeRTE: return "RoundingModeRTE"; + case CapabilityRoundingModeRTZ: return "RoundingModeRTZ"; + case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; + case CapabilityRayQueryKHR: return "RayQueryKHR"; + case CapabilityUntypedPointersKHR: return "UntypedPointersKHR"; + case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; + case CapabilityRayTracingKHR: return "RayTracingKHR"; + case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; + case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; + case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; + case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; + case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; + case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; + case CapabilityFragmentMaskAMD: return "FragmentMaskAMD"; + case CapabilityStencilExportEXT: return "StencilExportEXT"; + case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; + case CapabilityInt64ImageEXT: return "Int64ImageEXT"; + case CapabilityShaderClockKHR: return "ShaderClockKHR"; + case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; + case CapabilityQuadControlKHR: return "QuadControlKHR"; + case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; + case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; + case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; + case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; + case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; + case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; + case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; + case CapabilityMeshShadingNV: return "MeshShadingNV"; + case CapabilityImageFootprintNV: return "ImageFootprintNV"; + case CapabilityMeshShadingEXT: return "MeshShadingEXT"; + case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; + case CapabilityComputeDerivativeGroupQuadsKHR: return "ComputeDerivativeGroupQuadsKHR"; + case CapabilityFragmentDensityEXT: return "FragmentDensityEXT"; + case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; + case CapabilityShaderNonUniform: return "ShaderNonUniform"; + case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; + case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; + case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; + case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; + case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; + case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; + case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; + case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; + case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; + case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; + case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; + case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; + case CapabilityRayTracingNV: return "RayTracingNV"; + case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; + case CapabilityVulkanMemoryModel: return "VulkanMemoryModel"; + case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; + case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; + case CapabilityComputeDerivativeGroupLinearKHR: return "ComputeDerivativeGroupLinearKHR"; + case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; + case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; + case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; + case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; + case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; + case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; + case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; + case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; + case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; + case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; + case CapabilityBindlessTextureNV: return "BindlessTextureNV"; + case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; + case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; + case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; + case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; + case CapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV"; + case CapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV"; + case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV"; + case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV"; + case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV"; + case CapabilityTensorAddressingNV: return "TensorAddressingNV"; + case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; + case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; + case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; + case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; + case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; + case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; + case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; + case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; + case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; + case CapabilityAsmINTEL: return "AsmINTEL"; + case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; + case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; + case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; + case CapabilityVectorComputeINTEL: return "VectorComputeINTEL"; + case CapabilityVectorAnyINTEL: return "VectorAnyINTEL"; + case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; + case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; + case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; + case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; + case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; + case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; + case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; + case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; + case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; + case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; + case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; + case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; + case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; + case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; + case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; + case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; + case CapabilityLoopFuseINTEL: return "LoopFuseINTEL"; + case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; + case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; + case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; + case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; + case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; + case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; + case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; + case CapabilityIOPipesINTEL: return "IOPipesINTEL"; + case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; + case CapabilityFPGARegINTEL: return "FPGARegINTEL"; + case CapabilityDotProductInputAll: return "DotProductInputAll"; + case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; + case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; + case CapabilityDotProduct: return "DotProduct"; + case CapabilityRayCullMaskKHR: return "RayCullMaskKHR"; + case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; + case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; + case CapabilityBitInstructions: return "BitInstructions"; + case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; + case CapabilityFloatControls2: return "FloatControls2"; + case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; + case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; + case CapabilityLongCompositesINTEL: return "LongCompositesINTEL"; + case CapabilityOptNoneEXT: return "OptNoneEXT"; + case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; + case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; + case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; + case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; + case CapabilityArithmeticFenceEXT: return "ArithmeticFenceEXT"; + case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; + case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; + case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; + case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; + case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; + case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; + case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; + case CapabilitySubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL"; + case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; + case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; + case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; + case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; + default: return "Unknown"; + } +} + +inline const char* RayQueryIntersectionToString(RayQueryIntersection value) { + switch (value) { + case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; + case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; + default: return "Unknown"; + } +} + +inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) { + switch (value) { + case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; + case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; + case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; + default: return "Unknown"; + } +} + +inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) { + switch (value) { + case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; + case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; + default: return "Unknown"; + } +} + +inline const char* FPDenormModeToString(FPDenormMode value) { + switch (value) { + case FPDenormModePreserve: return "Preserve"; + case FPDenormModeFlushToZero: return "FlushToZero"; + default: return "Unknown"; + } +} + +inline const char* FPOperationModeToString(FPOperationMode value) { + switch (value) { + case FPOperationModeIEEE: return "IEEE"; + case FPOperationModeALT: return "ALT"; + default: return "Unknown"; + } +} + +inline const char* QuantizationModesToString(QuantizationModes value) { + switch (value) { + case QuantizationModesTRN: return "TRN"; + case QuantizationModesTRN_ZERO: return "TRN_ZERO"; + case QuantizationModesRND: return "RND"; + case QuantizationModesRND_ZERO: return "RND_ZERO"; + case QuantizationModesRND_INF: return "RND_INF"; + case QuantizationModesRND_MIN_INF: return "RND_MIN_INF"; + case QuantizationModesRND_CONV: return "RND_CONV"; + case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; + default: return "Unknown"; + } +} + +inline const char* OverflowModesToString(OverflowModes value) { + switch (value) { + case OverflowModesWRAP: return "WRAP"; + case OverflowModesSAT: return "SAT"; + case OverflowModesSAT_ZERO: return "SAT_ZERO"; + case OverflowModesSAT_SYM: return "SAT_SYM"; + default: return "Unknown"; + } +} + +inline const char* PackedVectorFormatToString(PackedVectorFormat value) { + switch (value) { + case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; + default: return "Unknown"; + } +} + +inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) { + switch (value) { + case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; + case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; + case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; + case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; + default: return "Unknown"; + } +} + +inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) { + switch (value) { + case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; + case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; + case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; + default: return "Unknown"; + } +} + +inline const char* TensorClampModeToString(TensorClampMode value) { + switch (value) { + case TensorClampModeUndefined: return "Undefined"; + case TensorClampModeConstant: return "Constant"; + case TensorClampModeClampToEdge: return "ClampToEdge"; + case TensorClampModeRepeat: return "Repeat"; + case TensorClampModeRepeatMirrored: return "RepeatMirrored"; + default: return "Unknown"; + } +} + +inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) { + switch (value) { + case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; + case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; + default: return "Unknown"; + } +} + +inline const char* HostAccessQualifierToString(HostAccessQualifier value) { + switch (value) { + case HostAccessQualifierNoneINTEL: return "NoneINTEL"; + case HostAccessQualifierReadINTEL: return "ReadINTEL"; + case HostAccessQualifierWriteINTEL: return "WriteINTEL"; + case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; + default: return "Unknown"; + } +} + +inline const char* LoadCacheControlToString(LoadCacheControl value) { + switch (value) { + case LoadCacheControlUncachedINTEL: return "UncachedINTEL"; + case LoadCacheControlCachedINTEL: return "CachedINTEL"; + case LoadCacheControlStreamingINTEL: return "StreamingINTEL"; + case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; + case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; + default: return "Unknown"; + } +} + +inline const char* StoreCacheControlToString(StoreCacheControl value) { + switch (value) { + case StoreCacheControlUncachedINTEL: return "UncachedINTEL"; + case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; + case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; + case StoreCacheControlStreamingINTEL: return "StreamingINTEL"; + default: return "Unknown"; + } +} + +inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) { + switch (value) { + case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; + default: return "Unknown"; + } +} + +inline const char* FPEncodingToString(FPEncoding value) { + switch (value) { + default: return "Unknown"; + } +} + +inline const char* OpToString(Op value) { + switch (value) { + case OpNop: return "OpNop"; + case OpUndef: return "OpUndef"; + case OpSourceContinued: return "OpSourceContinued"; + case OpSource: return "OpSource"; + case OpSourceExtension: return "OpSourceExtension"; + case OpName: return "OpName"; + case OpMemberName: return "OpMemberName"; + case OpString: return "OpString"; + case OpLine: return "OpLine"; + case OpExtension: return "OpExtension"; + case OpExtInstImport: return "OpExtInstImport"; + case OpExtInst: return "OpExtInst"; + case OpMemoryModel: return "OpMemoryModel"; + case OpEntryPoint: return "OpEntryPoint"; + case OpExecutionMode: return "OpExecutionMode"; + case OpCapability: return "OpCapability"; + case OpTypeVoid: return "OpTypeVoid"; + case OpTypeBool: return "OpTypeBool"; + case OpTypeInt: return "OpTypeInt"; + case OpTypeFloat: return "OpTypeFloat"; + case OpTypeVector: return "OpTypeVector"; + case OpTypeMatrix: return "OpTypeMatrix"; + case OpTypeImage: return "OpTypeImage"; + case OpTypeSampler: return "OpTypeSampler"; + case OpTypeSampledImage: return "OpTypeSampledImage"; + case OpTypeArray: return "OpTypeArray"; + case OpTypeRuntimeArray: return "OpTypeRuntimeArray"; + case OpTypeStruct: return "OpTypeStruct"; + case OpTypeOpaque: return "OpTypeOpaque"; + case OpTypePointer: return "OpTypePointer"; + case OpTypeFunction: return "OpTypeFunction"; + case OpTypeEvent: return "OpTypeEvent"; + case OpTypeDeviceEvent: return "OpTypeDeviceEvent"; + case OpTypeReserveId: return "OpTypeReserveId"; + case OpTypeQueue: return "OpTypeQueue"; + case OpTypePipe: return "OpTypePipe"; + case OpTypeForwardPointer: return "OpTypeForwardPointer"; + case OpConstantTrue: return "OpConstantTrue"; + case OpConstantFalse: return "OpConstantFalse"; + case OpConstant: return "OpConstant"; + case OpConstantComposite: return "OpConstantComposite"; + case OpConstantSampler: return "OpConstantSampler"; + case OpConstantNull: return "OpConstantNull"; + case OpSpecConstantTrue: return "OpSpecConstantTrue"; + case OpSpecConstantFalse: return "OpSpecConstantFalse"; + case OpSpecConstant: return "OpSpecConstant"; + case OpSpecConstantComposite: return "OpSpecConstantComposite"; + case OpSpecConstantOp: return "OpSpecConstantOp"; + case OpFunction: return "OpFunction"; + case OpFunctionParameter: return "OpFunctionParameter"; + case OpFunctionEnd: return "OpFunctionEnd"; + case OpFunctionCall: return "OpFunctionCall"; + case OpVariable: return "OpVariable"; + case OpImageTexelPointer: return "OpImageTexelPointer"; + case OpLoad: return "OpLoad"; + case OpStore: return "OpStore"; + case OpCopyMemory: return "OpCopyMemory"; + case OpCopyMemorySized: return "OpCopyMemorySized"; + case OpAccessChain: return "OpAccessChain"; + case OpInBoundsAccessChain: return "OpInBoundsAccessChain"; + case OpPtrAccessChain: return "OpPtrAccessChain"; + case OpArrayLength: return "OpArrayLength"; + case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; + case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; + case OpDecorate: return "OpDecorate"; + case OpMemberDecorate: return "OpMemberDecorate"; + case OpDecorationGroup: return "OpDecorationGroup"; + case OpGroupDecorate: return "OpGroupDecorate"; + case OpGroupMemberDecorate: return "OpGroupMemberDecorate"; + case OpVectorExtractDynamic: return "OpVectorExtractDynamic"; + case OpVectorInsertDynamic: return "OpVectorInsertDynamic"; + case OpVectorShuffle: return "OpVectorShuffle"; + case OpCompositeConstruct: return "OpCompositeConstruct"; + case OpCompositeExtract: return "OpCompositeExtract"; + case OpCompositeInsert: return "OpCompositeInsert"; + case OpCopyObject: return "OpCopyObject"; + case OpTranspose: return "OpTranspose"; + case OpSampledImage: return "OpSampledImage"; + case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; + case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; + case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; + case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; + case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; + case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; + case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; + case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; + case OpImageFetch: return "OpImageFetch"; + case OpImageGather: return "OpImageGather"; + case OpImageDrefGather: return "OpImageDrefGather"; + case OpImageRead: return "OpImageRead"; + case OpImageWrite: return "OpImageWrite"; + case OpImage: return "OpImage"; + case OpImageQueryFormat: return "OpImageQueryFormat"; + case OpImageQueryOrder: return "OpImageQueryOrder"; + case OpImageQuerySizeLod: return "OpImageQuerySizeLod"; + case OpImageQuerySize: return "OpImageQuerySize"; + case OpImageQueryLod: return "OpImageQueryLod"; + case OpImageQueryLevels: return "OpImageQueryLevels"; + case OpImageQuerySamples: return "OpImageQuerySamples"; + case OpConvertFToU: return "OpConvertFToU"; + case OpConvertFToS: return "OpConvertFToS"; + case OpConvertSToF: return "OpConvertSToF"; + case OpConvertUToF: return "OpConvertUToF"; + case OpUConvert: return "OpUConvert"; + case OpSConvert: return "OpSConvert"; + case OpFConvert: return "OpFConvert"; + case OpQuantizeToF16: return "OpQuantizeToF16"; + case OpConvertPtrToU: return "OpConvertPtrToU"; + case OpSatConvertSToU: return "OpSatConvertSToU"; + case OpSatConvertUToS: return "OpSatConvertUToS"; + case OpConvertUToPtr: return "OpConvertUToPtr"; + case OpPtrCastToGeneric: return "OpPtrCastToGeneric"; + case OpGenericCastToPtr: return "OpGenericCastToPtr"; + case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; + case OpBitcast: return "OpBitcast"; + case OpSNegate: return "OpSNegate"; + case OpFNegate: return "OpFNegate"; + case OpIAdd: return "OpIAdd"; + case OpFAdd: return "OpFAdd"; + case OpISub: return "OpISub"; + case OpFSub: return "OpFSub"; + case OpIMul: return "OpIMul"; + case OpFMul: return "OpFMul"; + case OpUDiv: return "OpUDiv"; + case OpSDiv: return "OpSDiv"; + case OpFDiv: return "OpFDiv"; + case OpUMod: return "OpUMod"; + case OpSRem: return "OpSRem"; + case OpSMod: return "OpSMod"; + case OpFRem: return "OpFRem"; + case OpFMod: return "OpFMod"; + case OpVectorTimesScalar: return "OpVectorTimesScalar"; + case OpMatrixTimesScalar: return "OpMatrixTimesScalar"; + case OpVectorTimesMatrix: return "OpVectorTimesMatrix"; + case OpMatrixTimesVector: return "OpMatrixTimesVector"; + case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; + case OpOuterProduct: return "OpOuterProduct"; + case OpDot: return "OpDot"; + case OpIAddCarry: return "OpIAddCarry"; + case OpISubBorrow: return "OpISubBorrow"; + case OpUMulExtended: return "OpUMulExtended"; + case OpSMulExtended: return "OpSMulExtended"; + case OpAny: return "OpAny"; + case OpAll: return "OpAll"; + case OpIsNan: return "OpIsNan"; + case OpIsInf: return "OpIsInf"; + case OpIsFinite: return "OpIsFinite"; + case OpIsNormal: return "OpIsNormal"; + case OpSignBitSet: return "OpSignBitSet"; + case OpLessOrGreater: return "OpLessOrGreater"; + case OpOrdered: return "OpOrdered"; + case OpUnordered: return "OpUnordered"; + case OpLogicalEqual: return "OpLogicalEqual"; + case OpLogicalNotEqual: return "OpLogicalNotEqual"; + case OpLogicalOr: return "OpLogicalOr"; + case OpLogicalAnd: return "OpLogicalAnd"; + case OpLogicalNot: return "OpLogicalNot"; + case OpSelect: return "OpSelect"; + case OpIEqual: return "OpIEqual"; + case OpINotEqual: return "OpINotEqual"; + case OpUGreaterThan: return "OpUGreaterThan"; + case OpSGreaterThan: return "OpSGreaterThan"; + case OpUGreaterThanEqual: return "OpUGreaterThanEqual"; + case OpSGreaterThanEqual: return "OpSGreaterThanEqual"; + case OpULessThan: return "OpULessThan"; + case OpSLessThan: return "OpSLessThan"; + case OpULessThanEqual: return "OpULessThanEqual"; + case OpSLessThanEqual: return "OpSLessThanEqual"; + case OpFOrdEqual: return "OpFOrdEqual"; + case OpFUnordEqual: return "OpFUnordEqual"; + case OpFOrdNotEqual: return "OpFOrdNotEqual"; + case OpFUnordNotEqual: return "OpFUnordNotEqual"; + case OpFOrdLessThan: return "OpFOrdLessThan"; + case OpFUnordLessThan: return "OpFUnordLessThan"; + case OpFOrdGreaterThan: return "OpFOrdGreaterThan"; + case OpFUnordGreaterThan: return "OpFUnordGreaterThan"; + case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; + case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; + case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; + case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; + case OpShiftRightLogical: return "OpShiftRightLogical"; + case OpShiftRightArithmetic: return "OpShiftRightArithmetic"; + case OpShiftLeftLogical: return "OpShiftLeftLogical"; + case OpBitwiseOr: return "OpBitwiseOr"; + case OpBitwiseXor: return "OpBitwiseXor"; + case OpBitwiseAnd: return "OpBitwiseAnd"; + case OpNot: return "OpNot"; + case OpBitFieldInsert: return "OpBitFieldInsert"; + case OpBitFieldSExtract: return "OpBitFieldSExtract"; + case OpBitFieldUExtract: return "OpBitFieldUExtract"; + case OpBitReverse: return "OpBitReverse"; + case OpBitCount: return "OpBitCount"; + case OpDPdx: return "OpDPdx"; + case OpDPdy: return "OpDPdy"; + case OpFwidth: return "OpFwidth"; + case OpDPdxFine: return "OpDPdxFine"; + case OpDPdyFine: return "OpDPdyFine"; + case OpFwidthFine: return "OpFwidthFine"; + case OpDPdxCoarse: return "OpDPdxCoarse"; + case OpDPdyCoarse: return "OpDPdyCoarse"; + case OpFwidthCoarse: return "OpFwidthCoarse"; + case OpEmitVertex: return "OpEmitVertex"; + case OpEndPrimitive: return "OpEndPrimitive"; + case OpEmitStreamVertex: return "OpEmitStreamVertex"; + case OpEndStreamPrimitive: return "OpEndStreamPrimitive"; + case OpControlBarrier: return "OpControlBarrier"; + case OpMemoryBarrier: return "OpMemoryBarrier"; + case OpAtomicLoad: return "OpAtomicLoad"; + case OpAtomicStore: return "OpAtomicStore"; + case OpAtomicExchange: return "OpAtomicExchange"; + case OpAtomicCompareExchange: return "OpAtomicCompareExchange"; + case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; + case OpAtomicIIncrement: return "OpAtomicIIncrement"; + case OpAtomicIDecrement: return "OpAtomicIDecrement"; + case OpAtomicIAdd: return "OpAtomicIAdd"; + case OpAtomicISub: return "OpAtomicISub"; + case OpAtomicSMin: return "OpAtomicSMin"; + case OpAtomicUMin: return "OpAtomicUMin"; + case OpAtomicSMax: return "OpAtomicSMax"; + case OpAtomicUMax: return "OpAtomicUMax"; + case OpAtomicAnd: return "OpAtomicAnd"; + case OpAtomicOr: return "OpAtomicOr"; + case OpAtomicXor: return "OpAtomicXor"; + case OpPhi: return "OpPhi"; + case OpLoopMerge: return "OpLoopMerge"; + case OpSelectionMerge: return "OpSelectionMerge"; + case OpLabel: return "OpLabel"; + case OpBranch: return "OpBranch"; + case OpBranchConditional: return "OpBranchConditional"; + case OpSwitch: return "OpSwitch"; + case OpKill: return "OpKill"; + case OpReturn: return "OpReturn"; + case OpReturnValue: return "OpReturnValue"; + case OpUnreachable: return "OpUnreachable"; + case OpLifetimeStart: return "OpLifetimeStart"; + case OpLifetimeStop: return "OpLifetimeStop"; + case OpGroupAsyncCopy: return "OpGroupAsyncCopy"; + case OpGroupWaitEvents: return "OpGroupWaitEvents"; + case OpGroupAll: return "OpGroupAll"; + case OpGroupAny: return "OpGroupAny"; + case OpGroupBroadcast: return "OpGroupBroadcast"; + case OpGroupIAdd: return "OpGroupIAdd"; + case OpGroupFAdd: return "OpGroupFAdd"; + case OpGroupFMin: return "OpGroupFMin"; + case OpGroupUMin: return "OpGroupUMin"; + case OpGroupSMin: return "OpGroupSMin"; + case OpGroupFMax: return "OpGroupFMax"; + case OpGroupUMax: return "OpGroupUMax"; + case OpGroupSMax: return "OpGroupSMax"; + case OpReadPipe: return "OpReadPipe"; + case OpWritePipe: return "OpWritePipe"; + case OpReservedReadPipe: return "OpReservedReadPipe"; + case OpReservedWritePipe: return "OpReservedWritePipe"; + case OpReserveReadPipePackets: return "OpReserveReadPipePackets"; + case OpReserveWritePipePackets: return "OpReserveWritePipePackets"; + case OpCommitReadPipe: return "OpCommitReadPipe"; + case OpCommitWritePipe: return "OpCommitWritePipe"; + case OpIsValidReserveId: return "OpIsValidReserveId"; + case OpGetNumPipePackets: return "OpGetNumPipePackets"; + case OpGetMaxPipePackets: return "OpGetMaxPipePackets"; + case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; + case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; + case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; + case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; + case OpEnqueueMarker: return "OpEnqueueMarker"; + case OpEnqueueKernel: return "OpEnqueueKernel"; + case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; + case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; + case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; + case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; + case OpRetainEvent: return "OpRetainEvent"; + case OpReleaseEvent: return "OpReleaseEvent"; + case OpCreateUserEvent: return "OpCreateUserEvent"; + case OpIsValidEvent: return "OpIsValidEvent"; + case OpSetUserEventStatus: return "OpSetUserEventStatus"; + case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; + case OpGetDefaultQueue: return "OpGetDefaultQueue"; + case OpBuildNDRange: return "OpBuildNDRange"; + case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; + case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; + case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; + case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; + case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; + case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; + case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; + case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; + case OpImageSparseFetch: return "OpImageSparseFetch"; + case OpImageSparseGather: return "OpImageSparseGather"; + case OpImageSparseDrefGather: return "OpImageSparseDrefGather"; + case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; + case OpNoLine: return "OpNoLine"; + case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; + case OpAtomicFlagClear: return "OpAtomicFlagClear"; + case OpImageSparseRead: return "OpImageSparseRead"; + case OpSizeOf: return "OpSizeOf"; + case OpTypePipeStorage: return "OpTypePipeStorage"; + case OpConstantPipeStorage: return "OpConstantPipeStorage"; + case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; + case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; + case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; + case OpTypeNamedBarrier: return "OpTypeNamedBarrier"; + case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; + case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; + case OpModuleProcessed: return "OpModuleProcessed"; + case OpExecutionModeId: return "OpExecutionModeId"; + case OpDecorateId: return "OpDecorateId"; + case OpGroupNonUniformElect: return "OpGroupNonUniformElect"; + case OpGroupNonUniformAll: return "OpGroupNonUniformAll"; + case OpGroupNonUniformAny: return "OpGroupNonUniformAny"; + case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; + case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; + case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; + case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; + case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; + case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; + case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; + case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; + case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; + case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; + case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; + case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; + case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; + case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; + case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; + case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; + case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; + case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; + case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; + case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; + case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; + case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; + case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; + case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; + case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; + case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; + case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; + case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; + case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; + case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; + case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; + case OpCopyLogical: return "OpCopyLogical"; + case OpPtrEqual: return "OpPtrEqual"; + case OpPtrNotEqual: return "OpPtrNotEqual"; + case OpPtrDiff: return "OpPtrDiff"; + case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; + case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; + case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; + case OpTerminateInvocation: return "OpTerminateInvocation"; + case OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; + case OpUntypedVariableKHR: return "OpUntypedVariableKHR"; + case OpUntypedAccessChainKHR: return "OpUntypedAccessChainKHR"; + case OpUntypedInBoundsAccessChainKHR: return "OpUntypedInBoundsAccessChainKHR"; + case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; + case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; + case OpUntypedPtrAccessChainKHR: return "OpUntypedPtrAccessChainKHR"; + case OpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR"; + case OpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR"; + case OpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR"; + case OpSubgroupAllKHR: return "OpSubgroupAllKHR"; + case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; + case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; + case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; + case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; + case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; + case OpTraceRayKHR: return "OpTraceRayKHR"; + case OpExecuteCallableKHR: return "OpExecuteCallableKHR"; + case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; + case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; + case OpTerminateRayKHR: return "OpTerminateRayKHR"; + case OpSDot: return "OpSDot"; + case OpUDot: return "OpUDot"; + case OpSUDot: return "OpSUDot"; + case OpSDotAccSat: return "OpSDotAccSat"; + case OpUDotAccSat: return "OpUDotAccSat"; + case OpSUDotAccSat: return "OpSUDotAccSat"; + case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; + case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; + case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; + case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; + case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; + case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; + case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; + case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; + case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; + case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; + case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; + case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; + case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; + case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; + case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; + case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; + case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; + case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; + case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; + case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; + case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; + case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; + case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; + case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; + case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; + case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; + case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; + case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; + case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; + case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; + case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; + case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; + case OpFragmentFetchAMD: return "OpFragmentFetchAMD"; + case OpReadClockKHR: return "OpReadClockKHR"; + case OpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX"; + case OpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX"; + case OpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX"; + case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; + case OpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX"; + case OpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX"; + case OpConstantStringAMDX: return "OpConstantStringAMDX"; + case OpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX"; + case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; + case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; + case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; + case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; + case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; + case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; + case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; + case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; + case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; + case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; + case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; + case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; + case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; + case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; + case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; + case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; + case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; + case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; + case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; + case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; + case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; + case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; + case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; + case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; + case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; + case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; + case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; + case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; + case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; + case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; + case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; + case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; + case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; + case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; + case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; + case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; + case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV"; + case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; + case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; + case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; + case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; + case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; + case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; + case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; + case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; + case OpTerminateRayNV: return "OpTerminateRayNV"; + case OpTraceNV: return "OpTraceNV"; + case OpTraceMotionNV: return "OpTraceMotionNV"; + case OpTraceRayMotionNV: return "OpTraceRayMotionNV"; + case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; + case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; + case OpExecuteCallableNV: return "OpExecuteCallableNV"; + case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; + case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; + case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; + case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; + case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; + case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; + case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; + case OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV"; + case OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV"; + case OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV"; + case OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV"; + case OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV"; + case OpTypeTensorViewNV: return "OpTypeTensorViewNV"; + case OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV"; + case OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV"; + case OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV"; + case OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV"; + case OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV"; + case OpCreateTensorViewNV: return "OpCreateTensorViewNV"; + case OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV"; + case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV"; + case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; + case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; + case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV"; + case OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV"; + case OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV"; + case OpConvertUToImageNV: return "OpConvertUToImageNV"; + case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; + case OpConvertImageToUNV: return "OpConvertImageToUNV"; + case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; + case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; + case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; + case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; + case OpRawAccessChainNV: return "OpRawAccessChainNV"; + case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; + case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; + case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; + case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; + case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; + case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; + case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; + case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; + case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; + case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; + case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; + case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; + case OpAbsISubINTEL: return "OpAbsISubINTEL"; + case OpAbsUSubINTEL: return "OpAbsUSubINTEL"; + case OpIAddSatINTEL: return "OpIAddSatINTEL"; + case OpUAddSatINTEL: return "OpUAddSatINTEL"; + case OpIAverageINTEL: return "OpIAverageINTEL"; + case OpUAverageINTEL: return "OpUAverageINTEL"; + case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; + case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; + case OpISubSatINTEL: return "OpISubSatINTEL"; + case OpUSubSatINTEL: return "OpUSubSatINTEL"; + case OpIMul32x16INTEL: return "OpIMul32x16INTEL"; + case OpUMul32x16INTEL: return "OpUMul32x16INTEL"; + case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; + case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; + case OpAsmTargetINTEL: return "OpAsmTargetINTEL"; + case OpAsmINTEL: return "OpAsmINTEL"; + case OpAsmCallINTEL: return "OpAsmCallINTEL"; + case OpAtomicFMinEXT: return "OpAtomicFMinEXT"; + case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; + case OpAssumeTrueKHR: return "OpAssumeTrueKHR"; + case OpExpectKHR: return "OpExpectKHR"; + case OpDecorateString: return "OpDecorateString"; + case OpMemberDecorateString: return "OpMemberDecorateString"; + case OpVmeImageINTEL: return "OpVmeImageINTEL"; + case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; + case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; + case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; + case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; + case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; + case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; + case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; + case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; + case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; + case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; + case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; + case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; + case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; + case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; + case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; + case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; + case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; + case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; + case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; + case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; + case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; + case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; + case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; + case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; + case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; + case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; + case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; + case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; + case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; + case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; + case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; + case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; + case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; + case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; + case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; + case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; + case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; + case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; + case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; + case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; + case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; + case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; + case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; + case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; + case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; + case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; + case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; + case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; + case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; + case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; + case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; + case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; + case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; + case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; + case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; + case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; + case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; + case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; + case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; + case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; + case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; + case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; + case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; + case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; + case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; + case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; + case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; + case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; + case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; + case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; + case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; + case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; + case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; + case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; + case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; + case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; + case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; + case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; + case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; + case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; + case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; + case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; + case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; + case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; + case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; + case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; + case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; + case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; + case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; + case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; + case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; + case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; + case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; + case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; + case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; + case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; + case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; + case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; + case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; + case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; + case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; + case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; + case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; + case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; + case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; + case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; + case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; + case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; + case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; + case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; + case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; + case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; + case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; + case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; + case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; + case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; + case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; + case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; + case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; + case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; + case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; + case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; + case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; + case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; + case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; + case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; + case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; + case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; + case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; + case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; + case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; + case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; + case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; + case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; + case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; + case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; + case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; + case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; + case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; + case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; + case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; + case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; + case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; + case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; + case OpLoopControlINTEL: return "OpLoopControlINTEL"; + case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; + case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; + case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; + case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; + case OpFixedRecipINTEL: return "OpFixedRecipINTEL"; + case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; + case OpFixedSinINTEL: return "OpFixedSinINTEL"; + case OpFixedCosINTEL: return "OpFixedCosINTEL"; + case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; + case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; + case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; + case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; + case OpFixedLogINTEL: return "OpFixedLogINTEL"; + case OpFixedExpINTEL: return "OpFixedExpINTEL"; + case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; + case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; + case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; + case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; + case OpFPGARegINTEL: return "OpFPGARegINTEL"; + case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; + case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; + case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; + case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; + case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; + case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; + case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; + case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; + case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; + case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; + case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; + case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; + case OpAtomicFAddEXT: return "OpAtomicFAddEXT"; + case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; + case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; + case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; + case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; + case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; + case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; + case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; + case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; + case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; + case OpArithmeticFenceEXT: return "OpArithmeticFenceEXT"; + case OpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL"; + case OpGroupIMulKHR: return "OpGroupIMulKHR"; + case OpGroupFMulKHR: return "OpGroupFMulKHR"; + case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; + case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; + case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; + case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; + case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; + case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; + case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; + case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; + default: return "Unknown"; + } +} + #endif /* SPV_ENABLE_UTILITY_CODE */ // Overload bitwise operators for mask bit combining @@ -2834,6 +4917,18 @@ inline CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a, inline CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); } inline CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); } inline CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); } +inline CooperativeMatrixReduceMask operator|(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) | unsigned(b)); } +inline CooperativeMatrixReduceMask operator&(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) & unsigned(b)); } +inline CooperativeMatrixReduceMask operator^(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) ^ unsigned(b)); } +inline CooperativeMatrixReduceMask operator~(CooperativeMatrixReduceMask a) { return CooperativeMatrixReduceMask(~unsigned(a)); } +inline TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) | unsigned(b)); } +inline TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); } +inline TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); } +inline TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); } +inline RawAccessChainOperandsMask operator|(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) | unsigned(b)); } +inline RawAccessChainOperandsMask operator&(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) & unsigned(b)); } +inline RawAccessChainOperandsMask operator^(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) ^ unsigned(b)); } +inline RawAccessChainOperandsMask operator~(RawAccessChainOperandsMask a) { return RawAccessChainOperandsMask(~unsigned(a)); } } // end namespace spv diff --git a/3rdparty/glslang/StandAlone/StandAlone.cpp b/3rdparty/glslang/StandAlone/StandAlone.cpp index e7153b7ab..832384553 100644 --- a/3rdparty/glslang/StandAlone/StandAlone.cpp +++ b/3rdparty/glslang/StandAlone/StandAlone.cpp @@ -842,6 +842,9 @@ void ProcessArguments(std::vector>& workItem } else if (strcmp(argv[1], "vulkan1.3") == 0) { setVulkanSpv(); ClientVersion = glslang::EShTargetVulkan_1_3; + } else if (strcmp(argv[1], "vulkan1.4") == 0) { + setVulkanSpv(); + ClientVersion = glslang::EShTargetVulkan_1_4; } else if (strcmp(argv[1], "opengl") == 0) { setOpenGlSpv(); ClientVersion = glslang::EShTargetOpenGL_450; @@ -1121,6 +1124,10 @@ void ProcessArguments(std::vector>& workItem TargetLanguage = glslang::EShTargetSpv; TargetVersion = glslang::EShTargetSpv_1_6; break; + case glslang::EShTargetVulkan_1_4: + TargetLanguage = glslang::EShTargetSpv; + TargetVersion = glslang::EShTargetSpv_1_6; + break; case glslang::EShTargetOpenGL_450: TargetLanguage = glslang::EShTargetSpv; TargetVersion = glslang::EShTargetSpv_1_0; diff --git a/3rdparty/glslang/build_info.h b/3rdparty/glslang/build_info.h index 328c273f0..05e3e3093 100644 --- a/3rdparty/glslang/build_info.h +++ b/3rdparty/glslang/build_info.h @@ -35,7 +35,7 @@ #define GLSLANG_BUILD_INFO #define GLSLANG_VERSION_MAJOR 15 -#define GLSLANG_VERSION_MINOR 0 +#define GLSLANG_VERSION_MINOR 1 #define GLSLANG_VERSION_PATCH 0 #define GLSLANG_VERSION_FLAVOR "" diff --git a/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp b/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp index 97f5a86d5..d391c1d04 100644 --- a/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp +++ b/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp @@ -270,6 +270,8 @@ static glslang::EShTargetClientVersion c_shader_client_version(glslang_target_cl return glslang::EShTargetVulkan_1_2; case GLSLANG_TARGET_VULKAN_1_3: return glslang::EShTargetVulkan_1_3; + case GLSLANG_TARGET_VULKAN_1_4: + return glslang::EShTargetVulkan_1_4; case GLSLANG_TARGET_OPENGL_450: return glslang::EShTargetOpenGL_450; default: diff --git a/3rdparty/glslang/glslang/HLSL/hlslParseHelper.cpp b/3rdparty/glslang/glslang/HLSL/hlslParseHelper.cpp index 63a4deb0d..073233405 100644 --- a/3rdparty/glslang/glslang/HLSL/hlslParseHelper.cpp +++ b/3rdparty/glslang/glslang/HLSL/hlslParseHelper.cpp @@ -1396,7 +1396,7 @@ TIntermTyped* HlslParseContext::flattenAccess(long long uniqueId, int member, TS // If this is not the final flattening, accumulate the position and return // an object of the partially dereferenced type. - subsetSymbol = new TIntermSymbol(uniqueId, "flattenShadow", dereferencedType); + subsetSymbol = new TIntermSymbol(uniqueId, "flattenShadow", getLanguage(), dereferencedType); subsetSymbol->setFlattenSubset(newSubset); } @@ -5806,6 +5806,7 @@ void HlslParseContext::addInputArgumentConversions(const TFunction& function, TI internalAggregate->getWritableType().getQualifier().makeTemporary(); TIntermSymbol* internalSymbolNode = new TIntermSymbol(internalAggregate->getUniqueId(), internalAggregate->getName(), + getLanguage(), internalAggregate->getType()); internalSymbolNode->setLoc(arg->getLoc()); // This makes the deepest level, the member-wise copy diff --git a/3rdparty/glslang/glslang/Include/BaseTypes.h b/3rdparty/glslang/glslang/Include/BaseTypes.h index 0ac526bfb..858670791 100644 --- a/3rdparty/glslang/glslang/Include/BaseTypes.h +++ b/3rdparty/glslang/glslang/Include/BaseTypes.h @@ -67,6 +67,9 @@ enum TBasicType { EbtRayQuery, EbtHitObjectNV, EbtCoopmat, + EbtFunction, + EbtTensorLayoutNV, + EbtTensorViewNV, // SPIR-V type defined by spirv_type EbtSpirvType, @@ -588,6 +591,30 @@ __inline bool isTypeFloat(TBasicType type) } } +__inline uint32_t GetNumBits(TBasicType type) +{ + switch (type) { + case EbtInt8: + case EbtUint8: + return 8; + case EbtFloat16: + case EbtInt16: + case EbtUint16: + return 16; + case EbtInt: + case EbtUint: + case EbtFloat: + return 32; + case EbtDouble: + case EbtInt64: + case EbtUint64: + return 64; + default: + assert(false); + return 0; + } +} + __inline int getTypeRank(TBasicType type) { int res = -1; diff --git a/3rdparty/glslang/glslang/Include/Types.h b/3rdparty/glslang/glslang/Include/Types.h index ec6b1db8b..465fb4642 100644 --- a/3rdparty/glslang/glslang/Include/Types.h +++ b/3rdparty/glslang/glslang/Include/Types.h @@ -1471,6 +1471,9 @@ public: bool isCoopmatNV() const { return coopmatNV; } bool isCoopmatKHR() const { return coopmatKHR; } + bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; } + bool isTensorViewNV() const { return basicType == EbtTensorViewNV; } + void initType(const TSourceLoc& l) { basicType = EbtVoid; @@ -1625,7 +1628,6 @@ public: assert(dimSize >= 0); coopmatKHRuse = static_cast(dimSize) & 0b111; coopmatKHRUseValid = true; - p.typeParameters->arraySizes->removeLastSize(); } } } @@ -1881,6 +1883,9 @@ public: bool isSpirvType() const { return getBasicType() == EbtSpirvType; } int getCoopMatKHRuse() const { return static_cast(coopmatKHRuse); } + bool isTensorLayoutNV() const { return getBasicType() == EbtTensorLayoutNV; } + bool isTensorViewNV() const { return getBasicType() == EbtTensorViewNV; } + // return true if this type contains any subtype which satisfies the given predicate. template bool contains(P predicate) const @@ -2106,6 +2111,8 @@ public: case EbtString: return "string"; case EbtSpirvType: return "spirv_type"; case EbtCoopmat: return "coopmat"; + case EbtTensorLayoutNV: return "tensorLayoutNV"; + case EbtTensorViewNV: return "tensorViewNV"; default: return "unknown type"; } } @@ -2416,6 +2423,14 @@ public: appendStr(" "); appendStr("coopmat"); } + if (isTensorLayoutNV()) { + appendStr(" "); + appendStr("tensorLayoutNV"); + } + if (isTensorViewNV()) { + appendStr(" "); + appendStr("tensorViewNV"); + } appendStr("<"); for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) { @@ -2423,10 +2438,6 @@ public: if (i != (int)typeParameters->arraySizes->getNumDims() - 1) appendStr(", "); } - if (coopmatKHRUseValid) { - appendStr(", "); - appendInt(coopmatKHRuse); - } appendStr(">"); } if (getPrecision && qualifier.precision != EpqNone) { @@ -2752,24 +2763,44 @@ public: return rv; } + bool tensorParameterOK(const TType& right) const + { + if (isTensorLayoutNV()) { + return right.isTensorLayoutNV() && right.typeParameters == nullptr && typeParameters != nullptr; + } + if (isTensorViewNV()) { + return right.isTensorViewNV() && right.typeParameters == nullptr && typeParameters != nullptr; + } + return false; + } + bool sameCoopMatUse(const TType &right) const { return coopmatKHRuse == right.coopmatKHRuse; } - bool sameCoopMatShapeAndUse(const TType &right) const + bool sameCoopMatShape(const TType &right) const { if (!isCoopMat() || !right.isCoopMat() || isCoopMatKHR() != right.isCoopMatKHR()) return false; + // Skip bit width type parameter (first array size) for coopmatNV + int firstArrayDimToCompare = isCoopMatNV() ? 1 : 0; + int lastArrayDimToCompare = typeParameters->arraySizes->getNumDims() - (isCoopMatKHR() ? 1 : 0); + for (int i = firstArrayDimToCompare; i < lastArrayDimToCompare; ++i) { + if (typeParameters->arraySizes->getDimSize(i) != right.typeParameters->arraySizes->getDimSize(i)) + return false; + } + return true; + } + + bool sameCoopMatShapeAndUse(const TType &right) const + { + if (!sameCoopMatShape(right)) + return false; + if (coopmatKHRuse != right.coopmatKHRuse) return false; - // Skip bit width type parameter (first array size) for coopmatNV - int firstArrayDimToCompare = isCoopMatNV() ? 1 : 0; - for (int i = firstArrayDimToCompare; i < typeParameters->arraySizes->getNumDims(); ++i) { - if (typeParameters->arraySizes->getDimSize(i) != right.typeParameters->arraySizes->getDimSize(i)) - return false; - } return true; } @@ -2827,7 +2858,9 @@ protected: typeParameters = new TTypeParameters; typeParameters->arraySizes = new TArraySizes; *typeParameters->arraySizes = *copyOf.typeParameters->arraySizes; - *typeParameters->spirvType = *copyOf.typeParameters->spirvType; + if (copyOf.typeParameters->spirvType) { + *typeParameters->spirvType = *copyOf.typeParameters->spirvType; + } typeParameters->basicType = copyOf.basicType; } diff --git a/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h b/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h index 768e2e84e..d0bcced4d 100644 --- a/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h +++ b/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h @@ -118,8 +118,9 @@ typedef enum { GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12), GLSLANG_TARGET_VULKAN_1_2 = (1 << 22) | (2 << 12), GLSLANG_TARGET_VULKAN_1_3 = (1 << 22) | (3 << 12), + GLSLANG_TARGET_VULKAN_1_4 = (1 << 22) | (4 << 12), GLSLANG_TARGET_OPENGL_450 = 450, - LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 5), + LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 6), } glslang_target_client_version_t; /* SH_TARGET_LanguageVersion counterpart */ diff --git a/3rdparty/glslang/glslang/Include/intermediate.h b/3rdparty/glslang/glslang/Include/intermediate.h index 82de2b4de..e574b80d0 100644 --- a/3rdparty/glslang/glslang/Include/intermediate.h +++ b/3rdparty/glslang/glslang/Include/intermediate.h @@ -87,189 +87,9 @@ enum TOperator { EOpDeclare, // Used by debugging to force declaration of variable in correct scope - // (u)int* -> bool - EOpConvInt8ToBool, - EOpConvUint8ToBool, - EOpConvInt16ToBool, - EOpConvUint16ToBool, - EOpConvIntToBool, - EOpConvUintToBool, - EOpConvInt64ToBool, - EOpConvUint64ToBool, - - // float* -> bool - EOpConvFloat16ToBool, - EOpConvFloatToBool, - EOpConvDoubleToBool, - - // bool -> (u)int* - EOpConvBoolToInt8, - EOpConvBoolToUint8, - EOpConvBoolToInt16, - EOpConvBoolToUint16, - EOpConvBoolToInt, - EOpConvBoolToUint, - EOpConvBoolToInt64, - EOpConvBoolToUint64, - - // bool -> float* - EOpConvBoolToFloat16, - EOpConvBoolToFloat, - EOpConvBoolToDouble, - - // int8_t -> (u)int* - EOpConvInt8ToInt16, - EOpConvInt8ToInt, - EOpConvInt8ToInt64, - EOpConvInt8ToUint8, - EOpConvInt8ToUint16, - EOpConvInt8ToUint, - EOpConvInt8ToUint64, - - // uint8_t -> (u)int* - EOpConvUint8ToInt8, - EOpConvUint8ToInt16, - EOpConvUint8ToInt, - EOpConvUint8ToInt64, - EOpConvUint8ToUint16, - EOpConvUint8ToUint, - EOpConvUint8ToUint64, - - // int8_t -> float* - EOpConvInt8ToFloat16, - EOpConvInt8ToFloat, - EOpConvInt8ToDouble, - - // uint8_t -> float* - EOpConvUint8ToFloat16, - EOpConvUint8ToFloat, - EOpConvUint8ToDouble, - - // int16_t -> (u)int* - EOpConvInt16ToInt8, - EOpConvInt16ToInt, - EOpConvInt16ToInt64, - EOpConvInt16ToUint8, - EOpConvInt16ToUint16, - EOpConvInt16ToUint, - EOpConvInt16ToUint64, - - // uint16_t -> (u)int* - EOpConvUint16ToInt8, - EOpConvUint16ToInt16, - EOpConvUint16ToInt, - EOpConvUint16ToInt64, - EOpConvUint16ToUint8, - EOpConvUint16ToUint, - EOpConvUint16ToUint64, - - // int16_t -> float* - EOpConvInt16ToFloat16, - EOpConvInt16ToFloat, - EOpConvInt16ToDouble, - - // uint16_t -> float* - EOpConvUint16ToFloat16, - EOpConvUint16ToFloat, - EOpConvUint16ToDouble, - - // int32_t -> (u)int* - EOpConvIntToInt8, - EOpConvIntToInt16, - EOpConvIntToInt64, - EOpConvIntToUint8, - EOpConvIntToUint16, - EOpConvIntToUint, - EOpConvIntToUint64, - - // uint32_t -> (u)int* - EOpConvUintToInt8, - EOpConvUintToInt16, - EOpConvUintToInt, - EOpConvUintToInt64, - EOpConvUintToUint8, - EOpConvUintToUint16, - EOpConvUintToUint64, - - // int32_t -> float* - EOpConvIntToFloat16, - EOpConvIntToFloat, - EOpConvIntToDouble, - - // uint32_t -> float* - EOpConvUintToFloat16, - EOpConvUintToFloat, - EOpConvUintToDouble, - - // int64_t -> (u)int* - EOpConvInt64ToInt8, - EOpConvInt64ToInt16, - EOpConvInt64ToInt, - EOpConvInt64ToUint8, - EOpConvInt64ToUint16, - EOpConvInt64ToUint, - EOpConvInt64ToUint64, - - // uint64_t -> (u)int* - EOpConvUint64ToInt8, - EOpConvUint64ToInt16, - EOpConvUint64ToInt, - EOpConvUint64ToInt64, - EOpConvUint64ToUint8, - EOpConvUint64ToUint16, - EOpConvUint64ToUint, - - // int64_t -> float* - EOpConvInt64ToFloat16, - EOpConvInt64ToFloat, - EOpConvInt64ToDouble, - - // uint64_t -> float* - EOpConvUint64ToFloat16, - EOpConvUint64ToFloat, - EOpConvUint64ToDouble, - - // float16_t -> (u)int* - EOpConvFloat16ToInt8, - EOpConvFloat16ToInt16, - EOpConvFloat16ToInt, - EOpConvFloat16ToInt64, - EOpConvFloat16ToUint8, - EOpConvFloat16ToUint16, - EOpConvFloat16ToUint, - EOpConvFloat16ToUint64, - - // float16_t -> float* - EOpConvFloat16ToFloat, - EOpConvFloat16ToDouble, - - // float -> (u)int* - EOpConvFloatToInt8, - EOpConvFloatToInt16, - EOpConvFloatToInt, - EOpConvFloatToInt64, - EOpConvFloatToUint8, - EOpConvFloatToUint16, - EOpConvFloatToUint, - EOpConvFloatToUint64, - - // float -> float* - EOpConvFloatToFloat16, - EOpConvFloatToDouble, - - // float64 _t-> (u)int* - EOpConvDoubleToInt8, - EOpConvDoubleToInt16, - EOpConvDoubleToInt, - EOpConvDoubleToInt64, - EOpConvDoubleToUint8, - EOpConvDoubleToUint16, - EOpConvDoubleToUint, - EOpConvDoubleToUint64, - - // float64_t -> float* - EOpConvDoubleToFloat16, - EOpConvDoubleToFloat, + // Operator used to represent all conversions between int, float, and bool. + // The specific types are inferred from TBasicType. + EOpConvNumeric, // uint64_t <-> pointer EOpConvUint64ToPtr, @@ -628,7 +448,24 @@ enum TOperator { EOpCooperativeMatrixMulAdd, EOpCooperativeMatrixLoadNV, EOpCooperativeMatrixStoreNV, + EOpCooperativeMatrixLoadTensorNV, + EOpCooperativeMatrixStoreTensorNV, EOpCooperativeMatrixMulAddNV, + EOpCooperativeMatrixReduceNV, + EOpCooperativeMatrixPerElementOpNV, + EOpCooperativeMatrixTransposeNV, + + EOpCreateTensorLayoutNV, + EOpTensorLayoutSetBlockSizeNV, + EOpTensorLayoutSetDimensionNV, + EOpTensorLayoutSetStrideNV, + EOpTensorLayoutSliceNV, + EOpTensorLayoutSetClampValueNV, + + EOpCreateTensorViewNV, + EOpTensorViewSetDimensionNV, + EOpTensorViewSetStrideNV, + EOpTensorViewSetClipNV, EOpBeginInvocationInterlock, // Fragment only EOpEndInvocationInterlock, // Fragment only @@ -1119,6 +956,10 @@ enum TOperator { EOpImageBlockMatchGatherSADQCOM, }; +inline bool IsOpNumericConv(const TOperator op) { + return op == EOpConvNumeric; +} + enum TLinkType { ELinkNone, ELinkExport, @@ -1356,11 +1197,19 @@ public: // if symbol is initialized as symbol(sym), the memory comes from the pool allocator of sym. If sym comes from // per process threadPoolAllocator, then it causes increased memory usage per compile // it is essential to use "symbol = sym" to assign to symbol - TIntermSymbol(long long i, const TString& n, const TType& t) - : TIntermTyped(t), id(i), flattenSubset(-1), constSubtree(nullptr) { name = n; } + TIntermSymbol(long long i, const TString& n, EShLanguage s, const TType& t, const TString* mn = nullptr) + : TIntermTyped(t), id(i), flattenSubset(-1), stage(s), constSubtree(nullptr) { + name = n; + if (mn) { + mangledName = *mn; + } else { + mangledName = n; + } + } virtual long long getId() const { return id; } virtual void changeId(long long i) { id = i; } virtual const TString& getName() const { return name; } + virtual const TString& getMangledName() const { return mangledName; } virtual void traverse(TIntermTraverser*); virtual TIntermSymbol* getAsSymbolNode() { return this; } virtual const TIntermSymbol* getAsSymbolNode() const { return this; } @@ -1376,11 +1225,14 @@ public: // This is meant for cases where a node has already been constructed, and // later on, it becomes necessary to switch to a different symbol. virtual void switchId(long long newId) { id = newId; } + EShLanguage getStage() const { return stage; } protected: long long id; // the unique id of the symbol this node represents int flattenSubset; // how deeply the flattened object rooted at id has been dereferenced TString name; // the name of the symbol this node represents + EShLanguage stage; + TString mangledName; // mangled function name, or a copy of name if not a function TConstUnionArray constArray; // if the symbol is a front-end compile-time constant, this is its value TIntermTyped* constSubtree; }; diff --git a/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp b/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp index 7a9fb2ed6..2878be8d1 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp @@ -490,6 +490,163 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) // Process component-wise operations for (int i = 0; i < objectSize; i++) { + // First read the value and convert to i64/u64/f64/bool, then convert + // to the destination type (still 64b), then convert down to the + // destination size. + if (IsOpNumericConv(op)) { + enum ConvType { CONV_FLOAT, CONV_INT, CONV_UINT, CONV_BOOL }; + ConvType srcType = CONV_UINT, dstType = CONV_UINT; + double valf = 0.0; + uint64_t valu = 0; + int64_t vali = 0; + bool valb = false; + switch (getType().getBasicType()) { + case EbtDouble: + case EbtFloat16: + case EbtFloat: + valf = unionArray[i].getDConst(); + srcType = CONV_FLOAT; + break; + case EbtInt8: + vali = unionArray[i].getI8Const(); + srcType = CONV_INT; + break; + case EbtInt16: + vali = unionArray[i].getI16Const(); + srcType = CONV_INT; + break; + case EbtInt: + vali = unionArray[i].getIConst(); + srcType = CONV_INT; + break; + case EbtInt64: + vali = unionArray[i].getI64Const(); + srcType = CONV_INT; + break; + case EbtUint8: + valu = unionArray[i].getU8Const(); + srcType = CONV_UINT; + break; + case EbtUint16: + valu = unionArray[i].getU16Const(); + srcType = CONV_UINT; + break; + case EbtUint: + valu = unionArray[i].getUConst(); + srcType = CONV_UINT; + break; + case EbtUint64: + valu = unionArray[i].getU64Const(); + srcType = CONV_UINT; + break; + case EbtBool: + valb = unionArray[i].getBConst(); + srcType = CONV_BOOL; + break; + default: + assert(0); + break; + } + + switch (returnType.getBasicType()) { + case EbtDouble: + case EbtFloat16: + case EbtFloat: + dstType = CONV_FLOAT; + break; + case EbtInt8: + case EbtInt16: + case EbtInt: + case EbtInt64: + dstType = CONV_INT; + break; + case EbtUint8: + case EbtUint16: + case EbtUint: + case EbtUint64: + dstType = CONV_UINT; + break; + case EbtBool: + dstType = CONV_BOOL; + break; + default: + assert(0); + break; + } + if (dstType == CONV_BOOL) { + switch (srcType) { + case CONV_FLOAT: + valb = (valf != 0.0); break; + case CONV_INT: + valb = (vali != 0.0); break; + case CONV_UINT: + valb = (valu != 0.0); break; + default: + break; + } + } else if (dstType == CONV_FLOAT) { + switch (srcType) { + case CONV_BOOL: + valf = (double)valb; break; + case CONV_INT: + valf = (double)vali; break; + case CONV_UINT: + valf = (double)valu; break; + default: + break; + } + } else if (dstType == CONV_INT) { + switch (srcType) { + case CONV_BOOL: + vali = (int64_t)valb; break; + case CONV_FLOAT: + vali = (int64_t)valf; break; + case CONV_UINT: + vali = (int64_t)valu; break; + default: + break; + } + } else if (dstType == CONV_UINT) { + switch (srcType) { + case CONV_BOOL: + valu = (uint64_t)valb; break; + case CONV_FLOAT: + valu = (uint64_t)valf; break; + case CONV_INT: + valu = (uint64_t)vali; break; + default: + break; + } + } + switch (returnType.getBasicType()) { + case EbtDouble: + case EbtFloat16: + case EbtFloat: + newConstArray[i].setDConst(valf); break; + case EbtInt8: + newConstArray[i].setI8Const(static_cast(vali)); break; + case EbtInt16: + newConstArray[i].setI16Const(static_cast(vali)); break; + case EbtInt: + newConstArray[i].setIConst(static_cast(vali)); break; + case EbtInt64: + newConstArray[i].setI64Const(vali); break; + case EbtUint8: + newConstArray[i].setU8Const(static_cast(valu)); break; + case EbtUint16: + newConstArray[i].setU16Const(static_cast(valu)); break; + case EbtUint: + newConstArray[i].setUConst(static_cast(valu)); break; + case EbtUint64: + newConstArray[i].setU64Const(valu); break; + case EbtBool: + newConstArray[i].setBConst(valb); break; + default: + assert(0); + break; + } + continue; + } switch (op) { case EOpNegative: switch (getType().getBasicType()) { @@ -641,277 +798,6 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) break; } - case EOpConvIntToBool: - newConstArray[i].setBConst(unionArray[i].getIConst() != 0); break; - case EOpConvUintToBool: - newConstArray[i].setBConst(unionArray[i].getUConst() != 0); break; - case EOpConvBoolToInt: - newConstArray[i].setIConst(unionArray[i].getBConst()); break; - case EOpConvBoolToUint: - newConstArray[i].setUConst(unionArray[i].getBConst()); break; - case EOpConvIntToUint: - newConstArray[i].setUConst(unionArray[i].getIConst()); break; - case EOpConvUintToInt: - newConstArray[i].setIConst(unionArray[i].getUConst()); break; - - case EOpConvFloatToBool: - case EOpConvDoubleToBool: - newConstArray[i].setBConst(unionArray[i].getDConst() != 0); break; - - case EOpConvBoolToFloat: - case EOpConvBoolToDouble: - newConstArray[i].setDConst(unionArray[i].getBConst()); break; - - case EOpConvIntToFloat: - case EOpConvIntToDouble: - newConstArray[i].setDConst(unionArray[i].getIConst()); break; - - case EOpConvUintToFloat: - case EOpConvUintToDouble: - newConstArray[i].setDConst(unionArray[i].getUConst()); break; - - case EOpConvDoubleToFloat: - case EOpConvFloatToDouble: - newConstArray[i].setDConst(unionArray[i].getDConst()); break; - - case EOpConvFloatToUint: - case EOpConvDoubleToUint: - newConstArray[i].setUConst(static_cast(unionArray[i].getDConst())); break; - - case EOpConvFloatToInt: - case EOpConvDoubleToInt: - newConstArray[i].setIConst(static_cast(unionArray[i].getDConst())); break; - - case EOpConvInt8ToBool: - newConstArray[i].setBConst(unionArray[i].getI8Const() != 0); break; - case EOpConvUint8ToBool: - newConstArray[i].setBConst(unionArray[i].getU8Const() != 0); break; - case EOpConvInt16ToBool: - newConstArray[i].setBConst(unionArray[i].getI16Const() != 0); break; - case EOpConvUint16ToBool: - newConstArray[i].setBConst(unionArray[i].getU16Const() != 0); break; - case EOpConvInt64ToBool: - newConstArray[i].setBConst(unionArray[i].getI64Const() != 0); break; - case EOpConvUint64ToBool: - newConstArray[i].setBConst(unionArray[i].getU64Const() != 0); break; - case EOpConvFloat16ToBool: - newConstArray[i].setBConst(unionArray[i].getDConst() != 0); break; - - case EOpConvBoolToInt8: - newConstArray[i].setI8Const(unionArray[i].getBConst()); break; - case EOpConvBoolToUint8: - newConstArray[i].setU8Const(unionArray[i].getBConst()); break; - case EOpConvBoolToInt16: - newConstArray[i].setI16Const(unionArray[i].getBConst()); break; - case EOpConvBoolToUint16: - newConstArray[i].setU16Const(unionArray[i].getBConst()); break; - case EOpConvBoolToInt64: - newConstArray[i].setI64Const(unionArray[i].getBConst()); break; - case EOpConvBoolToUint64: - newConstArray[i].setU64Const(unionArray[i].getBConst()); break; - case EOpConvBoolToFloat16: - newConstArray[i].setDConst(unionArray[i].getBConst()); break; - - case EOpConvInt8ToInt16: - newConstArray[i].setI16Const(unionArray[i].getI8Const()); break; - case EOpConvInt8ToInt: - newConstArray[i].setIConst(unionArray[i].getI8Const()); break; - case EOpConvInt8ToInt64: - newConstArray[i].setI64Const(unionArray[i].getI8Const()); break; - case EOpConvInt8ToUint8: - newConstArray[i].setU8Const(unionArray[i].getI8Const()); break; - case EOpConvInt8ToUint16: - newConstArray[i].setU16Const(unionArray[i].getI8Const()); break; - case EOpConvInt8ToUint: - newConstArray[i].setUConst(unionArray[i].getI8Const()); break; - case EOpConvInt8ToUint64: - newConstArray[i].setU64Const(unionArray[i].getI8Const()); break; - case EOpConvUint8ToInt8: - newConstArray[i].setI8Const(unionArray[i].getU8Const()); break; - case EOpConvUint8ToInt16: - newConstArray[i].setI16Const(unionArray[i].getU8Const()); break; - case EOpConvUint8ToInt: - newConstArray[i].setIConst(unionArray[i].getU8Const()); break; - case EOpConvUint8ToInt64: - newConstArray[i].setI64Const(unionArray[i].getU8Const()); break; - case EOpConvUint8ToUint16: - newConstArray[i].setU16Const(unionArray[i].getU8Const()); break; - case EOpConvUint8ToUint: - newConstArray[i].setUConst(unionArray[i].getU8Const()); break; - case EOpConvUint8ToUint64: - newConstArray[i].setU64Const(unionArray[i].getU8Const()); break; - case EOpConvInt8ToFloat16: - newConstArray[i].setDConst(unionArray[i].getI8Const()); break; - case EOpConvInt8ToFloat: - newConstArray[i].setDConst(unionArray[i].getI8Const()); break; - case EOpConvInt8ToDouble: - newConstArray[i].setDConst(unionArray[i].getI8Const()); break; - case EOpConvUint8ToFloat16: - newConstArray[i].setDConst(unionArray[i].getU8Const()); break; - case EOpConvUint8ToFloat: - newConstArray[i].setDConst(unionArray[i].getU8Const()); break; - case EOpConvUint8ToDouble: - newConstArray[i].setDConst(unionArray[i].getU8Const()); break; - - case EOpConvInt16ToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getI16Const())); break; - case EOpConvInt16ToInt: - newConstArray[i].setIConst(unionArray[i].getI16Const()); break; - case EOpConvInt16ToInt64: - newConstArray[i].setI64Const(unionArray[i].getI16Const()); break; - case EOpConvInt16ToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getI16Const())); break; - case EOpConvInt16ToUint16: - newConstArray[i].setU16Const(unionArray[i].getI16Const()); break; - case EOpConvInt16ToUint: - newConstArray[i].setUConst(unionArray[i].getI16Const()); break; - case EOpConvInt16ToUint64: - newConstArray[i].setU64Const(unionArray[i].getI16Const()); break; - case EOpConvUint16ToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getU16Const())); break; - case EOpConvUint16ToInt16: - newConstArray[i].setI16Const(unionArray[i].getU16Const()); break; - case EOpConvUint16ToInt: - newConstArray[i].setIConst(unionArray[i].getU16Const()); break; - case EOpConvUint16ToInt64: - newConstArray[i].setI64Const(unionArray[i].getU16Const()); break; - case EOpConvUint16ToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getU16Const())); break; - - case EOpConvUint16ToUint: - newConstArray[i].setUConst(unionArray[i].getU16Const()); break; - case EOpConvUint16ToUint64: - newConstArray[i].setU64Const(unionArray[i].getU16Const()); break; - case EOpConvInt16ToFloat16: - newConstArray[i].setDConst(unionArray[i].getI16Const()); break; - case EOpConvInt16ToFloat: - newConstArray[i].setDConst(unionArray[i].getI16Const()); break; - case EOpConvInt16ToDouble: - newConstArray[i].setDConst(unionArray[i].getI16Const()); break; - case EOpConvUint16ToFloat16: - newConstArray[i].setDConst(unionArray[i].getU16Const()); break; - case EOpConvUint16ToFloat: - newConstArray[i].setDConst(unionArray[i].getU16Const()); break; - case EOpConvUint16ToDouble: - newConstArray[i].setDConst(unionArray[i].getU16Const()); break; - - case EOpConvIntToInt8: - newConstArray[i].setI8Const((signed char)unionArray[i].getIConst()); break; - case EOpConvIntToInt16: - newConstArray[i].setI16Const((signed short)unionArray[i].getIConst()); break; - case EOpConvIntToInt64: - newConstArray[i].setI64Const(unionArray[i].getIConst()); break; - case EOpConvIntToUint8: - newConstArray[i].setU8Const((unsigned char)unionArray[i].getIConst()); break; - case EOpConvIntToUint16: - newConstArray[i].setU16Const((unsigned char)unionArray[i].getIConst()); break; - case EOpConvIntToUint64: - newConstArray[i].setU64Const(unionArray[i].getIConst()); break; - - case EOpConvUintToInt8: - newConstArray[i].setI8Const((signed char)unionArray[i].getUConst()); break; - case EOpConvUintToInt16: - newConstArray[i].setI16Const((signed short)unionArray[i].getUConst()); break; - case EOpConvUintToInt64: - newConstArray[i].setI64Const(unionArray[i].getUConst()); break; - case EOpConvUintToUint8: - newConstArray[i].setU8Const((unsigned char)unionArray[i].getUConst()); break; - case EOpConvUintToUint16: - newConstArray[i].setU16Const((unsigned short)unionArray[i].getUConst()); break; - case EOpConvUintToUint64: - newConstArray[i].setU64Const(unionArray[i].getUConst()); break; - case EOpConvIntToFloat16: - newConstArray[i].setDConst(unionArray[i].getIConst()); break; - case EOpConvUintToFloat16: - newConstArray[i].setDConst(unionArray[i].getUConst()); break; - case EOpConvInt64ToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToInt16: - newConstArray[i].setI16Const(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToInt: - newConstArray[i].setIConst(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToUint16: - newConstArray[i].setU16Const(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToUint: - newConstArray[i].setUConst(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToUint64: - newConstArray[i].setU64Const(unionArray[i].getI64Const()); break; - case EOpConvUint64ToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToInt16: - newConstArray[i].setI16Const(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToInt: - newConstArray[i].setIConst(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToInt64: - newConstArray[i].setI64Const(unionArray[i].getU64Const()); break; - case EOpConvUint64ToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToUint16: - newConstArray[i].setU16Const(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToUint: - newConstArray[i].setUConst(static_cast(unionArray[i].getU64Const())); break; - case EOpConvInt64ToFloat16: - newConstArray[i].setDConst(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToFloat: - newConstArray[i].setDConst(static_cast(unionArray[i].getI64Const())); break; - case EOpConvInt64ToDouble: - newConstArray[i].setDConst(static_cast(unionArray[i].getI64Const())); break; - case EOpConvUint64ToFloat16: - newConstArray[i].setDConst(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToFloat: - newConstArray[i].setDConst(static_cast(unionArray[i].getU64Const())); break; - case EOpConvUint64ToDouble: - newConstArray[i].setDConst(static_cast(unionArray[i].getU64Const())); break; - case EOpConvFloat16ToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToInt16: - newConstArray[i].setI16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToInt: - newConstArray[i].setIConst(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToInt64: - newConstArray[i].setI64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToUint16: - newConstArray[i].setU16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToUint: - newConstArray[i].setUConst(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToUint64: - newConstArray[i].setU64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloat16ToFloat: - newConstArray[i].setDConst(unionArray[i].getDConst()); break; - case EOpConvFloat16ToDouble: - newConstArray[i].setDConst(unionArray[i].getDConst()); break; - case EOpConvFloatToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToInt16: - newConstArray[i].setI16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToInt64: - newConstArray[i].setI64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToUint16: - newConstArray[i].setU16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToUint64: - newConstArray[i].setU64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvFloatToFloat16: - newConstArray[i].setDConst(unionArray[i].getDConst()); break; - case EOpConvDoubleToInt8: - newConstArray[i].setI8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToInt16: - newConstArray[i].setI16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToInt64: - newConstArray[i].setI64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToUint8: - newConstArray[i].setU8Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToUint16: - newConstArray[i].setU16Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToUint64: - newConstArray[i].setU64Const(static_cast(unionArray[i].getDConst())); break; - case EOpConvDoubleToFloat16: - newConstArray[i].setDConst(unionArray[i].getDConst()); break; case EOpConvPtrToUint64: case EOpConvUint64ToPtr: case EOpConstructReference: diff --git a/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp b/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp index d8a969d77..abab968f2 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp @@ -52,6 +52,7 @@ // #include +#include #include "Initialize.h" #include "span.h" @@ -4473,83 +4474,41 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "ucoopmatNV coopMatMulAddNV(ucoopmatNV A, ucoopmatNV B, ucoopmatNV C);\n" ); - std::string cooperativeMatrixFuncs = - "void coopMatLoad(out coopmat m, volatile coherent int8_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent int16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent int32_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent int64_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent uint8_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent uint16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent uint32_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent uint64_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent float16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent float[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent float64_t[] buf, uint element, uint stride, int matrixLayout);\n" + std::stringstream cooperativeMatrixFuncs; - "void coopMatLoad(out coopmat m, volatile coherent i8vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u8vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - - "void coopMatLoad(out coopmat m, volatile coherent i8vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent i64vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u8vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent u64vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatLoad(out coopmat m, volatile coherent f64vec4[] buf, uint element, uint stride, int matrixLayout);\n" - - "void coopMatStore(coopmat m, volatile coherent int8_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent int16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent int32_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent int64_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent uint8_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent uint16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent uint32_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent uint64_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent float16_t[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent float[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent float64_t[] buf, uint element, uint stride, int matrixLayout);\n" - - "void coopMatStore(coopmat m, volatile coherent i8vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u8vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f16vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f32vec2[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f64vec2[] buf, uint element, uint stride, int matrixLayout);\n" - - "void coopMatStore(coopmat m, volatile coherent i8vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent i64vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u8vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent u64vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f16vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f32vec4[] buf, uint element, uint stride, int matrixLayout);\n" - "void coopMatStore(coopmat m, volatile coherent f64vec4[] buf, uint element, uint stride, int matrixLayout);\n" + { + static const char *allTypes[] = + { + "float", "vec2", "vec4", + "float16_t", "f16vec2", "f16vec4", + "double", "dvec2", "dvec4", + "int8_t", "i8vec2", "i8vec4", + "int16_t", "i16vec2", "i16vec4", + "int", "ivec2", "ivec4", + "int64_t", "i64vec2", "i64vec4", + "uint8_t", "u8vec2", "u8vec4", + "uint16_t", "u16vec2", "u16vec4", + "uint", "uvec2", "uvec4", + "uint64_t", "u64vec2", "u64vec4", + }; + for (auto t : allTypes) { + cooperativeMatrixFuncs << "void coopMatLoad(out coopmat m, volatile coherent " << t << "[] buf, uint element, uint stride, int matrixLayout);\n"; + cooperativeMatrixFuncs << "void coopMatStore(coopmat m, volatile coherent " << t << "[] buf, uint element, uint stride, int matrixLayout);\n"; + } + // Just use uint8_t for buffer type, we have special matching rules to allow any conversion + cooperativeMatrixFuncs << "void coopMatLoadTensorNV(inout coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t);\n"; + cooperativeMatrixFuncs << "void coopMatLoadTensorNV(inout coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t, tensorViewNV v);\n"; + cooperativeMatrixFuncs << "void coopMatLoadTensorNV(inout coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t, __function f);\n"; + cooperativeMatrixFuncs << "void coopMatLoadTensorNV(inout coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t, tensorViewNV v, __function f);\n"; + cooperativeMatrixFuncs << "void coopMatStoreTensorNV(coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t);\n"; + cooperativeMatrixFuncs << "void coopMatStoreTensorNV(coopmat m, volatile coherent uint8_t[] buf, uint element, tensorLayoutNV t, tensorViewNV v);\n"; + } + cooperativeMatrixFuncs << "coopmat coopMatMulAdd(coopmat A, coopmat B, coopmat C);\n" "coopmat coopMatMulAdd(coopmat A, coopmat B, coopmat C, int matrixOperands);\n"; - commonBuiltins.append(cooperativeMatrixFuncs.c_str()); + commonBuiltins.append(cooperativeMatrixFuncs.str().c_str()); commonBuiltins.append( "const int gl_MatrixUseA = 0;\n" @@ -4562,6 +4521,83 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "const int gl_CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203;\n" "\n" ); + + commonBuiltins.append( + "void coopMatTransposeNV(out coopmat, coopmat);" + "void coopMatReduceNV(out coopmat, coopmat, int, __function);" + "void coopMatPerElementNV();" + ); + + commonBuiltins.append( + "const int gl_CooperativeMatrixReduceRowNV = 0x1;\n" + "const int gl_CooperativeMatrixReduceColumnNV = 0x2;\n" + "const int gl_CooperativeMatrixReduceRowAndColumnNV = 0x3;\n" + "const int gl_CooperativeMatrixReduce2x2NV = 0x4;\n" + "\n" + ); + + commonBuiltins.append( + "const int gl_CooperativeMatrixClampModeUndefinedNV = 0x0;\n" + "const int gl_CooperativeMatrixClampModeConstantNV = 0x1;\n" + "const int gl_CooperativeMatrixClampModeClampToEdgeNV = 0x2;\n" + "const int gl_CooperativeMatrixClampModeRepeatNV = 0x3;\n" + "const int gl_CooperativeMatrixClampModeMirrorRepeatNV = 0x4;\n" + "\n" + ); + + commonBuiltins.append( + "tensorLayoutNV createTensorLayoutNV(uint Dim);\n" + "tensorLayoutNV createTensorLayoutNV(uint Dim, uint Mode);\n" + + "tensorLayoutNV setTensorLayoutBlockSizeNV(tensorLayoutNV t, uint blockSize0);\n" + "tensorLayoutNV setTensorLayoutBlockSizeNV(tensorLayoutNV t, uint blockSize0, uint blockSize1);\n" + "tensorLayoutNV setTensorLayoutBlockSizeNV(tensorLayoutNV t, uint blockSize0, uint blockSize1, uint blockSize2);\n" + "tensorLayoutNV setTensorLayoutBlockSizeNV(tensorLayoutNV t, uint blockSize0, uint blockSize1, uint blockSize2, uint blockSize3);\n" + "tensorLayoutNV setTensorLayoutBlockSizeNV(tensorLayoutNV t, uint blockSize0, uint blockSize1, uint blockSize2, uint blockSize3, uint blockSize4);\n" + + "tensorLayoutNV setTensorLayoutDimensionNV(tensorLayoutNV t, uint dim0);\n" + "tensorLayoutNV setTensorLayoutDimensionNV(tensorLayoutNV t, uint dim0, uint dim1);\n" + "tensorLayoutNV setTensorLayoutDimensionNV(tensorLayoutNV t, uint dim0, uint dim1, uint dim2);\n" + "tensorLayoutNV setTensorLayoutDimensionNV(tensorLayoutNV t, uint dim0, uint dim1, uint dim2, uint dim3);\n" + "tensorLayoutNV setTensorLayoutDimensionNV(tensorLayoutNV t, uint dim0, uint dim1, uint dim2, uint dim3, uint dim4);\n" + + "tensorLayoutNV setTensorLayoutStrideNV(tensorLayoutNV t, uint stride0);\n" + "tensorLayoutNV setTensorLayoutStrideNV(tensorLayoutNV t, uint stride0, uint stride1);\n" + "tensorLayoutNV setTensorLayoutStrideNV(tensorLayoutNV t, uint stride0, uint stride1, uint stride2);\n" + "tensorLayoutNV setTensorLayoutStrideNV(tensorLayoutNV t, uint stride0, uint stride1, uint stride2, uint stride3);\n" + "tensorLayoutNV setTensorLayoutStrideNV(tensorLayoutNV t, uint stride0, uint stride1, uint stride2, uint stride3, uint stride4);\n" + + "tensorLayoutNV sliceTensorLayoutNV(tensorLayoutNV t, uint offset0, uint span0);\n" + "tensorLayoutNV sliceTensorLayoutNV(tensorLayoutNV t, uint offset0, uint span0, uint offset1, uint span1);\n" + "tensorLayoutNV sliceTensorLayoutNV(tensorLayoutNV t, uint offset0, uint span0, uint offset1, uint span1, uint offset2, uint span2);\n" + "tensorLayoutNV sliceTensorLayoutNV(tensorLayoutNV t, uint offset0, uint span0, uint offset1, uint span1, uint offset2, uint span2, uint offset3, uint span3);\n" + "tensorLayoutNV sliceTensorLayoutNV(tensorLayoutNV t, uint offset0, uint span0, uint offset1, uint span1, uint offset2, uint span2, uint offset3, uint span3, uint offset4, uint span4);\n" + + "tensorLayoutNV setTensorLayoutClampValueNV(tensorLayoutNV t, uint value);\n" + + "tensorViewNV createTensorViewNV(uint Dim);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions, uint p0);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions, uint p0, uint p1);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions, uint p0, uint p1, uint p2);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions, uint p0, uint p1, uint p2, uint p3);\n" + "tensorViewNV createTensorViewNV(uint Dim, bool HasDimensions, uint p0, uint p1, uint p2, uint p3, uint p4);\n" + + "tensorViewNV setTensorViewDimensionsNV(tensorViewNV v, uint dim0);\n" + "tensorViewNV setTensorViewDimensionsNV(tensorViewNV v, uint dim0, uint dim1);\n" + "tensorViewNV setTensorViewDimensionsNV(tensorViewNV v, uint dim0, uint dim1, uint dim2);\n" + "tensorViewNV setTensorViewDimensionsNV(tensorViewNV v, uint dim0, uint dim1, uint dim2, uint dim3);\n" + "tensorViewNV setTensorViewDimensionsNV(tensorViewNV v, uint dim0, uint dim1, uint dim2, uint dim3, uint dim4);\n" + + "tensorViewNV setTensorViewStrideNV(tensorViewNV v, uint stride0);\n" + "tensorViewNV setTensorViewStrideNV(tensorViewNV v, uint stride0, uint stride1);\n" + "tensorViewNV setTensorViewStrideNV(tensorViewNV v, uint stride0, uint stride1, uint stride2);\n" + "tensorViewNV setTensorViewStrideNV(tensorViewNV v, uint stride0, uint stride1, uint stride2, uint stride3);\n" + "tensorViewNV setTensorViewStrideNV(tensorViewNV v, uint stride0, uint stride1, uint stride2, uint stride3, uint stride4);\n" + + "tensorViewNV setTensorViewClipNV(tensorViewNV v, uint clipRowOffset, uint clipRowSpan, uint clipColOffset, uint clipColSpan);\n" + "\n" + ); } //============================================================================ @@ -9066,6 +9102,22 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("coopMatLoad", 1, &E_GL_KHR_cooperative_matrix); symbolTable.setFunctionExtensions("coopMatStore", 1, &E_GL_KHR_cooperative_matrix); symbolTable.setFunctionExtensions("coopMatMulAdd", 1, &E_GL_KHR_cooperative_matrix); + + symbolTable.setFunctionExtensions("coopMatReduceNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("coopMatPerElementNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("coopMatTransposeNV", 1, &E_GL_NV_cooperative_matrix2); + + symbolTable.setFunctionExtensions("createTensorLayoutNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorLayoutBlockSizeNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorLayoutDimensionNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorLayoutStrideNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("sliceTensorLayoutNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorLayoutClampValueNV", 1, &E_GL_NV_cooperative_matrix2); + + symbolTable.setFunctionExtensions("createTensorViewNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorViewDimensionsNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorViewStrideNV", 1, &E_GL_NV_cooperative_matrix2); + symbolTable.setFunctionExtensions("setTensorViewClipNV", 1, &E_GL_NV_cooperative_matrix2); } if ((profile != EEsProfile && version >= 450) || (profile == EEsProfile && version >= 320)) { @@ -10241,6 +10293,25 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("coopMatStore", EOpCooperativeMatrixStore); symbolTable.relateToOperator("coopMatMulAdd", EOpCooperativeMatrixMulAdd); + symbolTable.relateToOperator("coopMatLoadTensorNV", EOpCooperativeMatrixLoadTensorNV); + symbolTable.relateToOperator("coopMatStoreTensorNV", EOpCooperativeMatrixStoreTensorNV); + + symbolTable.relateToOperator("coopMatReduceNV", EOpCooperativeMatrixReduceNV); + symbolTable.relateToOperator("coopMatPerElementNV", EOpCooperativeMatrixPerElementOpNV); + symbolTable.relateToOperator("coopMatTransposeNV", EOpCooperativeMatrixTransposeNV); + + symbolTable.relateToOperator("createTensorLayoutNV", EOpCreateTensorLayoutNV); + symbolTable.relateToOperator("setTensorLayoutBlockSizeNV", EOpTensorLayoutSetBlockSizeNV); + symbolTable.relateToOperator("setTensorLayoutDimensionNV", EOpTensorLayoutSetDimensionNV); + symbolTable.relateToOperator("setTensorLayoutStrideNV", EOpTensorLayoutSetStrideNV); + symbolTable.relateToOperator("sliceTensorLayoutNV", EOpTensorLayoutSliceNV); + symbolTable.relateToOperator("setTensorLayoutClampValueNV", EOpTensorLayoutSetClampValueNV); + + symbolTable.relateToOperator("createTensorViewNV", EOpCreateTensorViewNV); + symbolTable.relateToOperator("setTensorViewDimensionsNV", EOpTensorViewSetDimensionNV); + symbolTable.relateToOperator("setTensorViewStrideNV", EOpTensorViewSetStrideNV); + symbolTable.relateToOperator("setTensorViewClipNV", EOpTensorViewSetClipNV); + if (profile != EEsProfile && version >= 460) { symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV); symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV); diff --git a/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp b/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp index 63e176e3a..7f707c8a3 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp @@ -65,10 +65,10 @@ namespace glslang { // Returns the added node. // -TIntermSymbol* TIntermediate::addSymbol(long long id, const TString& name, const TType& type, const TConstUnionArray& constArray, +TIntermSymbol* TIntermediate::addSymbol(long long id, const TString& name, const TString& mangledName, const TType& type, const TConstUnionArray& constArray, TIntermTyped* constSubtree, const TSourceLoc& loc) { - TIntermSymbol* node = new TIntermSymbol(id, name, type); + TIntermSymbol* node = new TIntermSymbol(id, name, getStage(), type, &mangledName); node->setLoc(loc); node->setConstArray(constArray); node->setConstSubtree(constSubtree); @@ -80,6 +80,7 @@ TIntermSymbol* TIntermediate::addSymbol(const TIntermSymbol& intermSymbol) { return addSymbol(intermSymbol.getId(), intermSymbol.getName(), + intermSymbol.getMangledName(), intermSymbol.getType(), intermSymbol.getConstArray(), intermSymbol.getConstSubtree(), @@ -96,14 +97,14 @@ TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable) TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable, const TSourceLoc& loc) { - return addSymbol(variable.getUniqueId(), variable.getName(), variable.getType(), variable.getConstArray(), variable.getConstSubtree(), loc); + return addSymbol(variable.getUniqueId(), variable.getName(), variable.getMangledName(), variable.getType(), variable.getConstArray(), variable.getConstSubtree(), loc); } TIntermSymbol* TIntermediate::addSymbol(const TType& type, const TSourceLoc& loc) { TConstUnionArray unionArray; // just a null constant - return addSymbol(0, "", type, unionArray, nullptr, loc); + return addSymbol(0, "", "", type, unionArray, nullptr, loc); } // @@ -163,8 +164,8 @@ TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIn left = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, left, TType(EbtUint64)); right = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, right, TType(EbtUint64)); - left = addBuiltInFunctionCall(loc, EOpConvUint64ToInt64, true, left, TType(EbtInt64)); - right = addBuiltInFunctionCall(loc, EOpConvUint64ToInt64, true, right, TType(EbtInt64)); + left = addBuiltInFunctionCall(loc, EOpConvNumeric, true, left, TType(EbtInt64)); + right = addBuiltInFunctionCall(loc, EOpConvNumeric, true, right, TType(EbtInt64)); left = addBinaryMath(EOpSub, left, right, loc); @@ -567,222 +568,12 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const bool TIntermediate::buildConvertOp(TBasicType dst, TBasicType src, TOperator& newOp) const { - switch (dst) { - case EbtDouble: - switch (src) { - case EbtUint: newOp = EOpConvUintToDouble; break; - case EbtBool: newOp = EOpConvBoolToDouble; break; - case EbtFloat: newOp = EOpConvFloatToDouble; break; - case EbtInt: newOp = EOpConvIntToDouble; break; - case EbtInt8: newOp = EOpConvInt8ToDouble; break; - case EbtUint8: newOp = EOpConvUint8ToDouble; break; - case EbtInt16: newOp = EOpConvInt16ToDouble; break; - case EbtUint16: newOp = EOpConvUint16ToDouble; break; - case EbtFloat16: newOp = EOpConvFloat16ToDouble; break; - case EbtInt64: newOp = EOpConvInt64ToDouble; break; - case EbtUint64: newOp = EOpConvUint64ToDouble; break; - default: - return false; - } - break; - case EbtFloat: - switch (src) { - case EbtInt: newOp = EOpConvIntToFloat; break; - case EbtUint: newOp = EOpConvUintToFloat; break; - case EbtBool: newOp = EOpConvBoolToFloat; break; - case EbtDouble: newOp = EOpConvDoubleToFloat; break; - case EbtInt8: newOp = EOpConvInt8ToFloat; break; - case EbtUint8: newOp = EOpConvUint8ToFloat; break; - case EbtInt16: newOp = EOpConvInt16ToFloat; break; - case EbtUint16: newOp = EOpConvUint16ToFloat; break; - case EbtFloat16: newOp = EOpConvFloat16ToFloat; break; - case EbtInt64: newOp = EOpConvInt64ToFloat; break; - case EbtUint64: newOp = EOpConvUint64ToFloat; break; - default: - return false; - } - break; - case EbtFloat16: - switch (src) { - case EbtInt8: newOp = EOpConvInt8ToFloat16; break; - case EbtUint8: newOp = EOpConvUint8ToFloat16; break; - case EbtInt16: newOp = EOpConvInt16ToFloat16; break; - case EbtUint16: newOp = EOpConvUint16ToFloat16; break; - case EbtInt: newOp = EOpConvIntToFloat16; break; - case EbtUint: newOp = EOpConvUintToFloat16; break; - case EbtBool: newOp = EOpConvBoolToFloat16; break; - case EbtFloat: newOp = EOpConvFloatToFloat16; break; - case EbtDouble: newOp = EOpConvDoubleToFloat16; break; - case EbtInt64: newOp = EOpConvInt64ToFloat16; break; - case EbtUint64: newOp = EOpConvUint64ToFloat16; break; - default: - return false; - } - break; - case EbtBool: - switch (src) { - case EbtInt: newOp = EOpConvIntToBool; break; - case EbtUint: newOp = EOpConvUintToBool; break; - case EbtFloat: newOp = EOpConvFloatToBool; break; - case EbtDouble: newOp = EOpConvDoubleToBool; break; - case EbtInt8: newOp = EOpConvInt8ToBool; break; - case EbtUint8: newOp = EOpConvUint8ToBool; break; - case EbtInt16: newOp = EOpConvInt16ToBool; break; - case EbtUint16: newOp = EOpConvUint16ToBool; break; - case EbtFloat16: newOp = EOpConvFloat16ToBool; break; - case EbtInt64: newOp = EOpConvInt64ToBool; break; - case EbtUint64: newOp = EOpConvUint64ToBool; break; - default: - return false; - } - break; - case EbtInt8: - switch (src) { - case EbtUint8: newOp = EOpConvUint8ToInt8; break; - case EbtInt16: newOp = EOpConvInt16ToInt8; break; - case EbtUint16: newOp = EOpConvUint16ToInt8; break; - case EbtInt: newOp = EOpConvIntToInt8; break; - case EbtUint: newOp = EOpConvUintToInt8; break; - case EbtInt64: newOp = EOpConvInt64ToInt8; break; - case EbtUint64: newOp = EOpConvUint64ToInt8; break; - case EbtBool: newOp = EOpConvBoolToInt8; break; - case EbtFloat: newOp = EOpConvFloatToInt8; break; - case EbtDouble: newOp = EOpConvDoubleToInt8; break; - case EbtFloat16: newOp = EOpConvFloat16ToInt8; break; - default: - return false; - } - break; - case EbtUint8: - switch (src) { - case EbtInt8: newOp = EOpConvInt8ToUint8; break; - case EbtInt16: newOp = EOpConvInt16ToUint8; break; - case EbtUint16: newOp = EOpConvUint16ToUint8; break; - case EbtInt: newOp = EOpConvIntToUint8; break; - case EbtUint: newOp = EOpConvUintToUint8; break; - case EbtInt64: newOp = EOpConvInt64ToUint8; break; - case EbtUint64: newOp = EOpConvUint64ToUint8; break; - case EbtBool: newOp = EOpConvBoolToUint8; break; - case EbtFloat: newOp = EOpConvFloatToUint8; break; - case EbtDouble: newOp = EOpConvDoubleToUint8; break; - case EbtFloat16: newOp = EOpConvFloat16ToUint8; break; - default: - return false; - } - break; - - case EbtInt16: - switch (src) { - case EbtUint8: newOp = EOpConvUint8ToInt16; break; - case EbtInt8: newOp = EOpConvInt8ToInt16; break; - case EbtUint16: newOp = EOpConvUint16ToInt16; break; - case EbtInt: newOp = EOpConvIntToInt16; break; - case EbtUint: newOp = EOpConvUintToInt16; break; - case EbtInt64: newOp = EOpConvInt64ToInt16; break; - case EbtUint64: newOp = EOpConvUint64ToInt16; break; - case EbtBool: newOp = EOpConvBoolToInt16; break; - case EbtFloat: newOp = EOpConvFloatToInt16; break; - case EbtDouble: newOp = EOpConvDoubleToInt16; break; - case EbtFloat16: newOp = EOpConvFloat16ToInt16; break; - default: - return false; - } - break; - case EbtUint16: - switch (src) { - case EbtInt8: newOp = EOpConvInt8ToUint16; break; - case EbtUint8: newOp = EOpConvUint8ToUint16; break; - case EbtInt16: newOp = EOpConvInt16ToUint16; break; - case EbtInt: newOp = EOpConvIntToUint16; break; - case EbtUint: newOp = EOpConvUintToUint16; break; - case EbtInt64: newOp = EOpConvInt64ToUint16; break; - case EbtUint64: newOp = EOpConvUint64ToUint16; break; - case EbtBool: newOp = EOpConvBoolToUint16; break; - case EbtFloat: newOp = EOpConvFloatToUint16; break; - case EbtDouble: newOp = EOpConvDoubleToUint16; break; - case EbtFloat16: newOp = EOpConvFloat16ToUint16; break; - default: - return false; - } - break; - - case EbtInt: - switch (src) { - case EbtUint: newOp = EOpConvUintToInt; break; - case EbtBool: newOp = EOpConvBoolToInt; break; - case EbtFloat: newOp = EOpConvFloatToInt; break; - case EbtInt8: newOp = EOpConvInt8ToInt; break; - case EbtUint8: newOp = EOpConvUint8ToInt; break; - case EbtInt16: newOp = EOpConvInt16ToInt; break; - case EbtUint16: newOp = EOpConvUint16ToInt; break; - case EbtDouble: newOp = EOpConvDoubleToInt; break; - case EbtFloat16: newOp = EOpConvFloat16ToInt; break; - case EbtInt64: newOp = EOpConvInt64ToInt; break; - case EbtUint64: newOp = EOpConvUint64ToInt; break; - default: - return false; - } - break; - case EbtUint: - switch (src) { - case EbtInt: newOp = EOpConvIntToUint; break; - case EbtBool: newOp = EOpConvBoolToUint; break; - case EbtFloat: newOp = EOpConvFloatToUint; break; - case EbtInt8: newOp = EOpConvInt8ToUint; break; - case EbtUint8: newOp = EOpConvUint8ToUint; break; - case EbtInt16: newOp = EOpConvInt16ToUint; break; - case EbtUint16: newOp = EOpConvUint16ToUint; break; - case EbtDouble: newOp = EOpConvDoubleToUint; break; - case EbtFloat16: newOp = EOpConvFloat16ToUint; break; - case EbtInt64: newOp = EOpConvInt64ToUint; break; - case EbtUint64: newOp = EOpConvUint64ToUint; break; - // For bindless texture type conversion, add a dummy convert op, just - // to generate a new TIntermTyped - // uvec2(any sampler type) - // uvec2(any image type) - case EbtSampler: newOp = EOpConvIntToUint; break; - default: - return false; - } - break; - case EbtInt64: - switch (src) { - case EbtInt8: newOp = EOpConvInt8ToInt64; break; - case EbtUint8: newOp = EOpConvUint8ToInt64; break; - case EbtInt16: newOp = EOpConvInt16ToInt64; break; - case EbtUint16: newOp = EOpConvUint16ToInt64; break; - case EbtInt: newOp = EOpConvIntToInt64; break; - case EbtUint: newOp = EOpConvUintToInt64; break; - case EbtBool: newOp = EOpConvBoolToInt64; break; - case EbtFloat: newOp = EOpConvFloatToInt64; break; - case EbtDouble: newOp = EOpConvDoubleToInt64; break; - case EbtFloat16: newOp = EOpConvFloat16ToInt64; break; - case EbtUint64: newOp = EOpConvUint64ToInt64; break; - default: - return false; - } - break; - case EbtUint64: - switch (src) { - case EbtInt8: newOp = EOpConvInt8ToUint64; break; - case EbtUint8: newOp = EOpConvUint8ToUint64; break; - case EbtInt16: newOp = EOpConvInt16ToUint64; break; - case EbtUint16: newOp = EOpConvUint16ToUint64; break; - case EbtInt: newOp = EOpConvIntToUint64; break; - case EbtUint: newOp = EOpConvUintToUint64; break; - case EbtBool: newOp = EOpConvBoolToUint64; break; - case EbtFloat: newOp = EOpConvFloatToUint64; break; - case EbtDouble: newOp = EOpConvDoubleToUint64; break; - case EbtFloat16: newOp = EOpConvFloat16ToUint64; break; - case EbtInt64: newOp = EOpConvInt64ToUint64; break; - default: - return false; - } - break; - default: - return false; + if ((isTypeInt(dst) || isTypeFloat(dst) || dst == EbtBool) && + (isTypeInt(src) || isTypeFloat(src) || src == EbtBool)) { + newOp = EOpConvNumeric; + return true; } - return true; + return false; } // This is 'mechanism' here, it does any conversion told. @@ -1034,6 +825,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt op != EOpConstructCooperativeMatrixKHR) return nullptr; + if (node->getType().isTensorLayoutNV() || + node->getType().isTensorViewNV()) + return nullptr; + // Note: callers are responsible for other aspects of shape, // like vector and matrix sizes. @@ -2962,17 +2757,16 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const // (However, some floating-point operations result in bool, like ">", // so are handled later.) if (node.getType().isFloatingDomain()) { + if (IsOpNumericConv(node.getOp()) && + isTypeFloat(node.getType().getBasicType()) && + isTypeFloat(node.getAsUnaryNode()->getOperand()->getAsTyped()->getType().getBasicType())) { + return true; + } switch (node.getOp()) { case EOpIndexDirect: case EOpIndexIndirect: case EOpIndexDirectStruct: case EOpVectorSwizzle: - case EOpConvFloatToDouble: - case EOpConvDoubleToFloat: - case EOpConvFloat16ToFloat: - case EOpConvFloatToFloat16: - case EOpConvFloat16ToDouble: - case EOpConvDoubleToFloat16: return true; default: return false; @@ -2987,6 +2781,15 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const // So, for now, we can assume everything left is non-floating-point... + if (IsOpNumericConv(node.getOp())) { + TBasicType srcType = node.getAsUnaryNode()->getOperand()->getAsTyped()->getType().getBasicType(); + TBasicType dstType = node.getType().getBasicType(); + if ((isTypeInt(srcType) || srcType == EbtBool) && + (isTypeInt(dstType) || dstType == EbtBool)) { + return true; + } + } + // Now check for integer/bool-based operations switch (node.getOp()) { @@ -2996,98 +2799,6 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const case EOpIndexDirectStruct: case EOpVectorSwizzle: - // (u)int* -> bool - case EOpConvInt8ToBool: - case EOpConvInt16ToBool: - case EOpConvIntToBool: - case EOpConvInt64ToBool: - case EOpConvUint8ToBool: - case EOpConvUint16ToBool: - case EOpConvUintToBool: - case EOpConvUint64ToBool: - - // bool -> (u)int* - case EOpConvBoolToInt8: - case EOpConvBoolToInt16: - case EOpConvBoolToInt: - case EOpConvBoolToInt64: - case EOpConvBoolToUint8: - case EOpConvBoolToUint16: - case EOpConvBoolToUint: - case EOpConvBoolToUint64: - - // int8_t -> (u)int* - case EOpConvInt8ToInt16: - case EOpConvInt8ToInt: - case EOpConvInt8ToInt64: - case EOpConvInt8ToUint8: - case EOpConvInt8ToUint16: - case EOpConvInt8ToUint: - case EOpConvInt8ToUint64: - - // int16_t -> (u)int* - case EOpConvInt16ToInt8: - case EOpConvInt16ToInt: - case EOpConvInt16ToInt64: - case EOpConvInt16ToUint8: - case EOpConvInt16ToUint16: - case EOpConvInt16ToUint: - case EOpConvInt16ToUint64: - - // int32_t -> (u)int* - case EOpConvIntToInt8: - case EOpConvIntToInt16: - case EOpConvIntToInt64: - case EOpConvIntToUint8: - case EOpConvIntToUint16: - case EOpConvIntToUint: - case EOpConvIntToUint64: - - // int64_t -> (u)int* - case EOpConvInt64ToInt8: - case EOpConvInt64ToInt16: - case EOpConvInt64ToInt: - case EOpConvInt64ToUint8: - case EOpConvInt64ToUint16: - case EOpConvInt64ToUint: - case EOpConvInt64ToUint64: - - // uint8_t -> (u)int* - case EOpConvUint8ToInt8: - case EOpConvUint8ToInt16: - case EOpConvUint8ToInt: - case EOpConvUint8ToInt64: - case EOpConvUint8ToUint16: - case EOpConvUint8ToUint: - case EOpConvUint8ToUint64: - - // uint16_t -> (u)int* - case EOpConvUint16ToInt8: - case EOpConvUint16ToInt16: - case EOpConvUint16ToInt: - case EOpConvUint16ToInt64: - case EOpConvUint16ToUint8: - case EOpConvUint16ToUint: - case EOpConvUint16ToUint64: - - // uint32_t -> (u)int* - case EOpConvUintToInt8: - case EOpConvUintToInt16: - case EOpConvUintToInt: - case EOpConvUintToInt64: - case EOpConvUintToUint8: - case EOpConvUintToUint16: - case EOpConvUintToUint64: - - // uint64_t -> (u)int* - case EOpConvUint64ToInt8: - case EOpConvUint64ToInt16: - case EOpConvUint64ToInt: - case EOpConvUint64ToInt64: - case EOpConvUint64ToUint8: - case EOpConvUint64ToUint16: - case EOpConvUint64ToUint: - // unary operations case EOpNegative: case EOpLogicalNot: diff --git a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp index 215ccd991..41c6179b3 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp @@ -506,8 +506,18 @@ TIntermTyped* TParseContext::handleVariable(const TSourceLoc& loc, TSymbol* symb } // Recovery, if it wasn't found or was not a variable. - if (! variable) - variable = new TVariable(string, TType(EbtVoid)); + if (! variable) { + bool builtIn = false; + TVector candidateList; + symbolTable.findFunctionNameList(*string + "(", candidateList, builtIn); + + // If it's a function, pass the name/mangledName + if (!candidateList.empty() && !builtIn) { + variable = new TVariable(&candidateList[0]->getName(), &candidateList[0]->getMangledName(), TType(EbtFunction)); + } else { + variable = new TVariable(string, TType(EbtVoid)); + } + } if (variable->getType().getQualifier().isFrontEndConstant()) node = intermediate.addConstantUnion(variable->getConstArray(), variable->getType(), loc); @@ -1489,13 +1499,7 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction result = addOutputArgumentConversions(*fnCandidate, *result->getAsAggregate()); } - if (result->getAsTyped()->getType().isCoopMat() && - !result->getAsTyped()->getType().isParameterized()) { - assert(fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAdd || - fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAddNV); - - result->setType(result->getAsAggregate()->getSequence()[2]->getAsTyped()->getType()); - } + handleCoopMat2FunctionCall(loc, fnCandidate, result, arguments); } } @@ -1507,6 +1511,224 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction return result; } +void TParseContext::handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* result, TIntermNode* arguments) +{ + if (arguments && arguments->getAsAggregate()) { + auto &sequence = arguments->getAsAggregate()->getSequence(); + for (uint32_t i = 0; i < sequence.size(); ++i) { + auto param = sequence[i]; + if (param->getAsTyped()->getBasicType() == EbtFunction) { + // Add the function to the callgraph + intermediate.addToCallGraph(infoSink, currentCaller, param->getAsSymbolNode()->getMangledName()); + + // error checking that all parameters are 'const in' + if (fnCandidate->getBuiltInOp() == EOpCooperativeMatrixLoadTensorNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixReduceNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixPerElementOpNV) { + const TFunction* func = symbolTable.find(param->getAsSymbolNode()->getMangledName())->getAsFunction(); + for (int i = 0; i < func->getParamCount(); ++i) { + const TParameter& arg = (*func)[i]; + const TQualifier& formalQualifier = arg.type->getQualifier(); + if (formalQualifier.storage != EvqConstReadOnly) { + error(loc, "function parameters must all be qualified 'const in'", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + } + + // error checking decodeFunc parameters are (reference, uint32_t[], uint32_t[]) + if (fnCandidate->getBuiltInOp() == EOpCooperativeMatrixLoadTensorNV) { + const TFunction* decodeFunc = symbolTable.find(param->getAsSymbolNode()->getMangledName())->getAsFunction(); + + if (decodeFunc->getParamCount() != 3) { + error(loc, "must have three parameters", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + + if ((*decodeFunc)[0].type->getBasicType() != EbtReference) { + error(loc, "first parameter must be buffer reference type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + if ((*decodeFunc)[1].type->getBasicType() != EbtUint || (*decodeFunc)[2].type->getBasicType() != EbtUint) { + error(loc, "coordinate parameters must be uint32_t", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + if (!(*decodeFunc)[1].type->isArray() || !(*decodeFunc)[2].type->isArray()) { + error(loc, "coordinate parameters must be uint32_t", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + + // error checking reduce function has matching parameters + if (fnCandidate->getBuiltInOp() == EOpCooperativeMatrixReduceNV) { + const TFunction* combineOp = symbolTable.find(param->getAsSymbolNode()->getMangledName())->getAsFunction(); + + if (combineOp->getParamCount() != 2) { + error(loc, "must have two parameters", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + + for (int i = 0; i < combineOp->getParamCount(); ++i) { + const TParameter& arg = (*combineOp)[i]; + if (sequence[1]->getAsTyped()->getType().getBasicType() != arg.type->getBasicType()) { + error(loc, "parameter types must match cooperative matrix component type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + if (sequence[1]->getAsTyped()->getType().getBasicType() != combineOp->getType().getBasicType()) { + error(loc, "return type must match cooperative matrix component type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + + // error checking perelement op has correct parameters + if (fnCandidate->getBuiltInOp() == EOpCooperativeMatrixPerElementOpNV) { + const TFunction* elemOp = symbolTable.find(param->getAsSymbolNode()->getMangledName())->getAsFunction(); + + if (sequence[1]->getAsTyped()->getType() != sequence[0]->getAsTyped()->getType()) { + error(loc, "cooperative matrix input and result types must match", "", ""); + } + + if (elemOp->getParamCount() < 3) { + error(loc, "not enough parameters", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } else if (elemOp->getParamCount() != (int)sequence.size()) { + error(loc, "number of parameters must match call to coopMatPerElementNV", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } else { + if ((*elemOp)[0].type->getBasicType() != EbtUint || (*elemOp)[1].type->getBasicType() != EbtUint) { + error(loc, "row/column parameters must be uint32_t", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + + const TParameter& matArg = (*elemOp)[2]; + if (sequence[1]->getAsTyped()->getType().getBasicType() != matArg.type->getBasicType()) { + error(loc, "third parameter must match cooperative matrix component type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + + for (int i = 3; i < elemOp->getParamCount(); ++i) { + const TParameter& arg = (*elemOp)[i]; + if (sequence[i]->getAsTyped()->getType().getBasicType() != arg.type->getBasicType()) { + error(loc, "parameter types must match or be cooperative matrix component type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + if (sequence[1]->getAsTyped()->getType().getBasicType() != elemOp->getType().getBasicType()) { + error(loc, "return type must match cooperative matrix component type", param->getAsSymbolNode()->getMangledName().c_str(), ""); + } + } + } + } + } + } + if ((result->getAsTyped()->getType().isCoopMat() || + result->getAsTyped()->getType().isTensorLayoutNV() || + result->getAsTyped()->getType().isTensorViewNV()) && + !result->getAsTyped()->getType().isParameterized()) { + assert(fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAdd || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixMulAddNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixReduceNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixPerElementOpNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixTransposeNV || + fnCandidate->getBuiltInOp() == EOpCreateTensorLayoutNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetDimensionNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetBlockSizeNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetStrideNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSliceNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetClampValueNV || + fnCandidate->getBuiltInOp() == EOpCreateTensorViewNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetDimensionNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetStrideNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetClipNV); + + if (fnCandidate->getBuiltInOp() == EOpCreateTensorLayoutNV) { + + // Convert template parameters to arraySizes/typeParameters + TArraySizes *arraySizes = new TArraySizes; + for (uint32_t i = 0; i < 2; ++i) { + TIntermNode *param {}; + if (arguments->getAsConstantUnion()) { + if (i == 0) { + param = arguments; + } + } else { + assert(arguments->getAsAggregate()); + auto &sequence = arguments->getAsAggregate()->getSequence(); + if (i < sequence.size()) { + param = sequence[i]; + } + } + if (param) { + if (param->getAsTyped()->getType().getQualifier().isSpecConstant()) { + uint32_t value = param->getAsSymbolNode()->getConstArray()[0].getIConst(); + arraySizes->addInnerSize(value, param->getAsTyped()); + } else { + uint32_t value = param->getAsConstantUnion()->getConstArray()[0].getIConst(); + arraySizes->addInnerSize(value); + } + } else { + // gl_CooperativeMatrixClampModeUndefined + arraySizes->addInnerSize(0); + } + } + TTypeParameters typeParameters; + typeParameters.arraySizes = arraySizes; + + TType resultType; + resultType.deepCopy(result->getAsTyped()->getType()); + + resultType.copyTypeParameters(typeParameters); + result->setType(resultType); + } else if (fnCandidate->getBuiltInOp() == EOpCreateTensorViewNV) { + + // Convert template parameters to arraySizes/typeParameters + TArraySizes *arraySizes = new TArraySizes; + for (uint32_t i = 0; i < 7; ++i) { + TIntermNode *param {}; + if (arguments->getAsConstantUnion()) { + if (i == 0) { + param = arguments; + } + } else { + assert(arguments->getAsAggregate()); + auto &sequence = arguments->getAsAggregate()->getSequence(); + if (i < sequence.size()) { + param = sequence[i]; + } + } + if (param) { + if (param->getAsTyped()->getType().getQualifier().isSpecConstant()) { + uint32_t value = param->getAsSymbolNode()->getConstArray()[0].getIConst(); + arraySizes->addInnerSize(value, param->getAsTyped()); + } else { + uint32_t value = param->getAsConstantUnion()->getConstArray()[0].getIConst(); + arraySizes->addInnerSize(value); + } + } else { + uint32_t value = 0; + if (i >= 2) { + // default permutation values are an increasing sequence + value = i - 2; + } + arraySizes->addInnerSize(value); + } + } + TTypeParameters typeParameters; + typeParameters.arraySizes = arraySizes; + + TType resultType; + resultType.deepCopy(result->getAsTyped()->getType()); + + resultType.copyTypeParameters(typeParameters); + result->setType(resultType); + } else if (fnCandidate->getBuiltInOp() == EOpCooperativeMatrixReduceNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixPerElementOpNV || + fnCandidate->getBuiltInOp() == EOpCooperativeMatrixTransposeNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetDimensionNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetBlockSizeNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetStrideNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSliceNV || + fnCandidate->getBuiltInOp() == EOpTensorLayoutSetClampValueNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetDimensionNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetStrideNV || + fnCandidate->getBuiltInOp() == EOpTensorViewSetClipNV) { + // Set result type to match type of first parameter + result->setType(result->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()); + } else { + // For MulAdd, set result type to match type of C parameter + result->setType(result->getAsAggregate()->getSequence()[2]->getAsTyped()->getType()); + } + } +} + TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNode* arguments, const TFunction& function) { @@ -1622,6 +1844,8 @@ void TParseContext::computeBuiltinPrecisions(TIntermTyped& node, const TFunction numArgs = 1; break; case EOpDebugPrintf: + case EOpCooperativeMatrixPerElementOpNV: + case EOpCooperativeMatrixReduceNV: numArgs = 0; break; default: @@ -1903,6 +2127,13 @@ TIntermTyped* TParseContext::addOutputArgumentConversions(const TFunction& funct } TVariable* tempArg = makeInternalVariable("tempArg", paramType); tempArg->getWritableType().getQualifier().makeTemporary(); + if (function[i].type->getQualifier().isParamInput()) { + // If the parameter is also an input, copy-in. + TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, intermNode.getLoc()); + TIntermTyped* tempAssign = intermediate.addAssign(EOpAssign, tempArgNode, intermediate.addSymbol(*arguments[i]->getAsTyped()->getAsSymbolNode()), arguments[i]->getLoc()); + conversionTree = intermediate.mergeAggregate(tempAssign, conversionTree, intermNode.getLoc()); + } + TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, intermNode.getLoc()); TIntermTyped* tempAssign = intermediate.addAssign(EOpAssign, arguments[i]->getAsTyped(), tempArgNode, arguments[i]->getLoc()); conversionTree = intermediate.growAggregate(conversionTree, tempAssign, arguments[i]->getLoc()); @@ -2348,7 +2579,7 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan TSampler s = arg0->getType().getSampler(); if (s.is2D() && s.isArrayed() && s.isShadow()) { if ( - ((*argp)[1]->getAsTyped()->getType().getBasicType() == EbtFloat) && + ((*argp)[1]->getAsTyped()->getType().getBasicType() == EbtFloat) && ((*argp)[1]->getAsTyped()->getType().getVectorSize() == 4) && (fnCandidate.getParamCount() == 4)) { featureString = fnCandidate.getName() + " for sampler2DArrayShadow"; @@ -2532,7 +2763,7 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan error(loc, "only supported on image with format r64i", fnCandidate.getName().c_str(), ""); else if (callNode.getType().getBasicType() == EbtUint64 && imageType.getQualifier().getFormat() != ElfR64ui) error(loc, "only supported on image with format r64ui", fnCandidate.getName().c_str(), ""); - } else if(callNode.getType().getBasicType() == EbtFloat16 && + } else if(callNode.getType().getBasicType() == EbtFloat16 && ((callNode.getType().getVectorSize() == 2 && arg0->getType().getQualifier().getFormat() == ElfRg16f) || (callNode.getType().getVectorSize() == 4 && arg0->getType().getQualifier().getFormat() == ElfRgba16f))) { if (StartsWith(fnCandidate.getName(), "imageAtomicAdd") || @@ -2603,7 +2834,7 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan requireExtensions(loc, 2, extensions, fnCandidate.getName().c_str()); } else if ((callNode.getOp() == EOpAtomicAdd || callNode.getOp() == EOpAtomicExchange || callNode.getOp() == EOpAtomicMin || callNode.getOp() == EOpAtomicMax) && - arg0->getType().getBasicType() == EbtFloat16 && + arg0->getType().getBasicType() == EbtFloat16 && (arg0->getType().getVectorSize() == 2 || arg0->getType().getVectorSize() == 4 )) { requireExtensions(loc, 1, &E_GL_NV_shader_atomic_fp16_vector, fnCandidate.getName().c_str()); } else if ((callNode.getOp() == EOpAtomicAdd || callNode.getOp() == EOpAtomicExchange) && @@ -3728,7 +3959,8 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T TIntermTyped* typed = node->getAsTyped(); if (type.isCoopMat() && typed->getType().isCoopMat() && - !type.sameCoopMatShapeAndUse(typed->getType())) { + ((extensionTurnedOn(E_GL_NV_cooperative_matrix2) && !type.sameCoopMatShape(typed->getType())) || + (!extensionTurnedOn(E_GL_NV_cooperative_matrix2) && !type.sameCoopMatShapeAndUse(typed->getType())))) { error(loc, "Cooperative matrix type parameters mismatch", constructorString.c_str(), ""); return true; } @@ -4460,7 +4692,7 @@ bool TParseContext::containsFieldWithBasicType(const TType& type, TBasicType bas // Do size checking for an array type's size. // void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair, - const char* sizeType, const bool allowZero) + const char* sizeType, const bool isTypeParameter) { bool isConst = false; sizePair.node = nullptr; @@ -4490,17 +4722,27 @@ void TParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TA sizePair.size = size; - if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) { - error(loc, sizeType, "", "must be a constant integer expression"); - return; - } - - if (allowZero) { + if (isTypeParameter) { + if (extensionTurnedOn(E_GL_NV_cooperative_matrix2)) { + if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint && expr->getBasicType() != EbtBool)) { + error(loc, sizeType, "", "must be a constant integer or boolean expression"); + return; + } + } else { + if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) { + error(loc, sizeType, "", "must be a constant integer expression"); + return; + } + } if (size < 0) { error(loc, sizeType, "", "must be a non-negative integer"); return; } } else { + if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) { + error(loc, sizeType, "", "must be a constant integer expression"); + return; + } if (size <= 0) { error(loc, sizeType, "", "must be a positive integer"); return; @@ -7036,6 +7278,14 @@ const TFunction* TParseContext::findFunction(const TSourceLoc& loc, const TFunct return symbol->getAsFunction(); } + // coopMatPerElementNV is variadic. There is some function signature error + // checking in handleCoopMat2FunctionCall. + if (call.getName() == "coopMatPerElementNV") { + TSymbol* symbol = symbolTable.find("coopMatPerElementNV(", &builtIn); + if (symbol) + return symbol->getAsFunction(); + } + bool explicitTypesEnabled = extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) || extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8) || extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16) || @@ -7201,15 +7451,25 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn); // can 'from' convert to 'to'? - const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool { + const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator op, int param) -> bool { if (from == to) return true; if (from.coopMatParameterOK(to)) return true; + if (from.tensorParameterOK(to)) + return true; + if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction) + return true; // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions if (builtIn && from.isArray() && to.isUnsizedArray()) { TType fromElementType(from, 0); TType toElementType(to, 0); + // Load/store tensor functions allow any element type for the pointer + if ((op == EOpCooperativeMatrixLoadTensorNV || op == EOpCooperativeMatrixStoreTensorNV) && + param == 1 && + (from.getQualifier().storage == EvqBuffer || from.getQualifier().storage == EvqShared)) { + return true; + } if (fromElementType == toElementType) return true; } @@ -7277,15 +7537,25 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn); // can 'from' convert to 'to'? - const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator, int) -> bool { + const auto convertible = [this,builtIn](const TType& from, const TType& to, TOperator op, int param) -> bool { if (from == to) return true; if (from.coopMatParameterOK(to)) return true; + if (from.tensorParameterOK(to)) + return true; + if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction) + return true; // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions if (builtIn && from.isArray() && to.isUnsizedArray()) { TType fromElementType(from, 0); TType toElementType(to, 0); + // Load/store tensor functions allow any element type for the pointer + if ((op == EOpCooperativeMatrixLoadTensorNV || op == EOpCooperativeMatrixStoreTensorNV) && + param == 1 && + (from.getQualifier().storage == EvqBuffer || from.getQualifier().storage == EvqShared)) { + return true; + } if (fromElementType == toElementType) return true; } @@ -7462,6 +7732,40 @@ void TParseContext::coopMatTypeParametersCheck(const TSourceLoc& loc, const TPub return; } } + if (publicType.isTensorLayoutNV()) { + if (publicType.typeParameters == nullptr) { + error(loc, "tensorLayout missing type parameters", "", ""); + return; + } + if (publicType.typeParameters->arraySizes->getNumDims() > 2) { + error(loc, "tensorLayout incorrect number of type parameters", "", ""); + return; + } + if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() < 2) { + while (publicType.typeParameters->arraySizes->getNumDims() < 2) { + publicType.typeParameters->arraySizes->addInnerSize(0); + } + } + } + if (publicType.isTensorViewNV()) { + if (publicType.typeParameters == nullptr) { + error(loc, "tensorView missing type parameters", "", ""); + return; + } + if (publicType.typeParameters->arraySizes->getNumDims() < 1 || + publicType.typeParameters->arraySizes->getNumDims() > 7) { + error(loc, "tensorView incorrect number of type parameters", "", ""); + return; + } + if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() < 7) { + uint32_t numDims = publicType.typeParameters->arraySizes->getNumDims(); + while (numDims < 7) { + uint32_t dim = (numDims == 1) ? 0 : (numDims - 2); + publicType.typeParameters->arraySizes->addInnerSize(dim); + numDims++; + } + } + } } bool TParseContext::vkRelaxedRemapUniformVariable(const TSourceLoc& loc, TString& identifier, const TPublicType& publicType, @@ -7837,7 +8141,7 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden intermediate.setUseStorageBuffer(); if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || - publicType.typeParameters->arraySizes->getNumDims() != 3) { + publicType.typeParameters->arraySizes->getNumDims() != 4) { error(loc, "unexpected number type parameters", identifier.c_str(), ""); } if (publicType.typeParameters) { @@ -7868,6 +8172,14 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden error(loc, "expected 8, 16, or 32 bits for first type parameter", identifier.c_str(), ""); } } + } else if (type.isTensorLayoutNV()) { + if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() > 2) { + error(loc, "expected 1-2 type parameters", identifier.c_str(), ""); + } + } else if (type.isTensorViewNV()) { + if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() > 7) { + error(loc, "expected 1-7 type parameters", identifier.c_str(), ""); + } } else { if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() != 0) { error(loc, "unexpected type parameters", identifier.c_str(), ""); @@ -8723,109 +9035,11 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T return nullptr; } node = intermediate.setAggregateOperator(node, op, type, node->getLoc()); + } else if (type.sameCoopMatShape(node->getType()) && !type.sameCoopMatUse(node->getType()) && + type.getBasicType() == node->getType().getBasicType()) { + node = intermediate.setAggregateOperator(node, op, type, node->getLoc()); } else { - TOperator op = EOpNull; - switch (type.getBasicType()) { - default: - assert(0); - break; - case EbtInt: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToInt; break; - case EbtFloat16: op = EOpConvFloat16ToInt; break; - case EbtUint8: op = EOpConvUint8ToInt; break; - case EbtInt8: op = EOpConvInt8ToInt; break; - case EbtUint16: op = EOpConvUint16ToInt; break; - case EbtInt16: op = EOpConvInt16ToInt; break; - case EbtUint: op = EOpConvUintToInt; break; - default: assert(0); - } - break; - case EbtUint: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToUint; break; - case EbtFloat16: op = EOpConvFloat16ToUint; break; - case EbtUint8: op = EOpConvUint8ToUint; break; - case EbtInt8: op = EOpConvInt8ToUint; break; - case EbtUint16: op = EOpConvUint16ToUint; break; - case EbtInt16: op = EOpConvInt16ToUint; break; - case EbtInt: op = EOpConvIntToUint; break; - default: assert(0); - } - break; - case EbtInt16: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToInt16; break; - case EbtFloat16: op = EOpConvFloat16ToInt16; break; - case EbtUint8: op = EOpConvUint8ToInt16; break; - case EbtInt8: op = EOpConvInt8ToInt16; break; - case EbtUint16: op = EOpConvUint16ToInt16; break; - case EbtInt: op = EOpConvIntToInt16; break; - case EbtUint: op = EOpConvUintToInt16; break; - default: assert(0); - } - break; - case EbtUint16: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToUint16; break; - case EbtFloat16: op = EOpConvFloat16ToUint16; break; - case EbtUint8: op = EOpConvUint8ToUint16; break; - case EbtInt8: op = EOpConvInt8ToUint16; break; - case EbtInt16: op = EOpConvInt16ToUint16; break; - case EbtInt: op = EOpConvIntToUint16; break; - case EbtUint: op = EOpConvUintToUint16; break; - default: assert(0); - } - break; - case EbtInt8: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToInt8; break; - case EbtFloat16: op = EOpConvFloat16ToInt8; break; - case EbtUint8: op = EOpConvUint8ToInt8; break; - case EbtInt16: op = EOpConvInt16ToInt8; break; - case EbtUint16: op = EOpConvUint16ToInt8; break; - case EbtInt: op = EOpConvIntToInt8; break; - case EbtUint: op = EOpConvUintToInt8; break; - default: assert(0); - } - break; - case EbtUint8: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToUint8; break; - case EbtFloat16: op = EOpConvFloat16ToUint8; break; - case EbtInt8: op = EOpConvInt8ToUint8; break; - case EbtInt16: op = EOpConvInt16ToUint8; break; - case EbtUint16: op = EOpConvUint16ToUint8; break; - case EbtInt: op = EOpConvIntToUint8; break; - case EbtUint: op = EOpConvUintToUint8; break; - default: assert(0); - } - break; - case EbtFloat: - switch (node->getType().getBasicType()) { - case EbtFloat16: op = EOpConvFloat16ToFloat; break; - case EbtInt8: op = EOpConvInt8ToFloat; break; - case EbtUint8: op = EOpConvUint8ToFloat; break; - case EbtInt16: op = EOpConvInt16ToFloat; break; - case EbtUint16: op = EOpConvUint16ToFloat; break; - case EbtInt: op = EOpConvIntToFloat; break; - case EbtUint: op = EOpConvUintToFloat; break; - default: assert(0); - } - break; - case EbtFloat16: - switch (node->getType().getBasicType()) { - case EbtFloat: op = EOpConvFloatToFloat16; break; - case EbtInt8: op = EOpConvInt8ToFloat16; break; - case EbtUint8: op = EOpConvUint8ToFloat16; break; - case EbtInt16: op = EOpConvInt16ToFloat16; break; - case EbtUint16: op = EOpConvUint16ToFloat16; break; - case EbtInt: op = EOpConvIntToFloat16; break; - case EbtUint: op = EOpConvUintToFloat16; break; - default: assert(0); - } - break; - } + TOperator op = EOpConvNumeric; node = intermediate.addUnaryNode(op, node, node->getLoc(), type); // If it's a (non-specialization) constant, it must be folded. @@ -9605,6 +9819,15 @@ void TParseContext::addQualifierToExisting(const TSourceLoc& loc, TQualifier qua // type with an empty type list, which will be filled in later in // TParseContext::declareBlock. if (!symbol && qualifier.hasBufferReference()) { + // The layout qualifiers are ignored in forward declaration, give warning for the most probable to be seen + if (qualifier.hasBufferReferenceAlign()) { + warn(loc, "the buffer_reference_align layout is ignored when defined in forward declaration", + identifier.c_str(), ""); + } + if (qualifier.hasPacking()) { + warn(loc, "the packing layout (scalar, std430, etc) is ignored when defined in forward declaration", + identifier.c_str(), ""); + } TTypeList typeList; TType blockType(&typeList, identifier, qualifier); TType blockNameType(EbtReference, blockType, identifier); diff --git a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h index 67ba7dbd1..5b192c11a 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h +++ b/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h @@ -384,7 +384,7 @@ public: void globalCheck(const TSourceLoc&, const char* token); bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&); bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&); - void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType, const bool allowZero = false); + void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType, const bool isTypeParameter = false); bool arrayQualifierError(const TSourceLoc&, const TQualifier&); bool arrayError(const TSourceLoc&, const TType&); void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&); @@ -509,6 +509,7 @@ protected: TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable); TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer); void finish() override; + void handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* result, TIntermNode* arguments); virtual const char* getGlobalUniformBlockName() const override; virtual void finalizeGlobalUniformBlockLayout(TVariable&) override; diff --git a/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp b/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp index a90edb32f..414251e67 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp @@ -752,6 +752,10 @@ const std::unordered_map KeywordMap { {"hitObjectNV",HITOBJECTNV}, {"hitObjectAttributeNV",HITOBJECTATTRNV}, + + {"__function",FUNCTION}, + {"tensorLayoutNV",TENSORLAYOUTNV}, + {"tensorViewNV",TENSORVIEWNV}, }; const std::unordered_set ReservedSet { "common", @@ -1807,6 +1811,15 @@ int TScanContext::tokenizeIdentifier() return keyword; return identifierOrType(); + case FUNCTION: + case TENSORLAYOUTNV: + case TENSORVIEWNV: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_NV_cooperative_matrix2)) + return keyword; + return identifierOrType(); + default: parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); return 0; diff --git a/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp b/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp index b6edb469a..803626000 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp @@ -78,6 +78,8 @@ void TType::buildMangledName(TString& mangledName) const case EbtRayQuery: mangledName += "rq"; break; case EbtSpirvType: mangledName += "spv-t"; break; case EbtHitObjectNV: mangledName += "ho"; break; + case EbtTensorLayoutNV: mangledName += "tl"; break; + case EbtTensorViewNV: mangledName += "tv"; break; case EbtSampler: switch (sampler.type) { case EbtFloat16: mangledName += "f16"; break; @@ -344,6 +346,7 @@ void TSymbolTableLevel::readOnly() TSymbol::TSymbol(const TSymbol& copyOf) { name = NewPoolTString(copyOf.name->c_str()); + mangledName = NewPoolTString(copyOf.mangledName->c_str()); uniqueId = copyOf.uniqueId; writable = true; } diff --git a/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h b/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h index 94c3929da..6d1a0c8e2 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h +++ b/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h @@ -84,7 +84,8 @@ typedef TVector TExtensionList; class TSymbol { public: POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) - explicit TSymbol(const TString *n) : name(n), uniqueId(0), extensions(nullptr), writable(true) { } + explicit TSymbol(const TString *n, const TString *mn) : name(n), mangledName(mn), uniqueId(0), extensions(nullptr), writable(true) { } + explicit TSymbol(const TString *n) : TSymbol(n, n) { } virtual TSymbol* clone() const = 0; virtual ~TSymbol() { } // rely on all symbol owned memory coming from the pool @@ -96,7 +97,7 @@ public: newName.append(*name); changeName(NewPoolTString(newName.c_str())); } - virtual const TString& getMangledName() const { return getName(); } + virtual const TString& getMangledName() const { return *mangledName; } virtual TFunction* getAsFunction() { return nullptr; } virtual const TFunction* getAsFunction() const { return nullptr; } virtual TVariable* getAsVariable() { return nullptr; } @@ -128,6 +129,7 @@ protected: TSymbol& operator=(const TSymbol&); const TString *name; + const TString *mangledName; unsigned long long uniqueId; // For cross-scope comparing during code generation // For tracking what extensions must be present @@ -154,7 +156,9 @@ protected: class TVariable : public TSymbol { public: TVariable(const TString *name, const TType& t, bool uT = false ) - : TSymbol(name), + : TVariable(name, name, t, uT) {} + TVariable(const TString *name, const TString *mangledName, const TType& t, bool uT = false ) + : TSymbol(name, mangledName), userType(uT), constSubtree(nullptr), memberExtensions(nullptr), diff --git a/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp b/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp index 0262c54dc..cbfae6c72 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp @@ -165,7 +165,8 @@ void TParseVersions::initializeExtensionBehavior() const extensionData exts[] = { {E_GL_EXT_ray_tracing, EShTargetSpv_1_4}, {E_GL_NV_ray_tracing_motion_blur, EShTargetSpv_1_4}, - {E_GL_EXT_mesh_shader, EShTargetSpv_1_4} + {E_GL_EXT_mesh_shader, EShTargetSpv_1_4}, + {E_GL_NV_cooperative_matrix2, EShTargetSpv_1_6} }; for (size_t ii = 0; ii < sizeof(exts) / sizeof(exts[0]); ii++) { @@ -310,6 +311,7 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_NV_shader_invocation_reorder] = EBhDisable; extensionBehavior[E_GL_NV_displacement_micromap] = EBhDisable; extensionBehavior[E_GL_NV_shader_atomic_fp16_vector] = EBhDisable; + extensionBehavior[E_GL_NV_cooperative_matrix2] = EBhDisable; // ARM extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable; @@ -574,6 +576,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_NV_cooperative_matrix 1\n" "#define GL_NV_integer_cooperative_matrix 1\n" "#define GL_NV_shader_invocation_reorder 1\n" + "#define GL_NV_cooperative_matrix2 1\n" "#define GL_QCOM_image_processing 1\n" "#define GL_QCOM_image_processing2 1\n" @@ -1021,6 +1024,8 @@ void TParseVersions::updateExtensionBehavior(int line, const char* extension, co updateExtensionBehavior(line, "GL_EXT_buffer_reference", behaviorString); else if (strcmp(extension, "GL_NV_integer_cooperative_matrix") == 0) updateExtensionBehavior(line, "GL_NV_cooperative_matrix", behaviorString); + else if (strcmp(extension, "GL_NV_cooperative_matrix2") == 0) + updateExtensionBehavior(line, "GL_KHR_cooperative_matrix", behaviorString); // subgroup extended types to explicit types else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int8") == 0) updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int8", behaviorString); @@ -1381,6 +1386,14 @@ void TParseVersions::coopmatCheck(const TSourceLoc& loc, const char* op, bool bu } } +void TParseVersions::tensorLayoutViewCheck(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = {E_GL_NV_cooperative_matrix2}; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + // Call for any operation removed because SPIR-V is in use. void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op) { diff --git a/3rdparty/glslang/glslang/MachineIndependent/Versions.h b/3rdparty/glslang/glslang/MachineIndependent/Versions.h index 75a823774..4541381ab 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/Versions.h +++ b/3rdparty/glslang/glslang/MachineIndependent/Versions.h @@ -282,6 +282,7 @@ const char* const E_GL_NV_shader_invocation_reorder = "GL_NV_shader_ const char* const E_GL_EXT_ray_tracing_position_fetch = "GL_EXT_ray_tracing_position_fetch"; 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"; // ARM const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader_core_builtins"; diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang.y b/3rdparty/glslang/glslang/MachineIndependent/glslang.y index 35686fbc7..90ac3c83e 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/glslang.y +++ b/3rdparty/glslang/glslang/MachineIndependent/glslang.y @@ -179,6 +179,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token FCOOPMATNV ICOOPMATNV UCOOPMATNV %token COOPMAT %token HITOBJECTNV HITOBJECTATTRNV +%token TENSORLAYOUTNV TENSORVIEWNV // combined image/sampler %token SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW @@ -275,7 +276,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token DOUBLECONSTANT INT16CONSTANT UINT16CONSTANT FLOAT16CONSTANT INT32CONSTANT UINT32CONSTANT %token INT64CONSTANT UINT64CONSTANT -%token SUBROUTINE DEMOTE +%token SUBROUTINE DEMOTE FUNCTION %token PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV %token PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT %token PATCH SAMPLE NONUNIFORM @@ -3535,6 +3536,20 @@ type_specifier_nonarray $$.coopmatNV = false; $$.coopmatKHR = true; } + | TENSORLAYOUTNV { + parseContext.tensorLayoutViewCheck($1.loc, "tensorLayoutNV", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtTensorLayoutNV; + } + | TENSORVIEWNV { + parseContext.tensorLayoutViewCheck($1.loc, "tensorViewNV", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtTensorViewNV; + } + | FUNCTION { + $$.init($1.loc); + $$.basicType = EbtFunction; + } | spirv_type_specifier { parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); $$ = $1; diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp index 77571b947..56e568bb0 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp @@ -290,434 +290,437 @@ enum yysymbol_kind_t YYSYMBOL_COOPMAT = 166, /* COOPMAT */ YYSYMBOL_HITOBJECTNV = 167, /* HITOBJECTNV */ YYSYMBOL_HITOBJECTATTRNV = 168, /* HITOBJECTATTRNV */ - YYSYMBOL_SAMPLERCUBEARRAY = 169, /* SAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 170, /* SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_ISAMPLERCUBEARRAY = 171, /* ISAMPLERCUBEARRAY */ - YYSYMBOL_USAMPLERCUBEARRAY = 172, /* USAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLER1D = 173, /* SAMPLER1D */ - YYSYMBOL_SAMPLER1DARRAY = 174, /* SAMPLER1DARRAY */ - YYSYMBOL_SAMPLER1DARRAYSHADOW = 175, /* SAMPLER1DARRAYSHADOW */ - YYSYMBOL_ISAMPLER1D = 176, /* ISAMPLER1D */ - YYSYMBOL_SAMPLER1DSHADOW = 177, /* SAMPLER1DSHADOW */ - YYSYMBOL_SAMPLER2DRECT = 178, /* SAMPLER2DRECT */ - YYSYMBOL_SAMPLER2DRECTSHADOW = 179, /* SAMPLER2DRECTSHADOW */ - YYSYMBOL_ISAMPLER2DRECT = 180, /* ISAMPLER2DRECT */ - YYSYMBOL_USAMPLER2DRECT = 181, /* USAMPLER2DRECT */ - YYSYMBOL_SAMPLERBUFFER = 182, /* SAMPLERBUFFER */ - YYSYMBOL_ISAMPLERBUFFER = 183, /* ISAMPLERBUFFER */ - YYSYMBOL_USAMPLERBUFFER = 184, /* USAMPLERBUFFER */ - YYSYMBOL_SAMPLER2DMS = 185, /* SAMPLER2DMS */ - YYSYMBOL_ISAMPLER2DMS = 186, /* ISAMPLER2DMS */ - YYSYMBOL_USAMPLER2DMS = 187, /* USAMPLER2DMS */ - YYSYMBOL_SAMPLER2DMSARRAY = 188, /* SAMPLER2DMSARRAY */ - YYSYMBOL_ISAMPLER2DMSARRAY = 189, /* ISAMPLER2DMSARRAY */ - YYSYMBOL_USAMPLER2DMSARRAY = 190, /* USAMPLER2DMSARRAY */ - YYSYMBOL_SAMPLEREXTERNALOES = 191, /* SAMPLEREXTERNALOES */ - YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 192, /* SAMPLEREXTERNAL2DY2YEXT */ - YYSYMBOL_ISAMPLER1DARRAY = 193, /* ISAMPLER1DARRAY */ - YYSYMBOL_USAMPLER1D = 194, /* USAMPLER1D */ - YYSYMBOL_USAMPLER1DARRAY = 195, /* USAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER1D = 196, /* F16SAMPLER1D */ - YYSYMBOL_F16SAMPLER2D = 197, /* F16SAMPLER2D */ - YYSYMBOL_F16SAMPLER3D = 198, /* F16SAMPLER3D */ - YYSYMBOL_F16SAMPLER2DRECT = 199, /* F16SAMPLER2DRECT */ - YYSYMBOL_F16SAMPLERCUBE = 200, /* F16SAMPLERCUBE */ - YYSYMBOL_F16SAMPLER1DARRAY = 201, /* F16SAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER2DARRAY = 202, /* F16SAMPLER2DARRAY */ - YYSYMBOL_F16SAMPLERCUBEARRAY = 203, /* F16SAMPLERCUBEARRAY */ - YYSYMBOL_F16SAMPLERBUFFER = 204, /* F16SAMPLERBUFFER */ - YYSYMBOL_F16SAMPLER2DMS = 205, /* F16SAMPLER2DMS */ - YYSYMBOL_F16SAMPLER2DMSARRAY = 206, /* F16SAMPLER2DMSARRAY */ - YYSYMBOL_F16SAMPLER1DSHADOW = 207, /* F16SAMPLER1DSHADOW */ - YYSYMBOL_F16SAMPLER2DSHADOW = 208, /* F16SAMPLER2DSHADOW */ - YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 209, /* F16SAMPLER1DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 210, /* F16SAMPLER2DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DRECTSHADOW = 211, /* F16SAMPLER2DRECTSHADOW */ - YYSYMBOL_F16SAMPLERCUBESHADOW = 212, /* F16SAMPLERCUBESHADOW */ - YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 213, /* F16SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_IMAGE1D = 214, /* IMAGE1D */ - YYSYMBOL_IIMAGE1D = 215, /* IIMAGE1D */ - YYSYMBOL_UIMAGE1D = 216, /* UIMAGE1D */ - YYSYMBOL_IMAGE2D = 217, /* IMAGE2D */ - YYSYMBOL_IIMAGE2D = 218, /* IIMAGE2D */ - YYSYMBOL_UIMAGE2D = 219, /* UIMAGE2D */ - YYSYMBOL_IMAGE3D = 220, /* IMAGE3D */ - YYSYMBOL_IIMAGE3D = 221, /* IIMAGE3D */ - YYSYMBOL_UIMAGE3D = 222, /* UIMAGE3D */ - YYSYMBOL_IMAGE2DRECT = 223, /* IMAGE2DRECT */ - YYSYMBOL_IIMAGE2DRECT = 224, /* IIMAGE2DRECT */ - YYSYMBOL_UIMAGE2DRECT = 225, /* UIMAGE2DRECT */ - YYSYMBOL_IMAGECUBE = 226, /* IMAGECUBE */ - YYSYMBOL_IIMAGECUBE = 227, /* IIMAGECUBE */ - YYSYMBOL_UIMAGECUBE = 228, /* UIMAGECUBE */ - YYSYMBOL_IMAGEBUFFER = 229, /* IMAGEBUFFER */ - YYSYMBOL_IIMAGEBUFFER = 230, /* IIMAGEBUFFER */ - YYSYMBOL_UIMAGEBUFFER = 231, /* UIMAGEBUFFER */ - YYSYMBOL_IMAGE1DARRAY = 232, /* IMAGE1DARRAY */ - YYSYMBOL_IIMAGE1DARRAY = 233, /* IIMAGE1DARRAY */ - YYSYMBOL_UIMAGE1DARRAY = 234, /* UIMAGE1DARRAY */ - YYSYMBOL_IMAGE2DARRAY = 235, /* IMAGE2DARRAY */ - YYSYMBOL_IIMAGE2DARRAY = 236, /* IIMAGE2DARRAY */ - YYSYMBOL_UIMAGE2DARRAY = 237, /* UIMAGE2DARRAY */ - YYSYMBOL_IMAGECUBEARRAY = 238, /* IMAGECUBEARRAY */ - YYSYMBOL_IIMAGECUBEARRAY = 239, /* IIMAGECUBEARRAY */ - YYSYMBOL_UIMAGECUBEARRAY = 240, /* UIMAGECUBEARRAY */ - YYSYMBOL_IMAGE2DMS = 241, /* IMAGE2DMS */ - YYSYMBOL_IIMAGE2DMS = 242, /* IIMAGE2DMS */ - YYSYMBOL_UIMAGE2DMS = 243, /* UIMAGE2DMS */ - YYSYMBOL_IMAGE2DMSARRAY = 244, /* IMAGE2DMSARRAY */ - YYSYMBOL_IIMAGE2DMSARRAY = 245, /* IIMAGE2DMSARRAY */ - YYSYMBOL_UIMAGE2DMSARRAY = 246, /* UIMAGE2DMSARRAY */ - YYSYMBOL_F16IMAGE1D = 247, /* F16IMAGE1D */ - YYSYMBOL_F16IMAGE2D = 248, /* F16IMAGE2D */ - YYSYMBOL_F16IMAGE3D = 249, /* F16IMAGE3D */ - YYSYMBOL_F16IMAGE2DRECT = 250, /* F16IMAGE2DRECT */ - YYSYMBOL_F16IMAGECUBE = 251, /* F16IMAGECUBE */ - YYSYMBOL_F16IMAGE1DARRAY = 252, /* F16IMAGE1DARRAY */ - YYSYMBOL_F16IMAGE2DARRAY = 253, /* F16IMAGE2DARRAY */ - YYSYMBOL_F16IMAGECUBEARRAY = 254, /* F16IMAGECUBEARRAY */ - YYSYMBOL_F16IMAGEBUFFER = 255, /* F16IMAGEBUFFER */ - YYSYMBOL_F16IMAGE2DMS = 256, /* F16IMAGE2DMS */ - YYSYMBOL_F16IMAGE2DMSARRAY = 257, /* F16IMAGE2DMSARRAY */ - YYSYMBOL_I64IMAGE1D = 258, /* I64IMAGE1D */ - YYSYMBOL_U64IMAGE1D = 259, /* U64IMAGE1D */ - YYSYMBOL_I64IMAGE2D = 260, /* I64IMAGE2D */ - YYSYMBOL_U64IMAGE2D = 261, /* U64IMAGE2D */ - YYSYMBOL_I64IMAGE3D = 262, /* I64IMAGE3D */ - YYSYMBOL_U64IMAGE3D = 263, /* U64IMAGE3D */ - YYSYMBOL_I64IMAGE2DRECT = 264, /* I64IMAGE2DRECT */ - YYSYMBOL_U64IMAGE2DRECT = 265, /* U64IMAGE2DRECT */ - YYSYMBOL_I64IMAGECUBE = 266, /* I64IMAGECUBE */ - YYSYMBOL_U64IMAGECUBE = 267, /* U64IMAGECUBE */ - YYSYMBOL_I64IMAGEBUFFER = 268, /* I64IMAGEBUFFER */ - YYSYMBOL_U64IMAGEBUFFER = 269, /* U64IMAGEBUFFER */ - YYSYMBOL_I64IMAGE1DARRAY = 270, /* I64IMAGE1DARRAY */ - YYSYMBOL_U64IMAGE1DARRAY = 271, /* U64IMAGE1DARRAY */ - YYSYMBOL_I64IMAGE2DARRAY = 272, /* I64IMAGE2DARRAY */ - YYSYMBOL_U64IMAGE2DARRAY = 273, /* U64IMAGE2DARRAY */ - YYSYMBOL_I64IMAGECUBEARRAY = 274, /* I64IMAGECUBEARRAY */ - YYSYMBOL_U64IMAGECUBEARRAY = 275, /* U64IMAGECUBEARRAY */ - YYSYMBOL_I64IMAGE2DMS = 276, /* I64IMAGE2DMS */ - YYSYMBOL_U64IMAGE2DMS = 277, /* U64IMAGE2DMS */ - YYSYMBOL_I64IMAGE2DMSARRAY = 278, /* I64IMAGE2DMSARRAY */ - YYSYMBOL_U64IMAGE2DMSARRAY = 279, /* U64IMAGE2DMSARRAY */ - YYSYMBOL_TEXTURECUBEARRAY = 280, /* TEXTURECUBEARRAY */ - YYSYMBOL_ITEXTURECUBEARRAY = 281, /* ITEXTURECUBEARRAY */ - YYSYMBOL_UTEXTURECUBEARRAY = 282, /* UTEXTURECUBEARRAY */ - YYSYMBOL_TEXTURE1D = 283, /* TEXTURE1D */ - YYSYMBOL_ITEXTURE1D = 284, /* ITEXTURE1D */ - YYSYMBOL_UTEXTURE1D = 285, /* UTEXTURE1D */ - YYSYMBOL_TEXTURE1DARRAY = 286, /* TEXTURE1DARRAY */ - YYSYMBOL_ITEXTURE1DARRAY = 287, /* ITEXTURE1DARRAY */ - YYSYMBOL_UTEXTURE1DARRAY = 288, /* UTEXTURE1DARRAY */ - YYSYMBOL_TEXTURE2DRECT = 289, /* TEXTURE2DRECT */ - YYSYMBOL_ITEXTURE2DRECT = 290, /* ITEXTURE2DRECT */ - YYSYMBOL_UTEXTURE2DRECT = 291, /* UTEXTURE2DRECT */ - YYSYMBOL_TEXTUREBUFFER = 292, /* TEXTUREBUFFER */ - YYSYMBOL_ITEXTUREBUFFER = 293, /* ITEXTUREBUFFER */ - YYSYMBOL_UTEXTUREBUFFER = 294, /* UTEXTUREBUFFER */ - YYSYMBOL_TEXTURE2DMS = 295, /* TEXTURE2DMS */ - YYSYMBOL_ITEXTURE2DMS = 296, /* ITEXTURE2DMS */ - YYSYMBOL_UTEXTURE2DMS = 297, /* UTEXTURE2DMS */ - YYSYMBOL_TEXTURE2DMSARRAY = 298, /* TEXTURE2DMSARRAY */ - YYSYMBOL_ITEXTURE2DMSARRAY = 299, /* ITEXTURE2DMSARRAY */ - YYSYMBOL_UTEXTURE2DMSARRAY = 300, /* UTEXTURE2DMSARRAY */ - YYSYMBOL_F16TEXTURE1D = 301, /* F16TEXTURE1D */ - YYSYMBOL_F16TEXTURE2D = 302, /* F16TEXTURE2D */ - YYSYMBOL_F16TEXTURE3D = 303, /* F16TEXTURE3D */ - YYSYMBOL_F16TEXTURE2DRECT = 304, /* F16TEXTURE2DRECT */ - YYSYMBOL_F16TEXTURECUBE = 305, /* F16TEXTURECUBE */ - YYSYMBOL_F16TEXTURE1DARRAY = 306, /* F16TEXTURE1DARRAY */ - YYSYMBOL_F16TEXTURE2DARRAY = 307, /* F16TEXTURE2DARRAY */ - YYSYMBOL_F16TEXTURECUBEARRAY = 308, /* F16TEXTURECUBEARRAY */ - YYSYMBOL_F16TEXTUREBUFFER = 309, /* F16TEXTUREBUFFER */ - YYSYMBOL_F16TEXTURE2DMS = 310, /* F16TEXTURE2DMS */ - YYSYMBOL_F16TEXTURE2DMSARRAY = 311, /* F16TEXTURE2DMSARRAY */ - YYSYMBOL_SUBPASSINPUT = 312, /* SUBPASSINPUT */ - YYSYMBOL_SUBPASSINPUTMS = 313, /* SUBPASSINPUTMS */ - YYSYMBOL_ISUBPASSINPUT = 314, /* ISUBPASSINPUT */ - YYSYMBOL_ISUBPASSINPUTMS = 315, /* ISUBPASSINPUTMS */ - YYSYMBOL_USUBPASSINPUT = 316, /* USUBPASSINPUT */ - YYSYMBOL_USUBPASSINPUTMS = 317, /* USUBPASSINPUTMS */ - YYSYMBOL_F16SUBPASSINPUT = 318, /* F16SUBPASSINPUT */ - YYSYMBOL_F16SUBPASSINPUTMS = 319, /* F16SUBPASSINPUTMS */ - YYSYMBOL_SPIRV_INSTRUCTION = 320, /* SPIRV_INSTRUCTION */ - YYSYMBOL_SPIRV_EXECUTION_MODE = 321, /* SPIRV_EXECUTION_MODE */ - YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 322, /* SPIRV_EXECUTION_MODE_ID */ - YYSYMBOL_SPIRV_DECORATE = 323, /* SPIRV_DECORATE */ - YYSYMBOL_SPIRV_DECORATE_ID = 324, /* SPIRV_DECORATE_ID */ - YYSYMBOL_SPIRV_DECORATE_STRING = 325, /* SPIRV_DECORATE_STRING */ - YYSYMBOL_SPIRV_TYPE = 326, /* SPIRV_TYPE */ - YYSYMBOL_SPIRV_STORAGE_CLASS = 327, /* SPIRV_STORAGE_CLASS */ - YYSYMBOL_SPIRV_BY_REFERENCE = 328, /* SPIRV_BY_REFERENCE */ - YYSYMBOL_SPIRV_LITERAL = 329, /* SPIRV_LITERAL */ - YYSYMBOL_ATTACHMENTEXT = 330, /* ATTACHMENTEXT */ - YYSYMBOL_IATTACHMENTEXT = 331, /* IATTACHMENTEXT */ - YYSYMBOL_UATTACHMENTEXT = 332, /* UATTACHMENTEXT */ - YYSYMBOL_LEFT_OP = 333, /* LEFT_OP */ - YYSYMBOL_RIGHT_OP = 334, /* RIGHT_OP */ - YYSYMBOL_INC_OP = 335, /* INC_OP */ - YYSYMBOL_DEC_OP = 336, /* DEC_OP */ - YYSYMBOL_LE_OP = 337, /* LE_OP */ - YYSYMBOL_GE_OP = 338, /* GE_OP */ - YYSYMBOL_EQ_OP = 339, /* EQ_OP */ - YYSYMBOL_NE_OP = 340, /* NE_OP */ - YYSYMBOL_AND_OP = 341, /* AND_OP */ - YYSYMBOL_OR_OP = 342, /* OR_OP */ - YYSYMBOL_XOR_OP = 343, /* XOR_OP */ - YYSYMBOL_MUL_ASSIGN = 344, /* MUL_ASSIGN */ - YYSYMBOL_DIV_ASSIGN = 345, /* DIV_ASSIGN */ - YYSYMBOL_ADD_ASSIGN = 346, /* ADD_ASSIGN */ - YYSYMBOL_MOD_ASSIGN = 347, /* MOD_ASSIGN */ - YYSYMBOL_LEFT_ASSIGN = 348, /* LEFT_ASSIGN */ - YYSYMBOL_RIGHT_ASSIGN = 349, /* RIGHT_ASSIGN */ - YYSYMBOL_AND_ASSIGN = 350, /* AND_ASSIGN */ - YYSYMBOL_XOR_ASSIGN = 351, /* XOR_ASSIGN */ - YYSYMBOL_OR_ASSIGN = 352, /* OR_ASSIGN */ - YYSYMBOL_SUB_ASSIGN = 353, /* SUB_ASSIGN */ - YYSYMBOL_STRING_LITERAL = 354, /* STRING_LITERAL */ - YYSYMBOL_LEFT_PAREN = 355, /* LEFT_PAREN */ - YYSYMBOL_RIGHT_PAREN = 356, /* RIGHT_PAREN */ - YYSYMBOL_LEFT_BRACKET = 357, /* LEFT_BRACKET */ - YYSYMBOL_RIGHT_BRACKET = 358, /* RIGHT_BRACKET */ - YYSYMBOL_LEFT_BRACE = 359, /* LEFT_BRACE */ - YYSYMBOL_RIGHT_BRACE = 360, /* RIGHT_BRACE */ - YYSYMBOL_DOT = 361, /* DOT */ - YYSYMBOL_COMMA = 362, /* COMMA */ - YYSYMBOL_COLON = 363, /* COLON */ - YYSYMBOL_EQUAL = 364, /* EQUAL */ - YYSYMBOL_SEMICOLON = 365, /* SEMICOLON */ - YYSYMBOL_BANG = 366, /* BANG */ - YYSYMBOL_DASH = 367, /* DASH */ - YYSYMBOL_TILDE = 368, /* TILDE */ - YYSYMBOL_PLUS = 369, /* PLUS */ - YYSYMBOL_STAR = 370, /* STAR */ - YYSYMBOL_SLASH = 371, /* SLASH */ - YYSYMBOL_PERCENT = 372, /* PERCENT */ - YYSYMBOL_LEFT_ANGLE = 373, /* LEFT_ANGLE */ - YYSYMBOL_RIGHT_ANGLE = 374, /* RIGHT_ANGLE */ - YYSYMBOL_VERTICAL_BAR = 375, /* VERTICAL_BAR */ - YYSYMBOL_CARET = 376, /* CARET */ - YYSYMBOL_AMPERSAND = 377, /* AMPERSAND */ - YYSYMBOL_QUESTION = 378, /* QUESTION */ - YYSYMBOL_INVARIANT = 379, /* INVARIANT */ - YYSYMBOL_HIGH_PRECISION = 380, /* HIGH_PRECISION */ - YYSYMBOL_MEDIUM_PRECISION = 381, /* MEDIUM_PRECISION */ - YYSYMBOL_LOW_PRECISION = 382, /* LOW_PRECISION */ - YYSYMBOL_PRECISION = 383, /* PRECISION */ - YYSYMBOL_PACKED = 384, /* PACKED */ - YYSYMBOL_RESOURCE = 385, /* RESOURCE */ - YYSYMBOL_SUPERP = 386, /* SUPERP */ - YYSYMBOL_FLOATCONSTANT = 387, /* FLOATCONSTANT */ - YYSYMBOL_INTCONSTANT = 388, /* INTCONSTANT */ - YYSYMBOL_UINTCONSTANT = 389, /* UINTCONSTANT */ - YYSYMBOL_BOOLCONSTANT = 390, /* BOOLCONSTANT */ - YYSYMBOL_IDENTIFIER = 391, /* IDENTIFIER */ - YYSYMBOL_TYPE_NAME = 392, /* TYPE_NAME */ - YYSYMBOL_CENTROID = 393, /* CENTROID */ - YYSYMBOL_IN = 394, /* IN */ - YYSYMBOL_OUT = 395, /* OUT */ - YYSYMBOL_INOUT = 396, /* INOUT */ - YYSYMBOL_STRUCT = 397, /* STRUCT */ - YYSYMBOL_VOID = 398, /* VOID */ - YYSYMBOL_WHILE = 399, /* WHILE */ - YYSYMBOL_BREAK = 400, /* BREAK */ - YYSYMBOL_CONTINUE = 401, /* CONTINUE */ - YYSYMBOL_DO = 402, /* DO */ - YYSYMBOL_ELSE = 403, /* ELSE */ - YYSYMBOL_FOR = 404, /* FOR */ - YYSYMBOL_IF = 405, /* IF */ - YYSYMBOL_DISCARD = 406, /* DISCARD */ - YYSYMBOL_RETURN = 407, /* RETURN */ - YYSYMBOL_SWITCH = 408, /* SWITCH */ - YYSYMBOL_CASE = 409, /* CASE */ - YYSYMBOL_DEFAULT = 410, /* DEFAULT */ - YYSYMBOL_TERMINATE_INVOCATION = 411, /* TERMINATE_INVOCATION */ - YYSYMBOL_TERMINATE_RAY = 412, /* TERMINATE_RAY */ - YYSYMBOL_IGNORE_INTERSECTION = 413, /* IGNORE_INTERSECTION */ - YYSYMBOL_UNIFORM = 414, /* UNIFORM */ - YYSYMBOL_SHARED = 415, /* SHARED */ - YYSYMBOL_BUFFER = 416, /* BUFFER */ - YYSYMBOL_TILEIMAGEEXT = 417, /* TILEIMAGEEXT */ - YYSYMBOL_FLAT = 418, /* FLAT */ - YYSYMBOL_SMOOTH = 419, /* SMOOTH */ - YYSYMBOL_LAYOUT = 420, /* LAYOUT */ - YYSYMBOL_DOUBLECONSTANT = 421, /* DOUBLECONSTANT */ - YYSYMBOL_INT16CONSTANT = 422, /* INT16CONSTANT */ - YYSYMBOL_UINT16CONSTANT = 423, /* UINT16CONSTANT */ - YYSYMBOL_FLOAT16CONSTANT = 424, /* FLOAT16CONSTANT */ - YYSYMBOL_INT32CONSTANT = 425, /* INT32CONSTANT */ - YYSYMBOL_UINT32CONSTANT = 426, /* UINT32CONSTANT */ - YYSYMBOL_INT64CONSTANT = 427, /* INT64CONSTANT */ - YYSYMBOL_UINT64CONSTANT = 428, /* UINT64CONSTANT */ - YYSYMBOL_SUBROUTINE = 429, /* SUBROUTINE */ - YYSYMBOL_DEMOTE = 430, /* DEMOTE */ - YYSYMBOL_PAYLOADNV = 431, /* PAYLOADNV */ - YYSYMBOL_PAYLOADINNV = 432, /* PAYLOADINNV */ - YYSYMBOL_HITATTRNV = 433, /* HITATTRNV */ - YYSYMBOL_CALLDATANV = 434, /* CALLDATANV */ - YYSYMBOL_CALLDATAINNV = 435, /* CALLDATAINNV */ - YYSYMBOL_PAYLOADEXT = 436, /* PAYLOADEXT */ - YYSYMBOL_PAYLOADINEXT = 437, /* PAYLOADINEXT */ - YYSYMBOL_HITATTREXT = 438, /* HITATTREXT */ - YYSYMBOL_CALLDATAEXT = 439, /* CALLDATAEXT */ - YYSYMBOL_CALLDATAINEXT = 440, /* CALLDATAINEXT */ - YYSYMBOL_PATCH = 441, /* PATCH */ - YYSYMBOL_SAMPLE = 442, /* SAMPLE */ - YYSYMBOL_NONUNIFORM = 443, /* NONUNIFORM */ - YYSYMBOL_COHERENT = 444, /* COHERENT */ - YYSYMBOL_VOLATILE = 445, /* VOLATILE */ - YYSYMBOL_RESTRICT = 446, /* RESTRICT */ - YYSYMBOL_READONLY = 447, /* READONLY */ - YYSYMBOL_WRITEONLY = 448, /* WRITEONLY */ - YYSYMBOL_DEVICECOHERENT = 449, /* DEVICECOHERENT */ - YYSYMBOL_QUEUEFAMILYCOHERENT = 450, /* QUEUEFAMILYCOHERENT */ - YYSYMBOL_WORKGROUPCOHERENT = 451, /* WORKGROUPCOHERENT */ - YYSYMBOL_SUBGROUPCOHERENT = 452, /* SUBGROUPCOHERENT */ - YYSYMBOL_NONPRIVATE = 453, /* NONPRIVATE */ - YYSYMBOL_SHADERCALLCOHERENT = 454, /* SHADERCALLCOHERENT */ - YYSYMBOL_NOPERSPECTIVE = 455, /* NOPERSPECTIVE */ - YYSYMBOL_EXPLICITINTERPAMD = 456, /* EXPLICITINTERPAMD */ - YYSYMBOL_PERVERTEXEXT = 457, /* PERVERTEXEXT */ - YYSYMBOL_PERVERTEXNV = 458, /* PERVERTEXNV */ - YYSYMBOL_PERPRIMITIVENV = 459, /* PERPRIMITIVENV */ - YYSYMBOL_PERVIEWNV = 460, /* PERVIEWNV */ - YYSYMBOL_PERTASKNV = 461, /* PERTASKNV */ - YYSYMBOL_PERPRIMITIVEEXT = 462, /* PERPRIMITIVEEXT */ - YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 463, /* TASKPAYLOADWORKGROUPEXT */ - YYSYMBOL_PRECISE = 464, /* PRECISE */ - YYSYMBOL_YYACCEPT = 465, /* $accept */ - YYSYMBOL_variable_identifier = 466, /* variable_identifier */ - YYSYMBOL_primary_expression = 467, /* primary_expression */ - YYSYMBOL_postfix_expression = 468, /* postfix_expression */ - YYSYMBOL_integer_expression = 469, /* integer_expression */ - YYSYMBOL_function_call = 470, /* function_call */ - YYSYMBOL_function_call_or_method = 471, /* function_call_or_method */ - YYSYMBOL_function_call_generic = 472, /* function_call_generic */ - YYSYMBOL_function_call_header_no_parameters = 473, /* function_call_header_no_parameters */ - YYSYMBOL_function_call_header_with_parameters = 474, /* function_call_header_with_parameters */ - YYSYMBOL_function_call_header = 475, /* function_call_header */ - YYSYMBOL_function_identifier = 476, /* function_identifier */ - YYSYMBOL_unary_expression = 477, /* unary_expression */ - YYSYMBOL_unary_operator = 478, /* unary_operator */ - YYSYMBOL_multiplicative_expression = 479, /* multiplicative_expression */ - YYSYMBOL_additive_expression = 480, /* additive_expression */ - YYSYMBOL_shift_expression = 481, /* shift_expression */ - YYSYMBOL_relational_expression = 482, /* relational_expression */ - YYSYMBOL_equality_expression = 483, /* equality_expression */ - YYSYMBOL_and_expression = 484, /* and_expression */ - YYSYMBOL_exclusive_or_expression = 485, /* exclusive_or_expression */ - YYSYMBOL_inclusive_or_expression = 486, /* inclusive_or_expression */ - YYSYMBOL_logical_and_expression = 487, /* logical_and_expression */ - YYSYMBOL_logical_xor_expression = 488, /* logical_xor_expression */ - YYSYMBOL_logical_or_expression = 489, /* logical_or_expression */ - YYSYMBOL_conditional_expression = 490, /* conditional_expression */ - YYSYMBOL_491_1 = 491, /* $@1 */ - YYSYMBOL_assignment_expression = 492, /* assignment_expression */ - YYSYMBOL_assignment_operator = 493, /* assignment_operator */ - YYSYMBOL_expression = 494, /* expression */ - YYSYMBOL_constant_expression = 495, /* constant_expression */ - YYSYMBOL_declaration = 496, /* declaration */ - YYSYMBOL_block_structure = 497, /* block_structure */ - YYSYMBOL_498_2 = 498, /* $@2 */ - YYSYMBOL_identifier_list = 499, /* identifier_list */ - YYSYMBOL_function_prototype = 500, /* function_prototype */ - YYSYMBOL_function_declarator = 501, /* function_declarator */ - YYSYMBOL_function_header_with_parameters = 502, /* function_header_with_parameters */ - YYSYMBOL_function_header = 503, /* function_header */ - YYSYMBOL_parameter_declarator = 504, /* parameter_declarator */ - YYSYMBOL_parameter_declaration = 505, /* parameter_declaration */ - YYSYMBOL_parameter_type_specifier = 506, /* parameter_type_specifier */ - YYSYMBOL_init_declarator_list = 507, /* init_declarator_list */ - YYSYMBOL_single_declaration = 508, /* single_declaration */ - YYSYMBOL_fully_specified_type = 509, /* fully_specified_type */ - YYSYMBOL_invariant_qualifier = 510, /* invariant_qualifier */ - YYSYMBOL_interpolation_qualifier = 511, /* interpolation_qualifier */ - YYSYMBOL_layout_qualifier = 512, /* layout_qualifier */ - YYSYMBOL_layout_qualifier_id_list = 513, /* layout_qualifier_id_list */ - YYSYMBOL_layout_qualifier_id = 514, /* layout_qualifier_id */ - YYSYMBOL_precise_qualifier = 515, /* precise_qualifier */ - YYSYMBOL_type_qualifier = 516, /* type_qualifier */ - YYSYMBOL_single_type_qualifier = 517, /* single_type_qualifier */ - YYSYMBOL_storage_qualifier = 518, /* storage_qualifier */ - YYSYMBOL_non_uniform_qualifier = 519, /* non_uniform_qualifier */ - YYSYMBOL_type_name_list = 520, /* type_name_list */ - YYSYMBOL_type_specifier = 521, /* type_specifier */ - YYSYMBOL_array_specifier = 522, /* array_specifier */ - YYSYMBOL_type_parameter_specifier_opt = 523, /* type_parameter_specifier_opt */ - YYSYMBOL_type_parameter_specifier = 524, /* type_parameter_specifier */ - YYSYMBOL_type_parameter_specifier_list = 525, /* type_parameter_specifier_list */ - YYSYMBOL_type_specifier_nonarray = 526, /* type_specifier_nonarray */ - YYSYMBOL_precision_qualifier = 527, /* precision_qualifier */ - YYSYMBOL_struct_specifier = 528, /* struct_specifier */ - YYSYMBOL_529_3 = 529, /* $@3 */ - YYSYMBOL_530_4 = 530, /* $@4 */ - YYSYMBOL_struct_declaration_list = 531, /* struct_declaration_list */ - YYSYMBOL_struct_declaration = 532, /* struct_declaration */ - YYSYMBOL_struct_declarator_list = 533, /* struct_declarator_list */ - YYSYMBOL_struct_declarator = 534, /* struct_declarator */ - YYSYMBOL_initializer = 535, /* initializer */ - YYSYMBOL_initializer_list = 536, /* initializer_list */ - YYSYMBOL_declaration_statement = 537, /* declaration_statement */ - YYSYMBOL_statement = 538, /* statement */ - YYSYMBOL_simple_statement = 539, /* simple_statement */ - YYSYMBOL_demote_statement = 540, /* demote_statement */ - YYSYMBOL_compound_statement = 541, /* compound_statement */ - YYSYMBOL_542_5 = 542, /* $@5 */ - YYSYMBOL_543_6 = 543, /* $@6 */ - YYSYMBOL_statement_no_new_scope = 544, /* statement_no_new_scope */ - YYSYMBOL_statement_scoped = 545, /* statement_scoped */ - YYSYMBOL_546_7 = 546, /* $@7 */ - YYSYMBOL_547_8 = 547, /* $@8 */ - YYSYMBOL_compound_statement_no_new_scope = 548, /* compound_statement_no_new_scope */ - YYSYMBOL_statement_list = 549, /* statement_list */ - YYSYMBOL_expression_statement = 550, /* expression_statement */ - YYSYMBOL_selection_statement = 551, /* selection_statement */ - YYSYMBOL_selection_statement_nonattributed = 552, /* selection_statement_nonattributed */ - YYSYMBOL_selection_rest_statement = 553, /* selection_rest_statement */ - YYSYMBOL_condition = 554, /* condition */ - YYSYMBOL_switch_statement = 555, /* switch_statement */ - YYSYMBOL_switch_statement_nonattributed = 556, /* switch_statement_nonattributed */ - YYSYMBOL_557_9 = 557, /* $@9 */ - YYSYMBOL_switch_statement_list = 558, /* switch_statement_list */ - YYSYMBOL_case_label = 559, /* case_label */ - YYSYMBOL_iteration_statement = 560, /* iteration_statement */ - YYSYMBOL_iteration_statement_nonattributed = 561, /* iteration_statement_nonattributed */ - YYSYMBOL_562_10 = 562, /* $@10 */ - YYSYMBOL_563_11 = 563, /* $@11 */ - YYSYMBOL_564_12 = 564, /* $@12 */ - YYSYMBOL_for_init_statement = 565, /* for_init_statement */ - YYSYMBOL_conditionopt = 566, /* conditionopt */ - YYSYMBOL_for_rest_statement = 567, /* for_rest_statement */ - YYSYMBOL_jump_statement = 568, /* jump_statement */ - YYSYMBOL_translation_unit = 569, /* translation_unit */ - YYSYMBOL_external_declaration = 570, /* external_declaration */ - YYSYMBOL_function_definition = 571, /* function_definition */ - YYSYMBOL_572_13 = 572, /* $@13 */ - YYSYMBOL_attribute = 573, /* attribute */ - YYSYMBOL_attribute_list = 574, /* attribute_list */ - YYSYMBOL_single_attribute = 575, /* single_attribute */ - YYSYMBOL_spirv_requirements_list = 576, /* spirv_requirements_list */ - YYSYMBOL_spirv_requirements_parameter = 577, /* spirv_requirements_parameter */ - YYSYMBOL_spirv_extension_list = 578, /* spirv_extension_list */ - YYSYMBOL_spirv_capability_list = 579, /* spirv_capability_list */ - YYSYMBOL_spirv_execution_mode_qualifier = 580, /* spirv_execution_mode_qualifier */ - YYSYMBOL_spirv_execution_mode_parameter_list = 581, /* spirv_execution_mode_parameter_list */ - YYSYMBOL_spirv_execution_mode_parameter = 582, /* spirv_execution_mode_parameter */ - YYSYMBOL_spirv_execution_mode_id_parameter_list = 583, /* spirv_execution_mode_id_parameter_list */ - YYSYMBOL_spirv_storage_class_qualifier = 584, /* spirv_storage_class_qualifier */ - YYSYMBOL_spirv_decorate_qualifier = 585, /* spirv_decorate_qualifier */ - YYSYMBOL_spirv_decorate_parameter_list = 586, /* spirv_decorate_parameter_list */ - YYSYMBOL_spirv_decorate_parameter = 587, /* spirv_decorate_parameter */ - YYSYMBOL_spirv_decorate_id_parameter_list = 588, /* spirv_decorate_id_parameter_list */ - YYSYMBOL_spirv_decorate_id_parameter = 589, /* spirv_decorate_id_parameter */ - YYSYMBOL_spirv_decorate_string_parameter_list = 590, /* spirv_decorate_string_parameter_list */ - YYSYMBOL_spirv_type_specifier = 591, /* spirv_type_specifier */ - YYSYMBOL_spirv_type_parameter_list = 592, /* spirv_type_parameter_list */ - YYSYMBOL_spirv_type_parameter = 593, /* spirv_type_parameter */ - YYSYMBOL_spirv_instruction_qualifier = 594, /* spirv_instruction_qualifier */ - YYSYMBOL_spirv_instruction_qualifier_list = 595, /* spirv_instruction_qualifier_list */ - YYSYMBOL_spirv_instruction_qualifier_id = 596 /* spirv_instruction_qualifier_id */ + 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 */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -732,7 +735,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; extern int yylex(YYSTYPE*, TParseContext&); -#line 736 "MachineIndependent/glslang_tab.cpp" +#line 739 "MachineIndependent/glslang_tab.cpp" #ifdef short @@ -1054,21 +1057,21 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 452 +#define YYFINAL 455 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 12701 +#define YYLAST 12814 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 465 +#define YYNTOKENS 468 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 132 /* YYNRULES -- Number of rules. */ -#define YYNRULES 700 +#define YYNRULES 703 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 946 +#define YYNSTATES 949 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 719 +#define YYMAXUTOK 722 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -1153,84 +1156,85 @@ static const yytype_int16 yytranslate[] = 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 + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 355, 355, 361, 364, 369, 372, 375, 379, 382, - 385, 389, 393, 397, 401, 405, 409, 415, 422, 425, - 428, 431, 434, 439, 447, 454, 461, 467, 471, 478, - 481, 487, 505, 530, 538, 543, 570, 578, 584, 588, - 592, 612, 613, 614, 615, 621, 622, 627, 632, 641, - 642, 647, 655, 656, 662, 671, 672, 677, 682, 687, - 695, 696, 705, 717, 718, 727, 728, 737, 738, 747, - 748, 756, 757, 765, 766, 774, 775, 775, 793, 794, - 810, 814, 818, 822, 827, 831, 835, 839, 843, 847, - 851, 858, 861, 872, 879, 884, 891, 896, 901, 908, - 912, 916, 920, 925, 930, 939, 939, 950, 954, 961, - 966, 974, 982, 994, 997, 1004, 1017, 1040, 1063, 1078, - 1103, 1114, 1124, 1134, 1144, 1153, 1156, 1160, 1164, 1169, - 1177, 1182, 1187, 1192, 1197, 1206, 1216, 1243, 1252, 1259, - 1266, 1273, 1280, 1288, 1296, 1306, 1316, 1323, 1333, 1339, - 1342, 1349, 1353, 1357, 1365, 1374, 1377, 1388, 1391, 1394, - 1398, 1402, 1406, 1410, 1413, 1418, 1422, 1427, 1435, 1439, - 1444, 1450, 1456, 1463, 1468, 1473, 1481, 1486, 1498, 1512, - 1518, 1523, 1531, 1539, 1547, 1555, 1563, 1571, 1579, 1587, - 1595, 1602, 1609, 1613, 1618, 1623, 1628, 1633, 1638, 1643, - 1647, 1651, 1655, 1659, 1665, 1671, 1681, 1688, 1691, 1699, - 1706, 1717, 1722, 1730, 1734, 1744, 1747, 1753, 1759, 1765, - 1773, 1783, 1787, 1791, 1795, 1800, 1804, 1809, 1814, 1819, - 1824, 1829, 1834, 1839, 1844, 1849, 1855, 1861, 1867, 1872, - 1877, 1882, 1887, 1892, 1897, 1902, 1907, 1912, 1917, 1922, - 1927, 1934, 1939, 1944, 1949, 1954, 1959, 1964, 1969, 1974, - 1979, 1984, 1989, 1997, 2005, 2013, 2019, 2025, 2031, 2037, - 2043, 2049, 2055, 2061, 2067, 2073, 2079, 2085, 2091, 2097, - 2103, 2109, 2115, 2121, 2127, 2133, 2139, 2145, 2151, 2157, - 2163, 2169, 2175, 2181, 2187, 2193, 2199, 2205, 2211, 2219, - 2227, 2235, 2243, 2251, 2259, 2267, 2275, 2283, 2291, 2299, - 2307, 2313, 2319, 2325, 2331, 2337, 2343, 2349, 2355, 2361, - 2367, 2373, 2379, 2385, 2391, 2397, 2403, 2409, 2415, 2421, - 2427, 2433, 2439, 2445, 2451, 2457, 2463, 2469, 2475, 2481, - 2487, 2493, 2499, 2505, 2511, 2517, 2523, 2527, 2531, 2535, - 2540, 2545, 2550, 2555, 2560, 2565, 2570, 2575, 2580, 2585, - 2590, 2595, 2600, 2605, 2611, 2617, 2623, 2629, 2635, 2641, - 2647, 2653, 2659, 2665, 2671, 2677, 2683, 2688, 2693, 2698, - 2703, 2708, 2713, 2718, 2723, 2728, 2733, 2738, 2743, 2748, - 2753, 2758, 2763, 2768, 2773, 2778, 2783, 2788, 2793, 2798, - 2803, 2808, 2813, 2818, 2823, 2828, 2833, 2838, 2843, 2848, - 2854, 2860, 2865, 2870, 2875, 2881, 2886, 2891, 2896, 2902, - 2907, 2912, 2917, 2923, 2928, 2933, 2938, 2944, 2950, 2956, - 2962, 2967, 2973, 2979, 2985, 2990, 2995, 3000, 3005, 3010, - 3016, 3021, 3026, 3031, 3037, 3042, 3047, 3052, 3058, 3063, - 3068, 3073, 3079, 3084, 3089, 3094, 3100, 3105, 3110, 3115, - 3121, 3126, 3131, 3136, 3142, 3147, 3152, 3157, 3163, 3168, - 3173, 3178, 3184, 3189, 3194, 3199, 3205, 3210, 3215, 3220, - 3226, 3231, 3236, 3241, 3247, 3252, 3257, 3262, 3268, 3273, - 3278, 3283, 3289, 3294, 3299, 3304, 3310, 3315, 3320, 3325, - 3330, 3335, 3340, 3345, 3350, 3355, 3360, 3365, 3370, 3375, - 3380, 3385, 3390, 3395, 3400, 3405, 3410, 3415, 3420, 3425, - 3430, 3436, 3442, 3448, 3454, 3460, 3466, 3472, 3479, 3486, - 3492, 3498, 3504, 3510, 3517, 3524, 3531, 3538, 3542, 3546, - 3551, 3567, 3572, 3577, 3585, 3585, 3602, 3602, 3612, 3615, - 3628, 3650, 3677, 3681, 3687, 3692, 3703, 3706, 3712, 3718, - 3727, 3730, 3736, 3740, 3741, 3747, 3748, 3749, 3750, 3751, - 3752, 3753, 3754, 3758, 3766, 3767, 3771, 3767, 3785, 3786, - 3790, 3790, 3797, 3797, 3811, 3814, 3824, 3832, 3843, 3844, - 3848, 3851, 3858, 3865, 3869, 3877, 3881, 3894, 3897, 3904, - 3904, 3924, 3927, 3933, 3945, 3957, 3960, 3968, 3968, 3983, - 3983, 4001, 4001, 4022, 4025, 4031, 4034, 4040, 4044, 4051, - 4056, 4061, 4068, 4071, 4075, 4079, 4083, 4092, 4096, 4105, - 4108, 4111, 4119, 4119, 4161, 4166, 4169, 4174, 4177, 4182, - 4185, 4190, 4193, 4198, 4201, 4206, 4209, 4214, 4218, 4223, - 4227, 4232, 4236, 4243, 4246, 4251, 4254, 4257, 4260, 4263, - 4268, 4277, 4288, 4293, 4301, 4305, 4310, 4314, 4319, 4323, - 4328, 4332, 4339, 4342, 4347, 4350, 4353, 4356, 4361, 4364, - 4369, 4375, 4378, 4381, 4384, 4389, 4393, 4398, 4402, 4407, - 4411, 4418, 4421, 4426, 4429, 4434, 4437, 4443, 4446, 4451, - 4454 + 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 }; #endif @@ -1276,16 +1280,16 @@ static const char *const yytname[] = "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "RAYQUERYEXT", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", "COOPMAT", - "HITOBJECTNV", "HITOBJECTATTRNV", "SAMPLERCUBEARRAY", - "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", - "SAMPLER1D", "SAMPLER1DARRAY", "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", - "SAMPLER1DSHADOW", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", - "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", - "USAMPLERBUFFER", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS", - "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY", - "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "ISAMPLER1DARRAY", - "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", "F16SAMPLER2D", - "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", + "HITOBJECTNV", "HITOBJECTATTRNV", "TENSORLAYOUTNV", "TENSORVIEWNV", + "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", + "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY", + "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT", + "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT", + "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS", + "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", + "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", + "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", + "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW", @@ -1340,8 +1344,8 @@ static const char *const yytname[] = "TILEIMAGEEXT", "FLAT", "SMOOTH", "LAYOUT", "DOUBLECONSTANT", "INT16CONSTANT", "UINT16CONSTANT", "FLOAT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INT64CONSTANT", "UINT64CONSTANT", "SUBROUTINE", - "DEMOTE", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", "CALLDATANV", - "CALLDATAINNV", "PAYLOADEXT", "PAYLOADINEXT", "HITATTREXT", + "DEMOTE", "FUNCTION", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", + "CALLDATANV", "CALLDATAINNV", "PAYLOADEXT", "PAYLOADINEXT", "HITATTREXT", "CALLDATAEXT", "CALLDATAINEXT", "PATCH", "SAMPLE", "NONUNIFORM", "COHERENT", "VOLATILE", "RESTRICT", "READONLY", "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT", "WORKGROUPCOHERENT", @@ -1407,12 +1411,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-872) +#define YYPACT_NINF (-875) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-695) +#define YYTABLE_NINF (-698) #define yytable_value_is_error(Yyn) \ 0 @@ -1421,101 +1425,101 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 4648, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -305, -301, - -289, -276, -246, -238, -227, -182, -872, -872, -872, -872, - -872, -168, -872, -872, -872, -872, -872, -55, -872, -872, - -872, -872, -872, -319, -872, -872, -872, -872, -872, -872, - -872, -135, -120, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -327, -114, - -81, -124, 7882, -313, -872, -101, -872, -872, -872, -872, - 5572, -872, -872, -872, -872, -94, -872, -872, 952, -872, - -872, 7882, -73, -872, -872, -872, 6034, -78, -252, -250, - -216, -197, -136, -78, -127, -49, 12303, -872, -13, -346, - -39, -872, -309, -872, -10, -9, 7882, -872, -872, -872, - 7882, -38, -37, -872, -267, -872, -236, -872, -872, 10983, - -2, -872, -872, -872, 3, -35, 7882, -872, -8, -6, - -1, -872, -256, -872, -255, -4, 4, 7, 8, -237, - 10, 11, 13, 14, 15, 18, -232, 9, 19, 27, - -188, -872, -3, 7882, -872, 20, -872, -229, -872, -872, - -219, 9223, -872, -272, 1414, -872, -872, -872, -872, -872, - -2, -277, -872, 9663, -265, -872, -23, -872, -112, 10983, - 10983, -872, 10983, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -253, -872, -872, -872, 29, -204, 11423, 28, - -872, 10983, -872, 31, -321, 17, -9, 32, -872, -325, - -78, -872, 5, -872, -330, 33, -125, 10983, -123, -872, - -130, -119, -146, -118, 34, -103, -78, -872, 11863, -872, - -74, 10983, 36, -49, -872, 7882, 24, 6496, -872, 7882, - 10983, -872, -346, -872, 30, -872, -872, -33, -133, -105, - -303, -11, -14, 21, 23, 48, 52, -316, 41, -872, - 10103, -872, 42, -872, -872, 46, 38, 40, -872, 64, - 67, 60, 10543, 74, 10983, 68, 65, 69, 70, 73, - -167, -872, -872, -47, -872, -114, 77, 31, -872, -872, - -872, -872, -872, 1876, -872, -872, -872, -872, -872, -872, - -872, -872, -872, 5110, 17, 9663, -261, 8343, -872, -872, - 9663, 7882, -872, 50, -872, -872, -872, -203, -872, -872, - 10983, 51, -872, -872, 10983, 87, -872, -872, -872, 10983, - -872, -872, -872, -312, -872, -872, -200, 80, -872, -872, - -872, -872, -872, -872, -199, -872, -196, -872, -872, -195, - 71, -872, -872, -872, -872, -169, -872, -164, -872, -872, - -872, -872, -872, -161, -872, 83, -872, -160, 84, -153, - 80, -872, -278, -152, -872, 91, 94, -872, -872, 24, - -2, -43, -872, -872, -872, 6958, -872, -872, -872, 10983, - 10983, 10983, 10983, 10983, 10983, 10983, 10983, 10983, 10983, 10983, - 10983, 10983, 10983, 10983, 10983, 10983, 10983, 10983, -872, -872, - -872, 93, -872, 2338, -872, -872, -872, 2338, -872, 10983, - -872, -872, -42, 10983, -32, -872, -872, -872, -872, -872, - -872, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, 10983, 10983, -872, -872, -872, -872, -872, -872, -872, - 9663, -872, -872, -76, -872, 7420, -872, -872, 96, 95, - -872, -872, -872, -872, -872, -132, -131, -872, -311, -872, - -330, -872, -330, -872, 10983, 10983, -872, -130, -872, -130, - -872, -146, -146, -872, 101, 34, -872, 11863, -872, 10983, - -872, -872, -41, 17, 24, -872, -872, -872, -872, -872, - -33, -33, -133, -133, -105, -105, -105, -105, -303, -303, - -11, -14, 21, 23, 48, 52, 10983, -872, 2338, 4186, - 59, 3724, -151, -872, -150, -872, -872, -872, -872, -872, - 8783, -872, -872, -872, 105, -872, 72, -872, -149, -872, - -148, -872, -141, -872, -140, -872, -139, -138, -872, -872, - -872, -28, 102, 95, 75, 107, 106, -872, -872, 4186, - 108, -872, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, 10983, -872, 100, 2800, 10983, -872, 104, 109, - 76, 112, 3262, -872, 113, -872, 9663, -872, -872, -872, - -137, 10983, 2800, 108, -872, -872, 2338, -872, 110, 95, - -872, -872, 2338, 114, -872, -872 + 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 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1539,123 +1543,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, 538, 182, 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, 631, 137, 541, 542, 543, 0, 540, 172, - 170, 171, 169, 0, 221, 173, 175, 176, 174, 139, - 138, 0, 203, 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, 630, 0, 632, - 0, 114, 113, 0, 125, 130, 161, 160, 158, 162, - 0, 155, 157, 163, 135, 216, 159, 539, 0, 627, - 629, 0, 0, 164, 165, 537, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 546, 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, 628, 0, 0, 0, 96, 0, 0, - 0, 639, 0, 697, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 637, - 0, 635, 0, 0, 544, 151, 153, 0, 149, 207, - 0, 0, 100, 0, 0, 633, 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, 695, 0, 647, 0, 0, 0, 0, 0, 664, - 0, 0, 0, 0, 0, 0, 0, 689, 0, 662, - 0, 0, 0, 0, 98, 0, 0, 0, 548, 0, - 0, 148, 0, 204, 0, 211, 45, 49, 52, 55, - 60, 63, 65, 67, 69, 71, 73, 75, 0, 34, - 0, 101, 575, 584, 588, 0, 0, 0, 609, 0, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 45, 78, 91, 0, 562, 0, 163, 135, 565, 586, - 564, 572, 563, 0, 566, 567, 590, 568, 597, 569, - 570, 605, 571, 0, 119, 0, 127, 0, 556, 134, - 0, 0, 107, 0, 104, 38, 39, 0, 22, 23, - 0, 0, 28, 27, 0, 221, 31, 33, 40, 0, - 217, 112, 699, 0, 700, 640, 0, 0, 698, 659, - 655, 656, 657, 658, 0, 653, 0, 93, 660, 0, - 0, 674, 675, 676, 677, 0, 672, 0, 681, 682, - 683, 684, 680, 0, 678, 0, 685, 0, 0, 0, - 2, 693, 216, 0, 691, 0, 0, 634, 636, 0, - 554, 0, 552, 547, 549, 0, 152, 150, 208, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 76, 212, - 213, 0, 574, 0, 607, 620, 619, 0, 611, 0, - 623, 621, 0, 0, 0, 604, 624, 625, 626, 573, - 81, 82, 84, 83, 86, 87, 88, 89, 90, 85, - 80, 0, 0, 589, 585, 587, 591, 598, 606, 129, - 0, 559, 560, 0, 133, 0, 108, 4, 0, 24, - 21, 32, 220, 643, 645, 0, 0, 696, 0, 649, - 0, 648, 0, 651, 0, 0, 666, 0, 665, 0, - 668, 0, 0, 670, 0, 0, 690, 0, 687, 0, - 663, 638, 0, 555, 0, 550, 545, 46, 47, 48, - 51, 50, 53, 54, 58, 59, 56, 57, 61, 62, - 64, 66, 68, 70, 72, 74, 0, 214, 576, 0, - 0, 0, 0, 622, 0, 603, 79, 92, 128, 557, - 0, 106, 19, 641, 0, 642, 0, 654, 0, 661, - 0, 673, 0, 679, 0, 686, 0, 0, 692, 551, - 553, 0, 0, 595, 0, 0, 0, 614, 613, 616, - 582, 599, 558, 561, 644, 646, 650, 652, 667, 669, - 671, 688, 0, 577, 0, 0, 0, 615, 0, 0, - 594, 0, 0, 592, 0, 77, 0, 579, 608, 578, - 0, 617, 0, 582, 581, 583, 601, 596, 0, 618, - 612, 593, 602, 0, 610, 600 + 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, 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 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -872, -544, -872, -872, -872, -872, -872, -872, -872, -872, - -872, -872, -436, -872, -392, -391, -490, -390, -269, -266, - -268, -264, -262, -260, -872, -482, -872, -499, -872, -492, - -534, 6, -872, -872, -872, 1, -403, -872, -872, 45, - 44, 49, -872, -872, -406, -872, -872, -872, -872, -104, - -872, -389, -375, -872, 12, -872, 0, -433, -872, -872, - -872, -553, 145, -872, -872, -872, -560, -556, -233, -344, - -614, -872, -373, -626, -871, -872, -430, -872, -872, -440, - -437, -872, -872, 63, -737, -363, -872, -144, -872, -399, - -872, -142, -872, -872, -872, -872, -134, -872, -872, -872, - -872, -872, -872, -872, -872, 97, -872, -872, 2, -872, - -71, -308, -416, -872, -872, -872, -304, -307, -302, -872, - -872, -315, -310, -306, -300, -314, -872, -299, -317, -872, - -395, -538 + -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 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - 0, 530, 531, 532, 798, 533, 534, 535, 536, 537, - 538, 539, 620, 541, 587, 588, 589, 590, 591, 592, - 593, 594, 595, 596, 597, 621, 856, 622, 781, 623, - 711, 624, 388, 651, 508, 625, 390, 391, 392, 437, - 438, 439, 393, 394, 395, 396, 397, 398, 487, 488, - 399, 400, 401, 402, 542, 490, 599, 493, 450, 451, - 544, 405, 406, 407, 579, 483, 577, 578, 721, 722, - 649, 793, 628, 629, 630, 631, 632, 753, 892, 928, - 920, 921, 922, 929, 633, 634, 635, 636, 923, 895, - 637, 638, 924, 943, 639, 640, 641, 859, 757, 861, - 899, 918, 919, 642, 408, 409, 410, 434, 643, 480, - 481, 460, 461, 805, 806, 412, 684, 685, 689, 413, - 414, 695, 696, 703, 704, 707, 415, 713, 714, 416, - 462, 463 + 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 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1663,287 +1667,149 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 404, 389, 411, 440, 648, 455, 387, 785, 454, 598, - 455, 504, 403, 540, 678, 712, 858, 545, 702, 725, - 657, 724, 456, 688, 679, 447, 747, 456, 476, 672, - 678, 789, 673, 792, 736, 737, 794, 716, 431, 666, - 427, 669, 803, 672, 927, 485, 726, 440, 491, 442, - 417, 935, 443, 670, 418, 586, 492, 680, 681, 682, - 683, 927, 748, 674, 432, 447, 419, 644, 646, 486, - 738, 739, 428, 655, 656, 687, 804, 674, -694, 420, - 491, 447, 658, 659, -694, 600, 687, 645, 502, 687, - 491, 795, 600, 601, 575, 449, 600, 503, 687, 650, - 551, 553, -35, 790, 660, 668, 552, 554, 661, 421, - 466, 468, 470, 472, 474, 475, 478, 422, 751, 559, - 762, 586, 764, 505, 567, 560, 506, 581, 423, 507, - 568, 860, 586, 582, 675, 586, 464, 583, 467, 465, - 675, 465, 675, 584, 586, 675, 648, 675, 648, 675, - 675, 648, 663, 797, 675, 676, 807, 809, 664, 782, - 811, 813, 552, 810, 586, 801, 812, 814, 799, 724, - 572, 709, 469, 424, 573, 465, 868, 770, 771, 772, - 773, 774, 775, 776, 777, 778, 779, 816, 575, 425, - 575, 471, 818, 817, 465, 820, 823, 780, 819, 942, - 447, 821, 824, 826, 828, 900, 901, 906, 907, 827, - 829, 782, 782, 810, 814, 908, 909, 910, 911, 938, - 429, 817, 821, 824, 829, 782, 873, 875, 734, 735, - 874, 876, 785, 802, 732, 430, 733, 455, 436, 724, - 454, 698, 699, 700, 701, 521, 844, 845, 846, 847, - 653, 433, 473, 654, 456, 465, 903, 691, 692, 693, - 694, 477, 575, 686, 465, 690, 465, 862, 465, 697, - 705, 864, 465, 465, 712, 435, 712, 702, 702, 449, - 879, 688, 866, 867, 869, 708, 870, 833, 465, 678, - 444, 648, 457, 837, 838, 839, 586, 586, 586, 586, - 586, 586, 586, 586, 586, 586, 586, 586, 586, 586, - 586, 586, 937, 459, 715, 782, 785, 465, 783, 834, - 782, 834, 835, 863, 889, 334, 335, 336, 740, 741, - 782, 865, 687, 687, 782, 912, 575, 729, 730, 731, - 840, 841, 479, 842, 843, 687, 484, 687, 331, 494, - 848, 849, 489, 500, 501, 491, 547, 548, 549, 546, - 555, 550, 574, 742, 891, 569, 556, 893, 652, 557, - 558, 648, 561, 562, 600, 563, 564, 565, 586, 586, - 566, 570, 571, 667, 580, 662, -34, 502, 706, 745, - 673, 586, 441, 586, 717, 746, 677, 743, 744, 749, - 448, 754, 752, 755, 403, 756, 575, 893, 404, 389, - 411, 404, 403, 925, 387, 720, 404, 458, 411, 758, - 403, 728, 759, 403, 930, 760, 482, 648, 403, 763, - 766, 765, -36, 815, 767, 768, 441, 496, 769, 939, - 441, 796, 800, -29, 808, 822, 825, 830, 403, 543, - 831, 857, 403, 894, 872, 885, 448, 782, 896, 904, - 905, 916, 913, 915, 926, 932, 914, -580, 403, 931, - 456, 602, 936, 850, 945, 944, 852, 851, 727, 933, - 497, 853, 426, 576, 854, 498, 832, 855, 897, 499, - 890, 934, 940, 894, 627, 403, 941, 495, 898, 786, - 917, 787, 718, 877, 882, 453, 626, 881, 878, 788, - 456, 886, 888, 880, 0, 0, 884, 0, 0, 0, - 0, 883, 0, 0, 0, 0, 0, 0, 887, 0, + 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 671, 0, + 0, 674, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 719, 0, 576, 0, 576, - 0, 0, 0, 0, 0, 0, 0, 403, 0, 403, - 0, 403, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 404, 0, 626, 0, 0, 0, 0, - 0, 576, 0, 0, 0, 403, 0, 0, 0, 0, - 0, 0, 0, 403, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 576, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 403, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 579, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 0, 0, 0, 627, 0, 0, - 0, 0, 0, 0, 0, 626, 0, 0, 0, 626, + 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, 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, 0, - 0, 0, 0, 0, 0, 576, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 403, 0, 0, + 406, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 627, 627, - 0, 627, 0, 411, 0, 0, 0, 0, 0, 0, - 626, 626, 0, 626, 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, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 626, 0, 0, 0, 627, 0, 0, 0, 0, - 0, 0, 627, 0, 0, 0, 0, 626, 0, 0, - 0, 0, 627, 0, 626, 0, 627, 0, 0, 0, - 0, 0, 627, 0, 626, 0, 0, 0, 626, 0, - 0, 0, 452, 0, 626, 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, 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, 0, 0, 0, 0, 0, 0, 331, - 0, 0, 0, 0, 0, 0, 0, 332, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 333, 334, 335, 336, 337, 0, 0, 0, 0, - 0, 0, 0, 0, 338, 339, 340, 341, 342, 343, - 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 345, 346, 347, 348, - 349, 350, 351, 0, 0, 0, 0, 0, 0, 0, - 0, 352, 0, 353, 354, 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, 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, 0, 0, 509, - 510, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 511, 512, - 0, 331, 0, 602, 603, 0, 0, 0, 0, 604, - 513, 514, 515, 516, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 333, 334, 335, 336, 337, 0, 0, - 0, 517, 518, 519, 520, 521, 338, 339, 340, 341, - 342, 343, 344, 605, 606, 607, 608, 0, 609, 610, - 611, 612, 613, 614, 615, 616, 617, 618, 345, 346, - 347, 348, 349, 350, 351, 522, 523, 524, 525, 526, - 527, 528, 529, 352, 619, 353, 354, 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, 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, 0, - 0, 509, 510, 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, 0, 0, 0, 0, - 511, 512, 0, 331, 0, 602, 784, 0, 0, 0, - 0, 604, 513, 514, 515, 516, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 333, 334, 335, 336, 337, - 0, 0, 0, 517, 518, 519, 520, 521, 338, 339, - 340, 341, 342, 343, 344, 605, 606, 607, 608, 0, - 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, - 345, 346, 347, 348, 349, 350, 351, 522, 523, 524, - 525, 526, 527, 528, 529, 352, 619, 353, 354, 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, 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, 0, 0, 509, 510, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 511, 512, 0, 331, 0, 602, 0, 0, - 0, 0, 0, 604, 513, 514, 515, 516, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 333, 334, 335, - 336, 337, 0, 0, 0, 517, 518, 519, 520, 521, - 338, 339, 340, 341, 342, 343, 344, 605, 606, 607, - 608, 0, 609, 610, 611, 612, 613, 614, 615, 616, - 617, 618, 345, 346, 347, 348, 349, 350, 351, 522, - 523, 524, 525, 526, 527, 528, 529, 352, 619, 353, - 354, 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, 1, 2, 3, 4, 5, 6, 7, + 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, @@ -1976,72 +1842,677 @@ 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, 0, 0, 509, 510, 0, 0, 0, + 328, 329, 330, 331, 332, 0, 0, 512, 513, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 511, 512, 0, 331, 0, 494, - 0, 0, 0, 0, 0, 604, 513, 514, 515, 516, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 333, - 334, 335, 336, 337, 0, 0, 0, 517, 518, 519, - 520, 521, 338, 339, 340, 341, 342, 343, 344, 605, - 606, 607, 608, 0, 609, 610, 611, 612, 613, 614, - 615, 616, 617, 618, 345, 346, 347, 348, 349, 350, - 351, 522, 523, 524, 525, 526, 527, 528, 529, 352, - 619, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 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, 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, 0, 0, 509, 510, 0, + 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, 0, 0, 0, 0, 0, 511, 512, 0, 331, - 0, 0, 0, 0, 0, 0, 0, 604, 513, 514, - 515, 516, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 333, 334, 335, 336, 337, 0, 0, 0, 517, - 518, 519, 520, 521, 338, 339, 340, 341, 342, 343, - 344, 605, 606, 607, 608, 0, 609, 610, 611, 612, - 613, 614, 615, 616, 617, 618, 345, 346, 347, 348, - 349, 350, 351, 522, 523, 524, 525, 526, 527, 528, - 529, 352, 619, 353, 354, 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, 1, 2, 3, + 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, + 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, 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, + 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, + 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, 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, 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, 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, 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, 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, + 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, 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, 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, 333, + 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, 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, 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, + 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, 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, 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, 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, 59, 60, 61, 62, 63, + 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, @@ -2052,7 +2523,7 @@ static const yytype_int16 yytable[] = 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 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, @@ -2067,27 +2538,158 @@ static const yytype_int16 yytable[] = 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 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, 0, 0, 509, - 510, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 511, 512, - 0, 331, 0, 0, 0, 0, 0, 0, 0, 604, - 513, 514, 515, 516, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 333, 334, 335, 336, 337, 0, 0, - 0, 517, 518, 519, 520, 521, 338, 339, 340, 341, - 342, 343, 344, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 345, 346, - 347, 348, 349, 350, 351, 522, 523, 524, 525, 526, - 527, 528, 529, 352, 0, 353, 354, 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, 1, + 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, 794, 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, 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, + 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, + 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, 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, 59, 60, 61, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, @@ -2098,7 +2700,7 @@ static const yytype_int16 yytable[] = 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 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, @@ -2113,28 +2715,159 @@ static const yytype_int16 yytable[] = 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 0, 0, 0, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, 0, - 0, 509, 510, 0, 0, 0, 0, 0, 0, 0, + 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, - 511, 512, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 513, 514, 515, 516, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 333, 334, 335, 336, 0, - 0, 0, 0, 517, 518, 519, 520, 521, 338, 339, - 340, 341, 342, 343, 344, 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, 0, 0, 0, 0, 0, 0, 0, 0, - 345, 346, 347, 348, 349, 350, 351, 522, 523, 524, - 525, 526, 527, 528, 529, 352, 0, 353, 354, 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, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 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, 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, + 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, 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, 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, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, + 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, @@ -2144,7 +2877,7 @@ static const yytype_int16 yytable[] = 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 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, @@ -2160,1065 +2893,209 @@ static const yytype_int16 yytable[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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, 0, 331, 0, 0, 0, 0, - 0, 0, 0, 332, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 333, 334, 335, - 336, 337, 0, 0, 0, 0, 0, 0, 0, 0, - 338, 339, 340, 341, 342, 343, 344, 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, 345, 346, 347, 348, 349, 350, 351, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 0, 353, - 354, 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, 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, - 0, 0, 0, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 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, 0, 0, 0, 0, 0, 0, 0, 0, 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, - 334, 335, 336, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 338, 339, 340, 341, 342, 343, 344, 605, - 0, 0, 608, 0, 609, 610, 0, 0, 613, 0, - 0, 0, 0, 0, 345, 346, 347, 348, 349, 350, - 351, 0, 0, 0, 0, 0, 0, 0, 0, 352, - 0, 353, 354, 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, 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, 0, 0, 0, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 445, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 333, 334, 335, 336, 0, 0, 0, 0, 0, - 0, 0, 0, 446, 338, 339, 340, 341, 342, 343, - 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 345, 346, 347, 348, - 349, 350, 351, 0, 0, 0, 0, 0, 0, 0, - 0, 352, 0, 353, 354, 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, 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, 0, 0, 0, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 331, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 333, 334, 335, 336, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 338, 339, 340, 341, - 342, 343, 344, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 345, 346, - 347, 348, 349, 350, 351, 0, 0, 0, 0, 0, - 0, 0, 0, 352, 0, 353, 354, 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, 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, 0, 0, 0, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 723, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 333, 334, 335, 336, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 338, 339, - 340, 341, 342, 343, 344, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 345, 346, 347, 348, 349, 350, 351, 0, 0, 0, - 0, 0, 0, 0, 0, 352, 0, 353, 354, 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, 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, 0, 0, - 0, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 836, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 333, 334, 335, - 336, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 338, 339, 340, 341, 342, 343, 344, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 345, 346, 347, 348, 349, 350, 351, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 0, 353, - 354, 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, 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, - 0, 0, 0, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 871, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 333, - 334, 335, 336, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 338, 339, 340, 341, 342, 343, 344, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 345, 346, 347, 348, 349, 350, - 351, 0, 0, 0, 0, 0, 0, 0, 0, 352, - 0, 353, 354, 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, 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, 0, 0, 0, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 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, 334, 335, 336, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 338, 339, 340, 341, 342, 343, - 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 345, 346, 347, 348, - 349, 350, 351, 0, 0, 0, 0, 0, 0, 0, - 0, 352, 0, 353, 354, 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, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 647, 791, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 647, 902, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 585, 0, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 647, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 750, 0, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 761, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 521, 338, 0, 0, 0, 0, - 343, 665, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 0, 0, 509, 510, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 511, 512, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 513, - 514, 515, 516, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 517, 518, 519, 520, 710, 338, 0, 0, 0, 0, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 522, 523, 524, 525, 526, 527, - 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 365, 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, 0, 0, 0, 0, 0, 0, 324, - 0, 0, 0, 328, 329, 330, 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, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 338, 0, 0, 0, 0, - 343, 344 + 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 }; static const yytype_int16 yycheck[] = { - 0, 0, 0, 392, 503, 411, 0, 633, 411, 491, - 416, 444, 0, 449, 552, 568, 753, 450, 562, 579, - 512, 577, 411, 557, 354, 400, 342, 416, 423, 354, - 568, 645, 357, 647, 337, 338, 650, 571, 365, 538, - 359, 362, 354, 354, 915, 391, 580, 436, 357, 362, - 355, 922, 365, 374, 355, 491, 365, 387, 388, 389, - 390, 932, 378, 388, 391, 440, 355, 500, 501, 415, - 373, 374, 391, 509, 510, 557, 388, 388, 356, 355, - 357, 456, 335, 336, 362, 357, 568, 364, 355, 571, - 357, 651, 357, 365, 483, 373, 357, 364, 580, 364, - 356, 356, 355, 364, 357, 541, 362, 362, 361, 355, - 418, 419, 420, 421, 422, 423, 424, 355, 600, 356, - 612, 557, 614, 359, 356, 362, 362, 356, 355, 365, - 362, 757, 568, 362, 550, 571, 388, 356, 388, 391, - 556, 391, 558, 362, 580, 561, 645, 563, 647, 565, - 566, 650, 356, 356, 570, 550, 356, 356, 362, 362, - 356, 356, 362, 362, 600, 664, 362, 362, 660, 725, - 358, 566, 388, 355, 362, 391, 790, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, 356, 577, 357, - 579, 388, 356, 362, 391, 356, 356, 364, 362, 936, - 575, 362, 362, 356, 356, 356, 356, 356, 356, 362, - 362, 362, 362, 362, 362, 356, 356, 356, 356, 356, - 355, 362, 362, 362, 362, 362, 358, 358, 333, 334, - 362, 362, 858, 669, 367, 355, 369, 643, 362, 795, - 643, 387, 388, 389, 390, 391, 736, 737, 738, 739, - 362, 365, 388, 365, 643, 391, 870, 387, 388, 389, - 390, 388, 651, 388, 391, 388, 391, 759, 391, 388, - 388, 763, 391, 391, 827, 356, 829, 821, 822, 373, - 814, 815, 781, 782, 360, 388, 362, 720, 391, 827, - 391, 790, 365, 729, 730, 731, 732, 733, 734, 735, + 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, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, - 746, 747, 926, 391, 388, 362, 942, 391, 365, 362, - 362, 362, 365, 365, 365, 380, 381, 382, 339, 340, - 362, 363, 814, 815, 362, 363, 725, 370, 371, 372, - 732, 733, 391, 734, 735, 827, 359, 829, 357, 359, - 740, 741, 391, 391, 391, 357, 391, 365, 364, 356, - 364, 362, 365, 377, 856, 356, 362, 859, 391, 362, - 362, 870, 362, 362, 357, 362, 362, 362, 814, 815, - 362, 362, 355, 355, 364, 356, 355, 355, 354, 341, - 357, 827, 392, 829, 358, 343, 391, 376, 375, 358, - 400, 355, 360, 365, 392, 365, 795, 899, 408, 408, - 408, 411, 400, 912, 408, 391, 416, 416, 416, 355, - 408, 391, 355, 411, 916, 365, 426, 926, 416, 355, - 365, 363, 355, 362, 365, 365, 436, 435, 365, 931, - 440, 391, 391, 356, 364, 362, 362, 356, 436, 449, - 356, 358, 440, 859, 358, 354, 456, 362, 399, 354, - 388, 355, 360, 356, 364, 356, 391, 359, 456, 365, - 859, 359, 359, 742, 360, 365, 744, 743, 582, 403, - 436, 745, 337, 483, 746, 440, 719, 747, 861, 440, - 834, 921, 932, 899, 494, 483, 933, 434, 861, 643, - 899, 643, 573, 810, 819, 408, 494, 817, 812, 643, - 899, 825, 829, 815, -1, -1, 822, -1, -1, -1, - -1, 821, -1, -1, -1, -1, -1, -1, 827, -1, + 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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 546, -1, + -1, 549, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 575, -1, 577, -1, 579, - -1, -1, -1, -1, -1, -1, -1, 575, -1, 577, - -1, 579, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 633, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 643, -1, 633, -1, -1, -1, -1, - -1, 651, -1, -1, -1, 643, -1, -1, -1, -1, - -1, -1, -1, 651, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 725, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 725, -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, 753, -1, -1, -1, 757, -1, -1, - -1, -1, -1, -1, -1, 753, -1, -1, -1, 757, + 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, -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, -1, - -1, -1, -1, -1, -1, 795, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 795, -1, -1, + 798, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 858, 859, - -1, 861, -1, 861, -1, -1, -1, -1, -1, -1, - 858, 859, -1, 861, -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, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 899, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 899, -1, -1, -1, 915, -1, -1, -1, -1, - -1, -1, 922, -1, -1, -1, -1, 915, -1, -1, - -1, -1, 932, -1, 922, -1, 936, -1, -1, -1, - -1, -1, 942, -1, 932, -1, -1, -1, 936, -1, - -1, -1, 0, -1, 942, 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, -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, -1, -1, -1, -1, -1, -1, 357, - -1, -1, -1, -1, -1, -1, -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 379, 380, 381, 382, 383, -1, -1, -1, -1, - -1, -1, -1, -1, 392, 393, 394, 395, 396, 397, - 398, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 414, 415, 416, 417, - 418, 419, 420, -1, -1, -1, -1, -1, -1, -1, - -1, 429, -1, 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, 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, -1, -1, 335, - 336, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 354, 355, - -1, 357, -1, 359, 360, -1, -1, -1, -1, 365, - 366, 367, 368, 369, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 379, 380, 381, 382, 383, -1, -1, - -1, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 401, 402, -1, 404, 405, - 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, 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, -1, - -1, 335, 336, -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, - 354, 355, -1, 357, -1, 359, 360, -1, -1, -1, - -1, 365, 366, 367, 368, 369, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 379, 380, 381, 382, 383, - -1, -1, -1, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 401, 402, -1, - 404, 405, 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, 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, -1, -1, 335, 336, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 354, 355, -1, 357, -1, 359, -1, -1, - -1, -1, -1, 365, 366, 367, 368, 369, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 379, 380, 381, - 382, 383, -1, -1, -1, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, - 402, -1, 404, 405, 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, 3, 4, 5, 6, 7, 8, 9, + -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, @@ -3251,72 +3128,677 @@ 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, -1, -1, 335, 336, -1, -1, -1, + 330, 331, 332, 333, 334, -1, -1, 337, 338, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 354, 355, -1, 357, -1, 359, - -1, -1, -1, -1, -1, 365, 366, 367, 368, 369, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, - 380, 381, 382, 383, -1, -1, -1, 387, 388, 389, + -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, -1, 404, 405, 406, 407, 408, 409, + 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, 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, -1, -1, 335, 336, -1, + 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, -1, -1, -1, -1, -1, 354, 355, -1, 357, - -1, -1, -1, -1, -1, -1, -1, 365, 366, 367, - 368, 369, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 379, 380, 381, 382, 383, -1, -1, -1, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, -1, 404, 405, 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, 3, 4, 5, + -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, + -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, 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, + -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, -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, 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, 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, + 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, 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, 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, -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, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 56, 57, 58, 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, @@ -3327,7 +3809,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, 168, 169, 170, 171, 172, 173, 174, 175, + 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, @@ -3342,27 +3824,158 @@ static const yytype_int16 yycheck[] = 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 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, -1, -1, 335, - 336, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 354, 355, - -1, 357, -1, -1, -1, -1, -1, -1, -1, 365, - 366, 367, 368, 369, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 379, 380, 381, 382, 383, -1, -1, - -1, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 429, -1, 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, 3, + 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, + -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, -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, -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, 61, 62, 63, + 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, @@ -3373,7 +3986,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, 168, 169, 170, 171, 172, 173, + 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, @@ -3388,28 +4001,159 @@ 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, -1, -1, -1, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, -1, - -1, 335, 336, -1, -1, -1, -1, -1, -1, -1, + 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, - 354, 355, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 366, 367, 368, 369, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 379, 380, 381, 382, -1, - -1, -1, -1, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, -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, - 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 429, -1, 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, 3, 4, 5, 6, 7, 8, 9, 10, 11, + -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, + -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, + -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, -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, -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, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 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, @@ -3419,7 +4163,7 @@ static const yytype_int16 yycheck[] = 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 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, @@ -3435,780 +4179,62 @@ static const yytype_int16 yycheck[] = 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -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, -1, 357, -1, -1, -1, -1, - -1, -1, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 379, 380, 381, - 382, 383, -1, -1, -1, -1, -1, -1, -1, -1, - 392, 393, 394, 395, 396, 397, 398, -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, -1, - -1, -1, 414, 415, 416, 417, 418, 419, 420, -1, - -1, -1, -1, -1, -1, -1, -1, 429, -1, 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, 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, - -1, -1, -1, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 379, - 380, 381, 382, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 392, 393, 394, 395, 396, 397, 398, 399, - -1, -1, 402, -1, 404, 405, -1, -1, 408, -1, - -1, -1, -1, -1, 414, 415, 416, 417, 418, 419, - 420, -1, -1, -1, -1, -1, -1, -1, -1, 429, - -1, 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, 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, -1, -1, -1, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 365, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 379, 380, 381, 382, -1, -1, -1, -1, -1, - -1, -1, -1, 391, 392, 393, 394, 395, 396, 397, - 398, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 414, 415, 416, 417, - 418, 419, 420, -1, -1, -1, -1, -1, -1, -1, - -1, 429, -1, 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, 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, -1, -1, -1, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 357, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 379, 380, 381, 382, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 392, 393, 394, 395, - 396, 397, 398, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 414, 415, - 416, 417, 418, 419, 420, -1, -1, -1, -1, -1, - -1, -1, -1, 429, -1, 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, 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, -1, -1, -1, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -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, 379, 380, 381, 382, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 392, 393, - 394, 395, 396, 397, 398, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 414, 415, 416, 417, 418, 419, 420, -1, -1, -1, - -1, -1, -1, -1, -1, 429, -1, 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, 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, -1, -1, - -1, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -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, 379, 380, 381, - 382, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 392, 393, 394, 395, 396, 397, 398, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 414, 415, 416, 417, 418, 419, 420, -1, - -1, -1, -1, -1, -1, -1, -1, 429, -1, 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, 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, - -1, -1, -1, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -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, 379, - 380, 381, 382, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 392, 393, 394, 395, 396, 397, 398, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 414, 415, 416, 417, 418, 419, - 420, -1, -1, -1, -1, -1, -1, -1, -1, 429, - -1, 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, 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, -1, -1, -1, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 379, 380, 381, 382, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 392, 393, 394, 395, 396, 397, - 398, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 414, 415, 416, 417, - 418, 419, 420, -1, -1, -1, -1, -1, -1, -1, - -1, 429, -1, 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, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, 359, 360, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, 359, 360, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, 358, -1, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, 359, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, 358, -1, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 365, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -1, -1, 335, 336, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 366, - 367, 368, 369, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 387, 388, 389, 390, 391, 392, -1, -1, -1, -1, - 397, 398, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, 428, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 443, 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, -1, -1, -1, -1, -1, -1, 326, - -1, -1, -1, 330, 331, 332, -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, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 392, -1, -1, -1, -1, - 397, 398 + -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 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -4248,144 +4274,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, 357, 365, 379, 380, 381, 382, 383, 392, 393, - 394, 395, 396, 397, 398, 414, 415, 416, 417, 418, - 419, 420, 429, 431, 432, 433, 434, 435, 436, 437, + 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, 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, 496, 497, 500, - 501, 502, 503, 507, 508, 509, 510, 511, 512, 515, - 516, 517, 518, 519, 521, 526, 527, 528, 569, 570, - 571, 573, 580, 584, 585, 591, 594, 355, 355, 355, - 355, 355, 355, 355, 355, 357, 527, 359, 391, 355, - 355, 365, 391, 365, 572, 356, 362, 504, 505, 506, - 516, 521, 362, 365, 391, 365, 391, 517, 521, 373, - 523, 524, 0, 570, 501, 509, 516, 365, 500, 391, - 576, 577, 595, 596, 388, 391, 576, 388, 576, 388, - 576, 388, 576, 388, 576, 576, 595, 388, 576, 391, - 574, 575, 521, 530, 359, 391, 415, 513, 514, 391, - 520, 357, 365, 522, 359, 548, 573, 505, 504, 506, - 391, 391, 355, 364, 522, 359, 362, 365, 499, 335, - 336, 354, 355, 366, 367, 368, 369, 387, 388, 389, - 390, 391, 421, 422, 423, 424, 425, 426, 427, 428, - 466, 467, 468, 470, 471, 472, 473, 474, 475, 476, - 477, 478, 519, 521, 525, 522, 356, 391, 365, 364, - 362, 356, 362, 356, 362, 364, 362, 362, 362, 356, - 362, 362, 362, 362, 362, 362, 362, 356, 362, 356, - 362, 355, 358, 362, 365, 516, 521, 531, 532, 529, - 364, 356, 362, 356, 362, 358, 477, 479, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 521, - 357, 365, 359, 360, 365, 399, 400, 401, 402, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 430, - 477, 490, 492, 494, 496, 500, 519, 521, 537, 538, - 539, 540, 541, 549, 550, 551, 552, 555, 556, 559, - 560, 561, 568, 573, 522, 364, 522, 359, 492, 535, - 364, 498, 391, 362, 365, 477, 477, 494, 335, 336, - 357, 361, 356, 356, 362, 398, 492, 355, 477, 362, - 374, 573, 354, 357, 388, 577, 595, 391, 596, 354, - 387, 388, 389, 390, 581, 582, 388, 490, 495, 583, - 388, 387, 388, 389, 390, 586, 587, 388, 387, 388, - 389, 390, 466, 588, 589, 388, 354, 590, 388, 595, - 391, 495, 526, 592, 593, 388, 495, 358, 575, 521, - 391, 533, 534, 360, 532, 531, 495, 514, 391, 370, - 371, 372, 367, 369, 333, 334, 337, 338, 373, 374, - 339, 340, 377, 376, 375, 341, 343, 342, 378, 358, - 358, 490, 360, 542, 355, 365, 365, 563, 355, 355, - 365, 365, 494, 355, 494, 363, 365, 365, 365, 365, - 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, - 364, 493, 362, 365, 360, 538, 552, 556, 561, 535, - 364, 360, 535, 536, 535, 531, 391, 356, 469, 494, - 391, 492, 477, 354, 388, 578, 579, 356, 364, 356, - 362, 356, 362, 356, 362, 362, 356, 362, 356, 362, - 356, 362, 362, 356, 362, 362, 356, 362, 356, 362, - 356, 356, 533, 522, 362, 365, 360, 477, 477, 477, - 479, 479, 480, 480, 481, 481, 481, 481, 482, 482, - 483, 484, 485, 486, 487, 488, 491, 358, 549, 562, - 538, 564, 494, 365, 494, 363, 492, 492, 535, 360, - 362, 360, 358, 358, 362, 358, 362, 582, 581, 495, - 583, 587, 586, 589, 588, 354, 590, 592, 593, 365, - 534, 494, 543, 494, 509, 554, 399, 537, 550, 565, - 356, 356, 360, 535, 354, 388, 356, 356, 356, 356, - 356, 356, 363, 360, 391, 356, 355, 554, 566, 567, - 545, 546, 547, 553, 557, 492, 364, 539, 544, 548, - 494, 365, 356, 403, 541, 539, 359, 535, 356, 494, - 544, 545, 549, 558, 365, 360 + 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 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_int16 yyr1[] = { - 0, 465, 466, 467, 467, 467, 467, 467, 467, 467, - 467, 467, 467, 467, 467, 467, 467, 467, 468, 468, - 468, 468, 468, 468, 469, 470, 471, 472, 472, 473, - 473, 474, 474, 475, 476, 476, 476, 477, 477, 477, - 477, 478, 478, 478, 478, 479, 479, 479, 479, 480, - 480, 480, 481, 481, 481, 482, 482, 482, 482, 482, - 483, 483, 483, 484, 484, 485, 485, 486, 486, 487, - 487, 488, 488, 489, 489, 490, 491, 490, 492, 492, - 493, 493, 493, 493, 493, 493, 493, 493, 493, 493, - 493, 494, 494, 495, 496, 496, 496, 496, 496, 496, - 496, 496, 496, 496, 496, 498, 497, 499, 499, 500, - 500, 500, 500, 501, 501, 502, 502, 503, 504, 504, - 505, 505, 505, 505, 506, 507, 507, 507, 507, 507, - 508, 508, 508, 508, 508, 509, 509, 510, 511, 511, - 511, 511, 511, 511, 511, 511, 511, 511, 512, 513, - 513, 514, 514, 514, 515, 516, 516, 517, 517, 517, - 517, 517, 517, 517, 517, 517, 517, 517, 518, 518, - 518, 518, 518, 518, 518, 518, 518, 518, 518, 518, - 518, 518, 518, 518, 518, 518, 518, 518, 518, 518, - 518, 518, 518, 518, 518, 518, 518, 518, 518, 518, - 518, 518, 518, 518, 518, 518, 519, 520, 520, 521, - 521, 522, 522, 522, 522, 523, 523, 524, 525, 525, - 525, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, - 526, 527, 527, 527, 529, 528, 530, 528, 531, 531, - 532, 532, 533, 533, 534, 534, 535, 535, 535, 535, - 536, 536, 537, 538, 538, 539, 539, 539, 539, 539, - 539, 539, 539, 540, 541, 542, 543, 541, 544, 544, - 546, 545, 547, 545, 548, 548, 549, 549, 550, 550, - 551, 551, 552, 553, 553, 554, 554, 555, 555, 557, - 556, 558, 558, 559, 559, 560, 560, 562, 561, 563, - 561, 564, 561, 565, 565, 566, 566, 567, 567, 568, - 568, 568, 568, 568, 568, 568, 568, 569, 569, 570, - 570, 570, 572, 571, 573, 574, 574, 575, 575, 576, - 576, 577, 577, 578, 578, 579, 579, 580, 580, 580, - 580, 580, 580, 581, 581, 582, 582, 582, 582, 582, - 583, 583, 584, 584, 585, 585, 585, 585, 585, 585, - 585, 585, 586, 586, 587, 587, 587, 587, 588, 588, - 589, 589, 589, 589, 589, 590, 590, 591, 591, 591, - 591, 592, 592, 593, 593, 594, 594, 595, 595, 596, - 596 + 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 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -4445,23 +4471,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, 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, 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 }; @@ -5203,260 +5229,260 @@ yyreduce: switch (yyn) { case 2: /* variable_identifier: IDENTIFIER */ -#line 355 "MachineIndependent/glslang.y" +#line 356 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 5211 "MachineIndependent/glslang_tab.cpp" +#line 5237 "MachineIndependent/glslang_tab.cpp" break; case 3: /* primary_expression: variable_identifier */ -#line 361 "MachineIndependent/glslang.y" +#line 362 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5219 "MachineIndependent/glslang_tab.cpp" +#line 5245 "MachineIndependent/glslang_tab.cpp" break; case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN */ -#line 364 "MachineIndependent/glslang.y" +#line 365 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 5229 "MachineIndependent/glslang_tab.cpp" +#line 5255 "MachineIndependent/glslang_tab.cpp" break; case 5: /* primary_expression: FLOATCONSTANT */ -#line 369 "MachineIndependent/glslang.y" +#line 370 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 5237 "MachineIndependent/glslang_tab.cpp" +#line 5263 "MachineIndependent/glslang_tab.cpp" break; case 6: /* primary_expression: INTCONSTANT */ -#line 372 "MachineIndependent/glslang.y" +#line 373 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5245 "MachineIndependent/glslang_tab.cpp" +#line 5271 "MachineIndependent/glslang_tab.cpp" break; case 7: /* primary_expression: UINTCONSTANT */ -#line 375 "MachineIndependent/glslang.y" +#line 376 "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 5254 "MachineIndependent/glslang_tab.cpp" +#line 5280 "MachineIndependent/glslang_tab.cpp" break; case 8: /* primary_expression: BOOLCONSTANT */ -#line 379 "MachineIndependent/glslang.y" +#line 380 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 5262 "MachineIndependent/glslang_tab.cpp" - break; - - case 9: /* primary_expression: STRING_LITERAL */ -#line 382 "MachineIndependent/glslang.y" - { - (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); - } -#line 5270 "MachineIndependent/glslang_tab.cpp" - break; - - case 10: /* primary_expression: INT32CONSTANT */ -#line 385 "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 5279 "MachineIndependent/glslang_tab.cpp" - break; - - case 11: /* primary_expression: UINT32CONSTANT */ -#line 389 "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 5288 "MachineIndependent/glslang_tab.cpp" break; + case 9: /* primary_expression: STRING_LITERAL */ +#line 383 "MachineIndependent/glslang.y" + { + (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); + } +#line 5296 "MachineIndependent/glslang_tab.cpp" + break; + + case 10: /* primary_expression: INT32CONSTANT */ +#line 386 "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" + break; + + case 11: /* primary_expression: UINT32CONSTANT */ +#line 390 "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" + break; + case 12: /* primary_expression: INT64CONSTANT */ -#line 393 "MachineIndependent/glslang.y" +#line 394 "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 5297 "MachineIndependent/glslang_tab.cpp" +#line 5323 "MachineIndependent/glslang_tab.cpp" break; case 13: /* primary_expression: UINT64CONSTANT */ -#line 397 "MachineIndependent/glslang.y" +#line 398 "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 5306 "MachineIndependent/glslang_tab.cpp" +#line 5332 "MachineIndependent/glslang_tab.cpp" break; case 14: /* primary_expression: INT16CONSTANT */ -#line 401 "MachineIndependent/glslang.y" +#line 402 "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 5315 "MachineIndependent/glslang_tab.cpp" +#line 5341 "MachineIndependent/glslang_tab.cpp" break; case 15: /* primary_expression: UINT16CONSTANT */ -#line 405 "MachineIndependent/glslang.y" +#line 406 "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 5324 "MachineIndependent/glslang_tab.cpp" +#line 5350 "MachineIndependent/glslang_tab.cpp" break; case 16: /* primary_expression: DOUBLECONSTANT */ -#line 409 "MachineIndependent/glslang.y" +#line 410 "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 5335 "MachineIndependent/glslang_tab.cpp" +#line 5361 "MachineIndependent/glslang_tab.cpp" break; case 17: /* primary_expression: FLOAT16CONSTANT */ -#line 415 "MachineIndependent/glslang.y" +#line 416 "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 5344 "MachineIndependent/glslang_tab.cpp" +#line 5370 "MachineIndependent/glslang_tab.cpp" break; case 18: /* postfix_expression: primary_expression */ -#line 422 "MachineIndependent/glslang.y" +#line 423 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5352 "MachineIndependent/glslang_tab.cpp" +#line 5378 "MachineIndependent/glslang_tab.cpp" break; case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET */ -#line 425 "MachineIndependent/glslang.y" +#line 426 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 5360 "MachineIndependent/glslang_tab.cpp" +#line 5386 "MachineIndependent/glslang_tab.cpp" break; case 20: /* postfix_expression: function_call */ -#line 428 "MachineIndependent/glslang.y" +#line 429 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5368 "MachineIndependent/glslang_tab.cpp" +#line 5394 "MachineIndependent/glslang_tab.cpp" break; case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER */ -#line 431 "MachineIndependent/glslang.y" +#line 432 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 5376 "MachineIndependent/glslang_tab.cpp" +#line 5402 "MachineIndependent/glslang_tab.cpp" break; case 22: /* postfix_expression: postfix_expression INC_OP */ -#line 434 "MachineIndependent/glslang.y" +#line 435 "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 5386 "MachineIndependent/glslang_tab.cpp" +#line 5412 "MachineIndependent/glslang_tab.cpp" break; case 23: /* postfix_expression: postfix_expression DEC_OP */ -#line 439 "MachineIndependent/glslang.y" +#line 440 "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 5396 "MachineIndependent/glslang_tab.cpp" +#line 5422 "MachineIndependent/glslang_tab.cpp" break; case 24: /* integer_expression: expression */ -#line 447 "MachineIndependent/glslang.y" +#line 448 "MachineIndependent/glslang.y" { parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5405 "MachineIndependent/glslang_tab.cpp" +#line 5431 "MachineIndependent/glslang_tab.cpp" break; case 25: /* function_call: function_call_or_method */ -#line 454 "MachineIndependent/glslang.y" +#line 455 "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 5414 "MachineIndependent/glslang_tab.cpp" - break; - - case 26: /* function_call_or_method: function_call_generic */ -#line 461 "MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[0].interm); - } -#line 5422 "MachineIndependent/glslang_tab.cpp" - break; - - case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN */ -#line 467 "MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[-1].interm); - (yyval.interm).loc = (yyvsp[0].lex).loc; - } -#line 5431 "MachineIndependent/glslang_tab.cpp" - break; - - case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN */ -#line 471 "MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[-1].interm); - (yyval.interm).loc = (yyvsp[0].lex).loc; - } #line 5440 "MachineIndependent/glslang_tab.cpp" break; - case 29: /* function_call_header_no_parameters: function_call_header VOID */ -#line 478 "MachineIndependent/glslang.y" - { - (yyval.interm) = (yyvsp[-1].interm); + case 26: /* function_call_or_method: function_call_generic */ +#line 462 "MachineIndependent/glslang.y" + { + (yyval.interm) = (yyvsp[0].interm); } #line 5448 "MachineIndependent/glslang_tab.cpp" break; + case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN */ +#line 468 "MachineIndependent/glslang.y" + { + (yyval.interm) = (yyvsp[-1].interm); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 5457 "MachineIndependent/glslang_tab.cpp" + break; + + case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN */ +#line 472 "MachineIndependent/glslang.y" + { + (yyval.interm) = (yyvsp[-1].interm); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 5466 "MachineIndependent/glslang_tab.cpp" + break; + + case 29: /* function_call_header_no_parameters: function_call_header VOID */ +#line 479 "MachineIndependent/glslang.y" + { + (yyval.interm) = (yyvsp[-1].interm); + } +#line 5474 "MachineIndependent/glslang_tab.cpp" + break; + case 30: /* function_call_header_no_parameters: function_call_header */ -#line 481 "MachineIndependent/glslang.y" +#line 482 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5456 "MachineIndependent/glslang_tab.cpp" +#line 5482 "MachineIndependent/glslang_tab.cpp" break; case 31: /* function_call_header_with_parameters: function_call_header assignment_expression */ -#line 487 "MachineIndependent/glslang.y" +#line 488 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5475,11 +5501,11 @@ yyreduce: (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } } -#line 5479 "MachineIndependent/glslang_tab.cpp" +#line 5505 "MachineIndependent/glslang_tab.cpp" break; case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression */ -#line 505 "MachineIndependent/glslang.y" +#line 506 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5502,29 +5528,29 @@ yyreduce: (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } } -#line 5506 "MachineIndependent/glslang_tab.cpp" +#line 5532 "MachineIndependent/glslang_tab.cpp" break; case 33: /* function_call_header: function_identifier LEFT_PAREN */ -#line 530 "MachineIndependent/glslang.y" +#line 531 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5514 "MachineIndependent/glslang_tab.cpp" +#line 5540 "MachineIndependent/glslang_tab.cpp" break; case 34: /* function_identifier: type_specifier */ -#line 538 "MachineIndependent/glslang.y" +#line 539 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5524 "MachineIndependent/glslang_tab.cpp" +#line 5550 "MachineIndependent/glslang_tab.cpp" break; case 35: /* function_identifier: postfix_expression */ -#line 543 "MachineIndependent/glslang.y" +#line 544 "MachineIndependent/glslang.y" { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -5552,50 +5578,50 @@ yyreduce: (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 5556 "MachineIndependent/glslang_tab.cpp" +#line 5582 "MachineIndependent/glslang_tab.cpp" break; case 36: /* function_identifier: non_uniform_qualifier */ -#line 570 "MachineIndependent/glslang.y" +#line 571 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5566 "MachineIndependent/glslang_tab.cpp" +#line 5592 "MachineIndependent/glslang_tab.cpp" break; case 37: /* unary_expression: postfix_expression */ -#line 578 "MachineIndependent/glslang.y" +#line 579 "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 5577 "MachineIndependent/glslang_tab.cpp" +#line 5603 "MachineIndependent/glslang_tab.cpp" break; case 38: /* unary_expression: INC_OP unary_expression */ -#line 584 "MachineIndependent/glslang.y" +#line 585 "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 5586 "MachineIndependent/glslang_tab.cpp" +#line 5612 "MachineIndependent/glslang_tab.cpp" break; case 39: /* unary_expression: DEC_OP unary_expression */ -#line 588 "MachineIndependent/glslang.y" +#line 589 "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 5595 "MachineIndependent/glslang_tab.cpp" +#line 5621 "MachineIndependent/glslang_tab.cpp" break; case 40: /* unary_expression: unary_operator unary_expression */ -#line 592 "MachineIndependent/glslang.y" +#line 593 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -5612,179 +5638,179 @@ yyreduce: (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 5616 "MachineIndependent/glslang_tab.cpp" +#line 5642 "MachineIndependent/glslang_tab.cpp" break; case 41: /* unary_operator: PLUS */ -#line 612 "MachineIndependent/glslang.y" +#line 613 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 5622 "MachineIndependent/glslang_tab.cpp" +#line 5648 "MachineIndependent/glslang_tab.cpp" break; case 42: /* unary_operator: DASH */ -#line 613 "MachineIndependent/glslang.y" +#line 614 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 5628 "MachineIndependent/glslang_tab.cpp" +#line 5654 "MachineIndependent/glslang_tab.cpp" break; case 43: /* unary_operator: BANG */ -#line 614 "MachineIndependent/glslang.y" +#line 615 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 5634 "MachineIndependent/glslang_tab.cpp" +#line 5660 "MachineIndependent/glslang_tab.cpp" break; case 44: /* unary_operator: TILDE */ -#line 615 "MachineIndependent/glslang.y" +#line 616 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } -#line 5641 "MachineIndependent/glslang_tab.cpp" +#line 5667 "MachineIndependent/glslang_tab.cpp" break; case 45: /* multiplicative_expression: unary_expression */ -#line 621 "MachineIndependent/glslang.y" +#line 622 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5647 "MachineIndependent/glslang_tab.cpp" +#line 5673 "MachineIndependent/glslang_tab.cpp" break; case 46: /* multiplicative_expression: multiplicative_expression STAR unary_expression */ -#line 622 "MachineIndependent/glslang.y" +#line 623 "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 5657 "MachineIndependent/glslang_tab.cpp" +#line 5683 "MachineIndependent/glslang_tab.cpp" break; case 47: /* multiplicative_expression: multiplicative_expression SLASH unary_expression */ -#line 627 "MachineIndependent/glslang.y" +#line 628 "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 5667 "MachineIndependent/glslang_tab.cpp" +#line 5693 "MachineIndependent/glslang_tab.cpp" break; case 48: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression */ -#line 632 "MachineIndependent/glslang.y" +#line 633 "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 5678 "MachineIndependent/glslang_tab.cpp" +#line 5704 "MachineIndependent/glslang_tab.cpp" break; case 49: /* additive_expression: multiplicative_expression */ -#line 641 "MachineIndependent/glslang.y" +#line 642 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5684 "MachineIndependent/glslang_tab.cpp" +#line 5710 "MachineIndependent/glslang_tab.cpp" break; case 50: /* additive_expression: additive_expression PLUS multiplicative_expression */ -#line 642 "MachineIndependent/glslang.y" +#line 643 "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 5694 "MachineIndependent/glslang_tab.cpp" +#line 5720 "MachineIndependent/glslang_tab.cpp" break; case 51: /* additive_expression: additive_expression DASH multiplicative_expression */ -#line 647 "MachineIndependent/glslang.y" +#line 648 "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 5704 "MachineIndependent/glslang_tab.cpp" +#line 5730 "MachineIndependent/glslang_tab.cpp" break; case 52: /* shift_expression: additive_expression */ -#line 655 "MachineIndependent/glslang.y" +#line 656 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5710 "MachineIndependent/glslang_tab.cpp" +#line 5736 "MachineIndependent/glslang_tab.cpp" break; case 53: /* shift_expression: shift_expression LEFT_OP additive_expression */ -#line 656 "MachineIndependent/glslang.y" +#line 657 "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 5721 "MachineIndependent/glslang_tab.cpp" +#line 5747 "MachineIndependent/glslang_tab.cpp" break; case 54: /* shift_expression: shift_expression RIGHT_OP additive_expression */ -#line 662 "MachineIndependent/glslang.y" +#line 663 "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 5732 "MachineIndependent/glslang_tab.cpp" +#line 5758 "MachineIndependent/glslang_tab.cpp" break; case 55: /* relational_expression: shift_expression */ -#line 671 "MachineIndependent/glslang.y" +#line 672 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5738 "MachineIndependent/glslang_tab.cpp" +#line 5764 "MachineIndependent/glslang_tab.cpp" break; case 56: /* relational_expression: relational_expression LEFT_ANGLE shift_expression */ -#line 672 "MachineIndependent/glslang.y" +#line 673 "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 5748 "MachineIndependent/glslang_tab.cpp" +#line 5774 "MachineIndependent/glslang_tab.cpp" break; case 57: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression */ -#line 677 "MachineIndependent/glslang.y" +#line 678 "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 5758 "MachineIndependent/glslang_tab.cpp" +#line 5784 "MachineIndependent/glslang_tab.cpp" break; case 58: /* relational_expression: relational_expression LE_OP shift_expression */ -#line 682 "MachineIndependent/glslang.y" +#line 683 "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 5768 "MachineIndependent/glslang_tab.cpp" +#line 5794 "MachineIndependent/glslang_tab.cpp" break; case 59: /* relational_expression: relational_expression GE_OP shift_expression */ -#line 687 "MachineIndependent/glslang.y" +#line 688 "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 5778 "MachineIndependent/glslang_tab.cpp" +#line 5804 "MachineIndependent/glslang_tab.cpp" break; case 60: /* equality_expression: relational_expression */ -#line 695 "MachineIndependent/glslang.y" +#line 696 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5784 "MachineIndependent/glslang_tab.cpp" +#line 5810 "MachineIndependent/glslang_tab.cpp" break; case 61: /* equality_expression: equality_expression EQ_OP relational_expression */ -#line 696 "MachineIndependent/glslang.y" +#line 697 "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(), "=="); @@ -5794,11 +5820,11 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5798 "MachineIndependent/glslang_tab.cpp" +#line 5824 "MachineIndependent/glslang_tab.cpp" break; case 62: /* equality_expression: equality_expression NE_OP relational_expression */ -#line 705 "MachineIndependent/glslang.y" +#line 706 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -5808,124 +5834,124 @@ yyreduce: if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5812 "MachineIndependent/glslang_tab.cpp" +#line 5838 "MachineIndependent/glslang_tab.cpp" break; case 63: /* and_expression: equality_expression */ -#line 717 "MachineIndependent/glslang.y" +#line 718 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5818 "MachineIndependent/glslang_tab.cpp" +#line 5844 "MachineIndependent/glslang_tab.cpp" break; case 64: /* and_expression: and_expression AMPERSAND equality_expression */ -#line 718 "MachineIndependent/glslang.y" +#line 719 "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 5829 "MachineIndependent/glslang_tab.cpp" +#line 5855 "MachineIndependent/glslang_tab.cpp" break; case 65: /* exclusive_or_expression: and_expression */ -#line 727 "MachineIndependent/glslang.y" +#line 728 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5835 "MachineIndependent/glslang_tab.cpp" +#line 5861 "MachineIndependent/glslang_tab.cpp" break; case 66: /* exclusive_or_expression: exclusive_or_expression CARET and_expression */ -#line 728 "MachineIndependent/glslang.y" +#line 729 "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 5846 "MachineIndependent/glslang_tab.cpp" +#line 5872 "MachineIndependent/glslang_tab.cpp" break; case 67: /* inclusive_or_expression: exclusive_or_expression */ -#line 737 "MachineIndependent/glslang.y" +#line 738 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5852 "MachineIndependent/glslang_tab.cpp" +#line 5878 "MachineIndependent/glslang_tab.cpp" break; case 68: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression */ -#line 738 "MachineIndependent/glslang.y" +#line 739 "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 5863 "MachineIndependent/glslang_tab.cpp" +#line 5889 "MachineIndependent/glslang_tab.cpp" break; case 69: /* logical_and_expression: inclusive_or_expression */ -#line 747 "MachineIndependent/glslang.y" +#line 748 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5869 "MachineIndependent/glslang_tab.cpp" +#line 5895 "MachineIndependent/glslang_tab.cpp" break; case 70: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression */ -#line 748 "MachineIndependent/glslang.y" +#line 749 "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 5879 "MachineIndependent/glslang_tab.cpp" +#line 5905 "MachineIndependent/glslang_tab.cpp" break; case 71: /* logical_xor_expression: logical_and_expression */ -#line 756 "MachineIndependent/glslang.y" +#line 757 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5885 "MachineIndependent/glslang_tab.cpp" +#line 5911 "MachineIndependent/glslang_tab.cpp" break; case 72: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression */ -#line 757 "MachineIndependent/glslang.y" +#line 758 "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 5895 "MachineIndependent/glslang_tab.cpp" +#line 5921 "MachineIndependent/glslang_tab.cpp" break; case 73: /* logical_or_expression: logical_xor_expression */ -#line 765 "MachineIndependent/glslang.y" +#line 766 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5901 "MachineIndependent/glslang_tab.cpp" +#line 5927 "MachineIndependent/glslang_tab.cpp" break; case 74: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression */ -#line 766 "MachineIndependent/glslang.y" +#line 767 "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 5911 "MachineIndependent/glslang_tab.cpp" +#line 5937 "MachineIndependent/glslang_tab.cpp" break; case 75: /* conditional_expression: logical_or_expression */ -#line 774 "MachineIndependent/glslang.y" +#line 775 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5917 "MachineIndependent/glslang_tab.cpp" +#line 5943 "MachineIndependent/glslang_tab.cpp" break; case 76: /* $@1: %empty */ -#line 775 "MachineIndependent/glslang.y" +#line 776 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 5925 "MachineIndependent/glslang_tab.cpp" +#line 5951 "MachineIndependent/glslang_tab.cpp" break; case 77: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression */ -#line 778 "MachineIndependent/glslang.y" +#line 779 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -5938,17 +5964,17 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 5942 "MachineIndependent/glslang_tab.cpp" +#line 5968 "MachineIndependent/glslang_tab.cpp" break; case 78: /* assignment_expression: conditional_expression */ -#line 793 "MachineIndependent/glslang.y" +#line 794 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5948 "MachineIndependent/glslang_tab.cpp" +#line 5974 "MachineIndependent/glslang_tab.cpp" break; case 79: /* assignment_expression: unary_expression assignment_operator assignment_expression */ -#line 794 "MachineIndependent/glslang.y" +#line 795 "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(), "="); @@ -5962,119 +5988,119 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 5966 "MachineIndependent/glslang_tab.cpp" +#line 5992 "MachineIndependent/glslang_tab.cpp" break; case 80: /* assignment_operator: EQUAL */ -#line 810 "MachineIndependent/glslang.y" +#line 811 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 5975 "MachineIndependent/glslang_tab.cpp" +#line 6001 "MachineIndependent/glslang_tab.cpp" break; case 81: /* assignment_operator: MUL_ASSIGN */ -#line 814 "MachineIndependent/glslang.y" +#line 815 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 5984 "MachineIndependent/glslang_tab.cpp" +#line 6010 "MachineIndependent/glslang_tab.cpp" break; case 82: /* assignment_operator: DIV_ASSIGN */ -#line 818 "MachineIndependent/glslang.y" +#line 819 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 5993 "MachineIndependent/glslang_tab.cpp" +#line 6019 "MachineIndependent/glslang_tab.cpp" break; case 83: /* assignment_operator: MOD_ASSIGN */ -#line 822 "MachineIndependent/glslang.y" +#line 823 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 6003 "MachineIndependent/glslang_tab.cpp" +#line 6029 "MachineIndependent/glslang_tab.cpp" break; case 84: /* assignment_operator: ADD_ASSIGN */ -#line 827 "MachineIndependent/glslang.y" +#line 828 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 6012 "MachineIndependent/glslang_tab.cpp" +#line 6038 "MachineIndependent/glslang_tab.cpp" break; case 85: /* assignment_operator: SUB_ASSIGN */ -#line 831 "MachineIndependent/glslang.y" +#line 832 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 6021 "MachineIndependent/glslang_tab.cpp" +#line 6047 "MachineIndependent/glslang_tab.cpp" break; case 86: /* assignment_operator: LEFT_ASSIGN */ -#line 835 "MachineIndependent/glslang.y" +#line 836 "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 6030 "MachineIndependent/glslang_tab.cpp" +#line 6056 "MachineIndependent/glslang_tab.cpp" break; case 87: /* assignment_operator: RIGHT_ASSIGN */ -#line 839 "MachineIndependent/glslang.y" +#line 840 "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 6039 "MachineIndependent/glslang_tab.cpp" +#line 6065 "MachineIndependent/glslang_tab.cpp" break; case 88: /* assignment_operator: AND_ASSIGN */ -#line 843 "MachineIndependent/glslang.y" +#line 844 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 6048 "MachineIndependent/glslang_tab.cpp" +#line 6074 "MachineIndependent/glslang_tab.cpp" break; case 89: /* assignment_operator: XOR_ASSIGN */ -#line 847 "MachineIndependent/glslang.y" +#line 848 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 6057 "MachineIndependent/glslang_tab.cpp" +#line 6083 "MachineIndependent/glslang_tab.cpp" break; case 90: /* assignment_operator: OR_ASSIGN */ -#line 851 "MachineIndependent/glslang.y" +#line 852 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 6066 "MachineIndependent/glslang_tab.cpp" +#line 6092 "MachineIndependent/glslang_tab.cpp" break; case 91: /* expression: assignment_expression */ -#line 858 "MachineIndependent/glslang.y" +#line 859 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6074 "MachineIndependent/glslang_tab.cpp" +#line 6100 "MachineIndependent/glslang_tab.cpp" break; case 92: /* expression: expression COMMA assignment_expression */ -#line 861 "MachineIndependent/glslang.y" +#line 862 "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); @@ -6083,30 +6109,30 @@ yyreduce: (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6087 "MachineIndependent/glslang_tab.cpp" +#line 6113 "MachineIndependent/glslang_tab.cpp" break; case 93: /* constant_expression: conditional_expression */ -#line 872 "MachineIndependent/glslang.y" +#line 873 "MachineIndependent/glslang.y" { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6096 "MachineIndependent/glslang_tab.cpp" +#line 6122 "MachineIndependent/glslang_tab.cpp" break; case 94: /* declaration: function_prototype SEMICOLON */ -#line 879 "MachineIndependent/glslang.y" +#line 880 "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 6106 "MachineIndependent/glslang_tab.cpp" +#line 6132 "MachineIndependent/glslang_tab.cpp" break; case 95: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON */ -#line 884 "MachineIndependent/glslang.y" +#line 885 "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 @@ -6114,31 +6140,31 @@ yyreduce: (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6118 "MachineIndependent/glslang_tab.cpp" +#line 6144 "MachineIndependent/glslang_tab.cpp" break; case 96: /* declaration: spirv_execution_mode_qualifier SEMICOLON */ -#line 891 "MachineIndependent/glslang.y" +#line 892 "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 6128 "MachineIndependent/glslang_tab.cpp" +#line 6154 "MachineIndependent/glslang_tab.cpp" break; case 97: /* declaration: init_declarator_list SEMICOLON */ -#line 896 "MachineIndependent/glslang.y" +#line 897 "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 6138 "MachineIndependent/glslang_tab.cpp" +#line 6164 "MachineIndependent/glslang_tab.cpp" break; case 98: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON */ -#line 901 "MachineIndependent/glslang.y" +#line 902 "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 @@ -6146,75 +6172,75 @@ yyreduce: parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 6150 "MachineIndependent/glslang_tab.cpp" +#line 6176 "MachineIndependent/glslang_tab.cpp" break; case 99: /* declaration: block_structure SEMICOLON */ -#line 908 "MachineIndependent/glslang.y" +#line 909 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 6159 "MachineIndependent/glslang_tab.cpp" +#line 6185 "MachineIndependent/glslang_tab.cpp" break; case 100: /* declaration: block_structure IDENTIFIER SEMICOLON */ -#line 912 "MachineIndependent/glslang.y" +#line 913 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 6168 "MachineIndependent/glslang_tab.cpp" +#line 6194 "MachineIndependent/glslang_tab.cpp" break; case 101: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON */ -#line 916 "MachineIndependent/glslang.y" +#line 917 "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 6177 "MachineIndependent/glslang_tab.cpp" +#line 6203 "MachineIndependent/glslang_tab.cpp" break; case 102: /* declaration: type_qualifier SEMICOLON */ -#line 920 "MachineIndependent/glslang.y" +#line 921 "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 6187 "MachineIndependent/glslang_tab.cpp" +#line 6213 "MachineIndependent/glslang_tab.cpp" break; case 103: /* declaration: type_qualifier IDENTIFIER SEMICOLON */ -#line 925 "MachineIndependent/glslang.y" +#line 926 "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 6197 "MachineIndependent/glslang_tab.cpp" +#line 6223 "MachineIndependent/glslang_tab.cpp" break; case 104: /* declaration: type_qualifier IDENTIFIER identifier_list SEMICOLON */ -#line 930 "MachineIndependent/glslang.y" +#line 931 "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 6208 "MachineIndependent/glslang_tab.cpp" +#line 6234 "MachineIndependent/glslang_tab.cpp" break; case 105: /* $@2: %empty */ -#line 939 "MachineIndependent/glslang.y" +#line 940 "MachineIndependent/glslang.y" { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 6214 "MachineIndependent/glslang_tab.cpp" +#line 6240 "MachineIndependent/glslang_tab.cpp" break; case 106: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE */ -#line 939 "MachineIndependent/glslang.y" +#line 940 "MachineIndependent/glslang.y" { --parseContext.blockNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -6224,39 +6250,39 @@ yyreduce: (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 6228 "MachineIndependent/glslang_tab.cpp" +#line 6254 "MachineIndependent/glslang_tab.cpp" break; case 107: /* identifier_list: COMMA IDENTIFIER */ -#line 950 "MachineIndependent/glslang.y" +#line 951 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6237 "MachineIndependent/glslang_tab.cpp" +#line 6263 "MachineIndependent/glslang_tab.cpp" break; case 108: /* identifier_list: identifier_list COMMA IDENTIFIER */ -#line 954 "MachineIndependent/glslang.y" +#line 955 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6246 "MachineIndependent/glslang_tab.cpp" +#line 6272 "MachineIndependent/glslang_tab.cpp" break; case 109: /* function_prototype: function_declarator RIGHT_PAREN */ -#line 961 "MachineIndependent/glslang.y" +#line 962 "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 6256 "MachineIndependent/glslang_tab.cpp" +#line 6282 "MachineIndependent/glslang_tab.cpp" break; case 110: /* function_prototype: function_declarator RIGHT_PAREN attribute */ -#line 966 "MachineIndependent/glslang.y" +#line 967 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6265,11 +6291,11 @@ yyreduce: parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6269 "MachineIndependent/glslang_tab.cpp" +#line 6295 "MachineIndependent/glslang_tab.cpp" break; case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN */ -#line 974 "MachineIndependent/glslang.y" +#line 975 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6278,11 +6304,11 @@ yyreduce: parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes)); } -#line 6282 "MachineIndependent/glslang_tab.cpp" +#line 6308 "MachineIndependent/glslang_tab.cpp" break; case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ -#line 982 "MachineIndependent/glslang.y" +#line 983 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6292,27 +6318,27 @@ yyreduce: parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes)); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6296 "MachineIndependent/glslang_tab.cpp" +#line 6322 "MachineIndependent/glslang_tab.cpp" break; case 113: /* function_declarator: function_header */ -#line 994 "MachineIndependent/glslang.y" +#line 995 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6304 "MachineIndependent/glslang_tab.cpp" +#line 6330 "MachineIndependent/glslang_tab.cpp" break; case 114: /* function_declarator: function_header_with_parameters */ -#line 997 "MachineIndependent/glslang.y" +#line 998 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6312 "MachineIndependent/glslang_tab.cpp" +#line 6338 "MachineIndependent/glslang_tab.cpp" break; case 115: /* function_header_with_parameters: function_header parameter_declaration */ -#line 1004 "MachineIndependent/glslang.y" +#line 1005 "MachineIndependent/glslang.y" { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -6326,11 +6352,11 @@ yyreduce: else delete (yyvsp[0].interm).param.type; } -#line 6330 "MachineIndependent/glslang_tab.cpp" +#line 6356 "MachineIndependent/glslang_tab.cpp" break; case 116: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ -#line 1017 "MachineIndependent/glslang.y" +#line 1018 "MachineIndependent/glslang.y" { // // Only first parameter of one-parameter functions can be void @@ -6351,11 +6377,11 @@ yyreduce: parseContext.vkRelaxedRemapFunctionParameter((yyvsp[-2].interm.function), (yyvsp[0].interm).param); } } -#line 6355 "MachineIndependent/glslang_tab.cpp" +#line 6381 "MachineIndependent/glslang_tab.cpp" break; case 117: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN */ -#line 1040 "MachineIndependent/glslang.y" +#line 1041 "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", @@ -6375,11 +6401,11 @@ yyreduce: function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 6379 "MachineIndependent/glslang_tab.cpp" +#line 6405 "MachineIndependent/glslang_tab.cpp" break; case 118: /* parameter_declarator: type_specifier IDENTIFIER */ -#line 1063 "MachineIndependent/glslang.y" +#line 1064 "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"); @@ -6395,11 +6421,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 6399 "MachineIndependent/glslang_tab.cpp" +#line 6425 "MachineIndependent/glslang_tab.cpp" break; case 119: /* parameter_declarator: type_specifier IDENTIFIER array_specifier */ -#line 1078 "MachineIndependent/glslang.y" +#line 1079 "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"); @@ -6419,11 +6445,11 @@ yyreduce: (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 6423 "MachineIndependent/glslang_tab.cpp" +#line 6449 "MachineIndependent/glslang_tab.cpp" break; case 120: /* parameter_declaration: type_qualifier parameter_declarator */ -#line 1103 "MachineIndependent/glslang.y" +#line 1104 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -6435,11 +6461,11 @@ yyreduce: parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6439 "MachineIndependent/glslang_tab.cpp" +#line 6465 "MachineIndependent/glslang_tab.cpp" break; case 121: /* parameter_declaration: parameter_declarator */ -#line 1114 "MachineIndependent/glslang.y" +#line 1115 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); @@ -6447,11 +6473,11 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); } -#line 6451 "MachineIndependent/glslang_tab.cpp" +#line 6477 "MachineIndependent/glslang_tab.cpp" break; case 122: /* parameter_declaration: type_qualifier parameter_type_specifier */ -#line 1124 "MachineIndependent/glslang.y" +#line 1125 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -6462,11 +6488,11 @@ yyreduce: parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6466 "MachineIndependent/glslang_tab.cpp" +#line 6492 "MachineIndependent/glslang_tab.cpp" break; case 123: /* parameter_declaration: parameter_type_specifier */ -#line 1134 "MachineIndependent/glslang.y" +#line 1135 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); @@ -6474,118 +6500,118 @@ yyreduce: parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMat()); } -#line 6478 "MachineIndependent/glslang_tab.cpp" +#line 6504 "MachineIndependent/glslang_tab.cpp" break; case 124: /* parameter_type_specifier: type_specifier */ -#line 1144 "MachineIndependent/glslang.y" +#line 1145 "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 6489 "MachineIndependent/glslang_tab.cpp" +#line 6515 "MachineIndependent/glslang_tab.cpp" break; case 125: /* init_declarator_list: single_declaration */ -#line 1153 "MachineIndependent/glslang.y" +#line 1154 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 6497 "MachineIndependent/glslang_tab.cpp" +#line 6523 "MachineIndependent/glslang_tab.cpp" break; case 126: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ -#line 1156 "MachineIndependent/glslang.y" +#line 1157 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 6506 "MachineIndependent/glslang_tab.cpp" +#line 6532 "MachineIndependent/glslang_tab.cpp" break; case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ -#line 1160 "MachineIndependent/glslang.y" +#line 1161 "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 6515 "MachineIndependent/glslang_tab.cpp" +#line 6541 "MachineIndependent/glslang_tab.cpp" break; case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ -#line 1164 "MachineIndependent/glslang.y" +#line 1165 "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 6525 "MachineIndependent/glslang_tab.cpp" +#line 6551 "MachineIndependent/glslang_tab.cpp" break; case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ -#line 1169 "MachineIndependent/glslang.y" +#line 1170 "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 6535 "MachineIndependent/glslang_tab.cpp" +#line 6561 "MachineIndependent/glslang_tab.cpp" break; case 130: /* single_declaration: fully_specified_type */ -#line 1177 "MachineIndependent/glslang.y" +#line 1178 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 6545 "MachineIndependent/glslang_tab.cpp" +#line 6571 "MachineIndependent/glslang_tab.cpp" break; case 131: /* single_declaration: fully_specified_type IDENTIFIER */ -#line 1182 "MachineIndependent/glslang.y" +#line 1183 "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 6555 "MachineIndependent/glslang_tab.cpp" +#line 6581 "MachineIndependent/glslang_tab.cpp" break; case 132: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ -#line 1187 "MachineIndependent/glslang.y" +#line 1188 "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 6565 "MachineIndependent/glslang_tab.cpp" +#line 6591 "MachineIndependent/glslang_tab.cpp" break; case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ -#line 1192 "MachineIndependent/glslang.y" +#line 1193 "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 6575 "MachineIndependent/glslang_tab.cpp" +#line 6601 "MachineIndependent/glslang_tab.cpp" break; case 134: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 1197 "MachineIndependent/glslang.y" +#line 1198 "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 6585 "MachineIndependent/glslang_tab.cpp" +#line 6611 "MachineIndependent/glslang_tab.cpp" break; case 135: /* fully_specified_type: type_specifier */ -#line 1206 "MachineIndependent/glslang.y" +#line 1207 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6596,11 +6622,11 @@ yyreduce: } parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).isCoopmat()); } -#line 6600 "MachineIndependent/glslang_tab.cpp" +#line 6626 "MachineIndependent/glslang_tab.cpp" break; case 136: /* fully_specified_type: type_qualifier type_specifier */ -#line 1216 "MachineIndependent/glslang.y" +#line 1217 "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)); @@ -6625,22 +6651,22 @@ yyreduce: (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 6629 "MachineIndependent/glslang_tab.cpp" +#line 6655 "MachineIndependent/glslang_tab.cpp" break; case 137: /* invariant_qualifier: INVARIANT */ -#line 1243 "MachineIndependent/glslang.y" +#line 1244 "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 6640 "MachineIndependent/glslang_tab.cpp" +#line 6666 "MachineIndependent/glslang_tab.cpp" break; case 138: /* interpolation_qualifier: SMOOTH */ -#line 1252 "MachineIndependent/glslang.y" +#line 1253 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -6648,11 +6674,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 6652 "MachineIndependent/glslang_tab.cpp" +#line 6678 "MachineIndependent/glslang_tab.cpp" break; case 139: /* interpolation_qualifier: FLAT */ -#line 1259 "MachineIndependent/glslang.y" +#line 1260 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -6660,11 +6686,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 6664 "MachineIndependent/glslang_tab.cpp" +#line 6690 "MachineIndependent/glslang_tab.cpp" break; case 140: /* interpolation_qualifier: NOPERSPECTIVE */ -#line 1266 "MachineIndependent/glslang.y" +#line 1267 "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"); @@ -6672,11 +6698,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 6676 "MachineIndependent/glslang_tab.cpp" +#line 6702 "MachineIndependent/glslang_tab.cpp" break; case 141: /* interpolation_qualifier: EXPLICITINTERPAMD */ -#line 1273 "MachineIndependent/glslang.y" +#line 1274 "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"); @@ -6684,11 +6710,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.explicitInterp = true; } -#line 6688 "MachineIndependent/glslang_tab.cpp" +#line 6714 "MachineIndependent/glslang_tab.cpp" break; case 142: /* interpolation_qualifier: PERVERTEXNV */ -#line 1280 "MachineIndependent/glslang.y" +#line 1281 "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"); @@ -6697,11 +6723,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexNV = true; } -#line 6701 "MachineIndependent/glslang_tab.cpp" +#line 6727 "MachineIndependent/glslang_tab.cpp" break; case 143: /* interpolation_qualifier: PERVERTEXEXT */ -#line 1288 "MachineIndependent/glslang.y" +#line 1289 "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"); @@ -6710,11 +6736,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexEXT = true; } -#line 6714 "MachineIndependent/glslang_tab.cpp" +#line 6740 "MachineIndependent/glslang_tab.cpp" break; case 144: /* interpolation_qualifier: PERPRIMITIVENV */ -#line 1296 "MachineIndependent/glslang.y" +#line 1297 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); @@ -6725,11 +6751,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6729 "MachineIndependent/glslang_tab.cpp" +#line 6755 "MachineIndependent/glslang_tab.cpp" break; case 145: /* interpolation_qualifier: PERPRIMITIVEEXT */ -#line 1306 "MachineIndependent/glslang.y" +#line 1307 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveEXT"); @@ -6740,11 +6766,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6744 "MachineIndependent/glslang_tab.cpp" +#line 6770 "MachineIndependent/glslang_tab.cpp" break; case 146: /* interpolation_qualifier: PERVIEWNV */ -#line 1316 "MachineIndependent/glslang.y" +#line 1317 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); @@ -6752,11 +6778,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perViewNV = true; } -#line 6756 "MachineIndependent/glslang_tab.cpp" +#line 6782 "MachineIndependent/glslang_tab.cpp" break; case 147: /* interpolation_qualifier: PERTASKNV */ -#line 1323 "MachineIndependent/glslang.y" +#line 1324 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); @@ -6764,84 +6790,84 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perTaskNV = true; } -#line 6768 "MachineIndependent/glslang_tab.cpp" +#line 6794 "MachineIndependent/glslang_tab.cpp" break; case 148: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ -#line 1333 "MachineIndependent/glslang.y" +#line 1334 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 6776 "MachineIndependent/glslang_tab.cpp" +#line 6802 "MachineIndependent/glslang_tab.cpp" break; case 149: /* layout_qualifier_id_list: layout_qualifier_id */ -#line 1339 "MachineIndependent/glslang.y" +#line 1340 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6784 "MachineIndependent/glslang_tab.cpp" +#line 6810 "MachineIndependent/glslang_tab.cpp" break; case 150: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ -#line 1342 "MachineIndependent/glslang.y" +#line 1343 "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 6794 "MachineIndependent/glslang_tab.cpp" +#line 6820 "MachineIndependent/glslang_tab.cpp" break; case 151: /* layout_qualifier_id: IDENTIFIER */ -#line 1349 "MachineIndependent/glslang.y" +#line 1350 "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 6803 "MachineIndependent/glslang_tab.cpp" +#line 6829 "MachineIndependent/glslang_tab.cpp" break; case 152: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ -#line 1353 "MachineIndependent/glslang.y" +#line 1354 "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 6812 "MachineIndependent/glslang_tab.cpp" +#line 6838 "MachineIndependent/glslang_tab.cpp" break; case 153: /* layout_qualifier_id: SHARED */ -#line 1357 "MachineIndependent/glslang.y" +#line 1358 "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 6822 "MachineIndependent/glslang_tab.cpp" +#line 6848 "MachineIndependent/glslang_tab.cpp" break; case 154: /* precise_qualifier: PRECISE */ -#line 1365 "MachineIndependent/glslang.y" +#line 1366 "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 6833 "MachineIndependent/glslang_tab.cpp" +#line 6859 "MachineIndependent/glslang_tab.cpp" break; case 155: /* type_qualifier: single_type_qualifier */ -#line 1374 "MachineIndependent/glslang.y" +#line 1375 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6841 "MachineIndependent/glslang_tab.cpp" +#line 6867 "MachineIndependent/glslang_tab.cpp" break; case 156: /* type_qualifier: type_qualifier single_type_qualifier */ -#line 1377 "MachineIndependent/glslang.y" +#line 1378 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -6850,151 +6876,151 @@ yyreduce: (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 6854 "MachineIndependent/glslang_tab.cpp" +#line 6880 "MachineIndependent/glslang_tab.cpp" break; case 157: /* single_type_qualifier: storage_qualifier */ -#line 1388 "MachineIndependent/glslang.y" +#line 1389 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6862 "MachineIndependent/glslang_tab.cpp" - break; - - case 158: /* single_type_qualifier: layout_qualifier */ -#line 1391 "MachineIndependent/glslang.y" - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 6870 "MachineIndependent/glslang_tab.cpp" - break; - - case 159: /* single_type_qualifier: precision_qualifier */ -#line 1394 "MachineIndependent/glslang.y" - { - parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); - (yyval.interm.type) = (yyvsp[0].interm.type); - } -#line 6879 "MachineIndependent/glslang_tab.cpp" - break; - - case 160: /* single_type_qualifier: interpolation_qualifier */ -#line 1398 "MachineIndependent/glslang.y" - { - // allow inheritance of storage qualifier from block declaration - (yyval.interm.type) = (yyvsp[0].interm.type); - } #line 6888 "MachineIndependent/glslang_tab.cpp" break; - case 161: /* single_type_qualifier: invariant_qualifier */ -#line 1402 "MachineIndependent/glslang.y" + case 158: /* single_type_qualifier: layout_qualifier */ +#line 1392 "MachineIndependent/glslang.y" + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 6896 "MachineIndependent/glslang_tab.cpp" + break; + + case 159: /* single_type_qualifier: precision_qualifier */ +#line 1395 "MachineIndependent/glslang.y" { - // allow inheritance of storage qualifier from block declaration + parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6897 "MachineIndependent/glslang_tab.cpp" +#line 6905 "MachineIndependent/glslang_tab.cpp" break; - case 162: /* single_type_qualifier: precise_qualifier */ -#line 1406 "MachineIndependent/glslang.y" - { + case 160: /* single_type_qualifier: interpolation_qualifier */ +#line 1399 "MachineIndependent/glslang.y" + { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6906 "MachineIndependent/glslang_tab.cpp" - break; - - case 163: /* single_type_qualifier: non_uniform_qualifier */ -#line 1410 "MachineIndependent/glslang.y" - { - (yyval.interm.type) = (yyvsp[0].interm.type); - } #line 6914 "MachineIndependent/glslang_tab.cpp" break; + case 161: /* single_type_qualifier: invariant_qualifier */ +#line 1403 "MachineIndependent/glslang.y" + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 6923 "MachineIndependent/glslang_tab.cpp" + break; + + case 162: /* single_type_qualifier: precise_qualifier */ +#line 1407 "MachineIndependent/glslang.y" + { + // allow inheritance of storage qualifier from block declaration + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 6932 "MachineIndependent/glslang_tab.cpp" + break; + + case 163: /* single_type_qualifier: non_uniform_qualifier */ +#line 1411 "MachineIndependent/glslang.y" + { + (yyval.interm.type) = (yyvsp[0].interm.type); + } +#line 6940 "MachineIndependent/glslang_tab.cpp" + break; + case 164: /* single_type_qualifier: spirv_storage_class_qualifier */ -#line 1413 "MachineIndependent/glslang.y" +#line 1414 "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 6924 "MachineIndependent/glslang_tab.cpp" +#line 6950 "MachineIndependent/glslang_tab.cpp" break; case 165: /* single_type_qualifier: spirv_decorate_qualifier */ -#line 1418 "MachineIndependent/glslang.y" +#line 1419 "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 6933 "MachineIndependent/glslang_tab.cpp" +#line 6959 "MachineIndependent/glslang_tab.cpp" break; case 166: /* single_type_qualifier: SPIRV_BY_REFERENCE */ -#line 1422 "MachineIndependent/glslang.y" +#line 1423 "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 6943 "MachineIndependent/glslang_tab.cpp" +#line 6969 "MachineIndependent/glslang_tab.cpp" break; case 167: /* single_type_qualifier: SPIRV_LITERAL */ -#line 1427 "MachineIndependent/glslang.y" +#line 1428 "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 6953 "MachineIndependent/glslang_tab.cpp" +#line 6979 "MachineIndependent/glslang_tab.cpp" break; case 168: /* storage_qualifier: CONST */ -#line 1435 "MachineIndependent/glslang.y" +#line 1436 "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 6962 "MachineIndependent/glslang_tab.cpp" +#line 6988 "MachineIndependent/glslang_tab.cpp" break; case 169: /* storage_qualifier: INOUT */ -#line 1439 "MachineIndependent/glslang.y" +#line 1440 "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 6972 "MachineIndependent/glslang_tab.cpp" +#line 6998 "MachineIndependent/glslang_tab.cpp" break; case 170: /* storage_qualifier: IN */ -#line 1444 "MachineIndependent/glslang.y" +#line 1445 "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 6983 "MachineIndependent/glslang_tab.cpp" +#line 7009 "MachineIndependent/glslang_tab.cpp" break; case 171: /* storage_qualifier: OUT */ -#line 1450 "MachineIndependent/glslang.y" +#line 1451 "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 6994 "MachineIndependent/glslang_tab.cpp" +#line 7020 "MachineIndependent/glslang_tab.cpp" break; case 172: /* storage_qualifier: CENTROID */ -#line 1456 "MachineIndependent/glslang.y" +#line 1457 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -7002,31 +7028,31 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 7006 "MachineIndependent/glslang_tab.cpp" +#line 7032 "MachineIndependent/glslang_tab.cpp" break; case 173: /* storage_qualifier: UNIFORM */ -#line 1463 "MachineIndependent/glslang.y" +#line 1464 "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 7016 "MachineIndependent/glslang_tab.cpp" +#line 7042 "MachineIndependent/glslang_tab.cpp" break; case 174: /* storage_qualifier: TILEIMAGEEXT */ -#line 1468 "MachineIndependent/glslang.y" +#line 1469 "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 7026 "MachineIndependent/glslang_tab.cpp" +#line 7052 "MachineIndependent/glslang_tab.cpp" break; case 175: /* storage_qualifier: SHARED */ -#line 1473 "MachineIndependent/glslang.y" +#line 1474 "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"); @@ -7035,21 +7061,21 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 7039 "MachineIndependent/glslang_tab.cpp" +#line 7065 "MachineIndependent/glslang_tab.cpp" break; case 176: /* storage_qualifier: BUFFER */ -#line 1481 "MachineIndependent/glslang.y" +#line 1482 "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 7049 "MachineIndependent/glslang_tab.cpp" +#line 7075 "MachineIndependent/glslang_tab.cpp" break; case 177: /* storage_qualifier: ATTRIBUTE */ -#line 1486 "MachineIndependent/glslang.y" +#line 1487 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -7062,11 +7088,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7066 "MachineIndependent/glslang_tab.cpp" +#line 7092 "MachineIndependent/glslang_tab.cpp" break; case 178: /* storage_qualifier: VARYING */ -#line 1498 "MachineIndependent/glslang.y" +#line 1499 "MachineIndependent/glslang.y" { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -7081,32 +7107,32 @@ yyreduce: else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7085 "MachineIndependent/glslang_tab.cpp" +#line 7111 "MachineIndependent/glslang_tab.cpp" break; case 179: /* storage_qualifier: PATCH */ -#line 1512 "MachineIndependent/glslang.y" +#line 1513 "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 7096 "MachineIndependent/glslang_tab.cpp" +#line 7122 "MachineIndependent/glslang_tab.cpp" break; case 180: /* storage_qualifier: SAMPLE */ -#line 1518 "MachineIndependent/glslang.y" +#line 1519 "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 7106 "MachineIndependent/glslang_tab.cpp" +#line 7132 "MachineIndependent/glslang_tab.cpp" break; case 181: /* storage_qualifier: HITATTRNV */ -#line 1523 "MachineIndependent/glslang.y" +#line 1524 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7115,11 +7141,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7119 "MachineIndependent/glslang_tab.cpp" +#line 7145 "MachineIndependent/glslang_tab.cpp" break; case 182: /* storage_qualifier: HITOBJECTATTRNV */ -#line 1531 "MachineIndependent/glslang.y" +#line 1532 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask @@ -7128,11 +7154,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitObjectAttrNV; } -#line 7132 "MachineIndependent/glslang_tab.cpp" +#line 7158 "MachineIndependent/glslang_tab.cpp" break; case 183: /* storage_qualifier: HITATTREXT */ -#line 1539 "MachineIndependent/glslang.y" +#line 1540 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7141,11 +7167,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7145 "MachineIndependent/glslang_tab.cpp" +#line 7171 "MachineIndependent/glslang_tab.cpp" break; case 184: /* storage_qualifier: PAYLOADNV */ -#line 1547 "MachineIndependent/glslang.y" +#line 1548 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7154,11 +7180,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7158 "MachineIndependent/glslang_tab.cpp" +#line 7184 "MachineIndependent/glslang_tab.cpp" break; case 185: /* storage_qualifier: PAYLOADEXT */ -#line 1555 "MachineIndependent/glslang.y" +#line 1556 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7167,11 +7193,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7171 "MachineIndependent/glslang_tab.cpp" +#line 7197 "MachineIndependent/glslang_tab.cpp" break; case 186: /* storage_qualifier: PAYLOADINNV */ -#line 1563 "MachineIndependent/glslang.y" +#line 1564 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7180,11 +7206,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7184 "MachineIndependent/glslang_tab.cpp" +#line 7210 "MachineIndependent/glslang_tab.cpp" break; case 187: /* storage_qualifier: PAYLOADINEXT */ -#line 1571 "MachineIndependent/glslang.y" +#line 1572 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7193,11 +7219,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7197 "MachineIndependent/glslang_tab.cpp" +#line 7223 "MachineIndependent/glslang_tab.cpp" break; case 188: /* storage_qualifier: CALLDATANV */ -#line 1579 "MachineIndependent/glslang.y" +#line 1580 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7206,11 +7232,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7210 "MachineIndependent/glslang_tab.cpp" +#line 7236 "MachineIndependent/glslang_tab.cpp" break; case 189: /* storage_qualifier: CALLDATAEXT */ -#line 1587 "MachineIndependent/glslang.y" +#line 1588 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7219,11 +7245,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7223 "MachineIndependent/glslang_tab.cpp" +#line 7249 "MachineIndependent/glslang_tab.cpp" break; case 190: /* storage_qualifier: CALLDATAINNV */ -#line 1595 "MachineIndependent/glslang.y" +#line 1596 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV"); @@ -7231,11 +7257,11 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7235 "MachineIndependent/glslang_tab.cpp" +#line 7261 "MachineIndependent/glslang_tab.cpp" break; case 191: /* storage_qualifier: CALLDATAINEXT */ -#line 1602 "MachineIndependent/glslang.y" +#line 1603 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT"); @@ -7243,138 +7269,138 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7247 "MachineIndependent/glslang_tab.cpp" +#line 7273 "MachineIndependent/glslang_tab.cpp" break; case 192: /* storage_qualifier: COHERENT */ -#line 1609 "MachineIndependent/glslang.y" +#line 1610 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 7256 "MachineIndependent/glslang_tab.cpp" +#line 7282 "MachineIndependent/glslang_tab.cpp" break; case 193: /* storage_qualifier: DEVICECOHERENT */ -#line 1613 "MachineIndependent/glslang.y" +#line 1614 "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 7266 "MachineIndependent/glslang_tab.cpp" +#line 7292 "MachineIndependent/glslang_tab.cpp" break; case 194: /* storage_qualifier: QUEUEFAMILYCOHERENT */ -#line 1618 "MachineIndependent/glslang.y" +#line 1619 "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 7276 "MachineIndependent/glslang_tab.cpp" +#line 7302 "MachineIndependent/glslang_tab.cpp" break; case 195: /* storage_qualifier: WORKGROUPCOHERENT */ -#line 1623 "MachineIndependent/glslang.y" +#line 1624 "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 7286 "MachineIndependent/glslang_tab.cpp" +#line 7312 "MachineIndependent/glslang_tab.cpp" break; case 196: /* storage_qualifier: SUBGROUPCOHERENT */ -#line 1628 "MachineIndependent/glslang.y" +#line 1629 "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 7296 "MachineIndependent/glslang_tab.cpp" +#line 7322 "MachineIndependent/glslang_tab.cpp" break; case 197: /* storage_qualifier: NONPRIVATE */ -#line 1633 "MachineIndependent/glslang.y" +#line 1634 "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 7306 "MachineIndependent/glslang_tab.cpp" +#line 7332 "MachineIndependent/glslang_tab.cpp" break; case 198: /* storage_qualifier: SHADERCALLCOHERENT */ -#line 1638 "MachineIndependent/glslang.y" +#line 1639 "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 7316 "MachineIndependent/glslang_tab.cpp" +#line 7342 "MachineIndependent/glslang_tab.cpp" break; case 199: /* storage_qualifier: VOLATILE */ -#line 1643 "MachineIndependent/glslang.y" +#line 1644 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 7325 "MachineIndependent/glslang_tab.cpp" +#line 7351 "MachineIndependent/glslang_tab.cpp" break; case 200: /* storage_qualifier: RESTRICT */ -#line 1647 "MachineIndependent/glslang.y" +#line 1648 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 7334 "MachineIndependent/glslang_tab.cpp" +#line 7360 "MachineIndependent/glslang_tab.cpp" break; case 201: /* storage_qualifier: READONLY */ -#line 1651 "MachineIndependent/glslang.y" +#line 1652 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 7343 "MachineIndependent/glslang_tab.cpp" +#line 7369 "MachineIndependent/glslang_tab.cpp" break; case 202: /* storage_qualifier: WRITEONLY */ -#line 1655 "MachineIndependent/glslang.y" +#line 1656 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 7352 "MachineIndependent/glslang_tab.cpp" +#line 7378 "MachineIndependent/glslang_tab.cpp" break; case 203: /* storage_qualifier: SUBROUTINE */ -#line 1659 "MachineIndependent/glslang.y" +#line 1660 "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 7363 "MachineIndependent/glslang_tab.cpp" +#line 7389 "MachineIndependent/glslang_tab.cpp" break; case 204: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ -#line 1665 "MachineIndependent/glslang.y" +#line 1666 "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 7374 "MachineIndependent/glslang_tab.cpp" +#line 7400 "MachineIndependent/glslang_tab.cpp" break; case 205: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ -#line 1671 "MachineIndependent/glslang.y" +#line 1672 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskPayloadSharedEXT"); @@ -7382,38 +7408,38 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqtaskPayloadSharedEXT; } -#line 7386 "MachineIndependent/glslang_tab.cpp" +#line 7412 "MachineIndependent/glslang_tab.cpp" break; case 206: /* non_uniform_qualifier: NONUNIFORM */ -#line 1681 "MachineIndependent/glslang.y" +#line 1682 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 7395 "MachineIndependent/glslang_tab.cpp" +#line 7421 "MachineIndependent/glslang_tab.cpp" break; case 207: /* type_name_list: IDENTIFIER */ -#line 1688 "MachineIndependent/glslang.y" +#line 1689 "MachineIndependent/glslang.y" { // TODO } -#line 7403 "MachineIndependent/glslang_tab.cpp" +#line 7429 "MachineIndependent/glslang_tab.cpp" break; case 208: /* type_name_list: type_name_list COMMA IDENTIFIER */ -#line 1691 "MachineIndependent/glslang.y" +#line 1692 "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 7413 "MachineIndependent/glslang_tab.cpp" +#line 7439 "MachineIndependent/glslang_tab.cpp" break; case 209: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ -#line 1699 "MachineIndependent/glslang.y" +#line 1700 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); @@ -7421,11 +7447,11 @@ yyreduce: parseContext.coopMatTypeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type)); } -#line 7425 "MachineIndependent/glslang_tab.cpp" +#line 7451 "MachineIndependent/glslang_tab.cpp" break; case 210: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ -#line 1706 "MachineIndependent/glslang.y" +#line 1707 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-2].interm.type); @@ -7434,21 +7460,21 @@ yyreduce: (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; parseContext.coopMatTypeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type)); } -#line 7438 "MachineIndependent/glslang_tab.cpp" +#line 7464 "MachineIndependent/glslang_tab.cpp" break; case 211: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ -#line 1717 "MachineIndependent/glslang.y" +#line 1718 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 7448 "MachineIndependent/glslang_tab.cpp" +#line 7474 "MachineIndependent/glslang_tab.cpp" break; case 212: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1722 "MachineIndependent/glslang.y" +#line 1723 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -7457,20 +7483,20 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7461 "MachineIndependent/glslang_tab.cpp" +#line 7487 "MachineIndependent/glslang_tab.cpp" break; case 213: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ -#line 1730 "MachineIndependent/glslang.y" +#line 1731 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 7470 "MachineIndependent/glslang_tab.cpp" +#line 7496 "MachineIndependent/glslang_tab.cpp" break; case 214: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1734 "MachineIndependent/glslang.y" +#line 1735 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); @@ -7478,46 +7504,46 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7482 "MachineIndependent/glslang_tab.cpp" +#line 7508 "MachineIndependent/glslang_tab.cpp" break; case 215: /* type_parameter_specifier_opt: type_parameter_specifier */ -#line 1744 "MachineIndependent/glslang.y" +#line 1745 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); } -#line 7490 "MachineIndependent/glslang_tab.cpp" +#line 7516 "MachineIndependent/glslang_tab.cpp" break; case 216: /* type_parameter_specifier_opt: %empty */ -#line 1747 "MachineIndependent/glslang.y" +#line 1748 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = 0; } -#line 7498 "MachineIndependent/glslang_tab.cpp" +#line 7524 "MachineIndependent/glslang_tab.cpp" break; case 217: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ -#line 1753 "MachineIndependent/glslang.y" +#line 1754 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); } -#line 7506 "MachineIndependent/glslang_tab.cpp" +#line 7532 "MachineIndependent/glslang_tab.cpp" break; case 218: /* type_parameter_specifier_list: type_specifier */ -#line 1759 "MachineIndependent/glslang.y" +#line 1760 "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 7517 "MachineIndependent/glslang_tab.cpp" +#line 7543 "MachineIndependent/glslang_tab.cpp" break; case 219: /* type_parameter_specifier_list: unary_expression */ -#line 1765 "MachineIndependent/glslang.y" +#line 1766 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; @@ -7526,11 +7552,11 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7530 "MachineIndependent/glslang_tab.cpp" +#line 7556 "MachineIndependent/glslang_tab.cpp" break; case 220: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ -#line 1773 "MachineIndependent/glslang.y" +#line 1774 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); @@ -7538,300 +7564,300 @@ yyreduce: parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7542 "MachineIndependent/glslang_tab.cpp" +#line 7568 "MachineIndependent/glslang_tab.cpp" break; case 221: /* type_specifier_nonarray: VOID */ -#line 1783 "MachineIndependent/glslang.y" +#line 1784 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 7551 "MachineIndependent/glslang_tab.cpp" +#line 7577 "MachineIndependent/glslang_tab.cpp" break; case 222: /* type_specifier_nonarray: FLOAT */ -#line 1787 "MachineIndependent/glslang.y" +#line 1788 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7560 "MachineIndependent/glslang_tab.cpp" +#line 7586 "MachineIndependent/glslang_tab.cpp" break; case 223: /* type_specifier_nonarray: INT */ -#line 1791 "MachineIndependent/glslang.y" +#line 1792 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 7569 "MachineIndependent/glslang_tab.cpp" +#line 7595 "MachineIndependent/glslang_tab.cpp" break; case 224: /* type_specifier_nonarray: UINT */ -#line 1795 "MachineIndependent/glslang.y" +#line 1796 "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 7579 "MachineIndependent/glslang_tab.cpp" +#line 7605 "MachineIndependent/glslang_tab.cpp" break; case 225: /* type_specifier_nonarray: BOOL */ -#line 1800 "MachineIndependent/glslang.y" +#line 1801 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; } -#line 7588 "MachineIndependent/glslang_tab.cpp" +#line 7614 "MachineIndependent/glslang_tab.cpp" break; case 226: /* type_specifier_nonarray: VEC2 */ -#line 1804 "MachineIndependent/glslang.y" +#line 1805 "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 7598 "MachineIndependent/glslang_tab.cpp" +#line 7624 "MachineIndependent/glslang_tab.cpp" break; case 227: /* type_specifier_nonarray: VEC3 */ -#line 1809 "MachineIndependent/glslang.y" +#line 1810 "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 7608 "MachineIndependent/glslang_tab.cpp" +#line 7634 "MachineIndependent/glslang_tab.cpp" break; case 228: /* type_specifier_nonarray: VEC4 */ -#line 1814 "MachineIndependent/glslang.y" +#line 1815 "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 7618 "MachineIndependent/glslang_tab.cpp" +#line 7644 "MachineIndependent/glslang_tab.cpp" break; case 229: /* type_specifier_nonarray: BVEC2 */ -#line 1819 "MachineIndependent/glslang.y" +#line 1820 "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 7628 "MachineIndependent/glslang_tab.cpp" +#line 7654 "MachineIndependent/glslang_tab.cpp" break; case 230: /* type_specifier_nonarray: BVEC3 */ -#line 1824 "MachineIndependent/glslang.y" +#line 1825 "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 7638 "MachineIndependent/glslang_tab.cpp" +#line 7664 "MachineIndependent/glslang_tab.cpp" break; case 231: /* type_specifier_nonarray: BVEC4 */ -#line 1829 "MachineIndependent/glslang.y" +#line 1830 "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 7648 "MachineIndependent/glslang_tab.cpp" +#line 7674 "MachineIndependent/glslang_tab.cpp" break; case 232: /* type_specifier_nonarray: IVEC2 */ -#line 1834 "MachineIndependent/glslang.y" +#line 1835 "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 7658 "MachineIndependent/glslang_tab.cpp" +#line 7684 "MachineIndependent/glslang_tab.cpp" break; case 233: /* type_specifier_nonarray: IVEC3 */ -#line 1839 "MachineIndependent/glslang.y" +#line 1840 "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 7668 "MachineIndependent/glslang_tab.cpp" +#line 7694 "MachineIndependent/glslang_tab.cpp" break; case 234: /* type_specifier_nonarray: IVEC4 */ -#line 1844 "MachineIndependent/glslang.y" +#line 1845 "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 7678 "MachineIndependent/glslang_tab.cpp" +#line 7704 "MachineIndependent/glslang_tab.cpp" break; case 235: /* type_specifier_nonarray: UVEC2 */ -#line 1849 "MachineIndependent/glslang.y" +#line 1850 "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 7689 "MachineIndependent/glslang_tab.cpp" +#line 7715 "MachineIndependent/glslang_tab.cpp" break; case 236: /* type_specifier_nonarray: UVEC3 */ -#line 1855 "MachineIndependent/glslang.y" +#line 1856 "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 7700 "MachineIndependent/glslang_tab.cpp" +#line 7726 "MachineIndependent/glslang_tab.cpp" break; case 237: /* type_specifier_nonarray: UVEC4 */ -#line 1861 "MachineIndependent/glslang.y" +#line 1862 "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 7711 "MachineIndependent/glslang_tab.cpp" +#line 7737 "MachineIndependent/glslang_tab.cpp" break; case 238: /* type_specifier_nonarray: MAT2 */ -#line 1867 "MachineIndependent/glslang.y" +#line 1868 "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 7721 "MachineIndependent/glslang_tab.cpp" +#line 7747 "MachineIndependent/glslang_tab.cpp" break; case 239: /* type_specifier_nonarray: MAT3 */ -#line 1872 "MachineIndependent/glslang.y" +#line 1873 "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 7731 "MachineIndependent/glslang_tab.cpp" +#line 7757 "MachineIndependent/glslang_tab.cpp" break; case 240: /* type_specifier_nonarray: MAT4 */ -#line 1877 "MachineIndependent/glslang.y" +#line 1878 "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 7741 "MachineIndependent/glslang_tab.cpp" +#line 7767 "MachineIndependent/glslang_tab.cpp" break; case 241: /* type_specifier_nonarray: MAT2X2 */ -#line 1882 "MachineIndependent/glslang.y" +#line 1883 "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 7751 "MachineIndependent/glslang_tab.cpp" +#line 7777 "MachineIndependent/glslang_tab.cpp" break; case 242: /* type_specifier_nonarray: MAT2X3 */ -#line 1887 "MachineIndependent/glslang.y" +#line 1888 "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 7761 "MachineIndependent/glslang_tab.cpp" +#line 7787 "MachineIndependent/glslang_tab.cpp" break; case 243: /* type_specifier_nonarray: MAT2X4 */ -#line 1892 "MachineIndependent/glslang.y" +#line 1893 "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 7771 "MachineIndependent/glslang_tab.cpp" +#line 7797 "MachineIndependent/glslang_tab.cpp" break; case 244: /* type_specifier_nonarray: MAT3X2 */ -#line 1897 "MachineIndependent/glslang.y" +#line 1898 "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 7781 "MachineIndependent/glslang_tab.cpp" +#line 7807 "MachineIndependent/glslang_tab.cpp" break; case 245: /* type_specifier_nonarray: MAT3X3 */ -#line 1902 "MachineIndependent/glslang.y" +#line 1903 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7791 "MachineIndependent/glslang_tab.cpp" +#line 7817 "MachineIndependent/glslang_tab.cpp" break; case 246: /* type_specifier_nonarray: MAT3X4 */ -#line 1907 "MachineIndependent/glslang.y" +#line 1908 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 7801 "MachineIndependent/glslang_tab.cpp" +#line 7827 "MachineIndependent/glslang_tab.cpp" break; case 247: /* type_specifier_nonarray: MAT4X2 */ -#line 1912 "MachineIndependent/glslang.y" +#line 1913 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 7811 "MachineIndependent/glslang_tab.cpp" +#line 7837 "MachineIndependent/glslang_tab.cpp" break; case 248: /* type_specifier_nonarray: MAT4X3 */ -#line 1917 "MachineIndependent/glslang.y" +#line 1918 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 7821 "MachineIndependent/glslang_tab.cpp" +#line 7847 "MachineIndependent/glslang_tab.cpp" break; case 249: /* type_specifier_nonarray: MAT4X4 */ -#line 1922 "MachineIndependent/glslang.y" +#line 1923 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7831 "MachineIndependent/glslang_tab.cpp" +#line 7857 "MachineIndependent/glslang_tab.cpp" break; case 250: /* type_specifier_nonarray: DOUBLE */ -#line 1927 "MachineIndependent/glslang.y" +#line 1928 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7839,121 +7865,121 @@ yyreduce: (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 7843 "MachineIndependent/glslang_tab.cpp" +#line 7869 "MachineIndependent/glslang_tab.cpp" break; case 251: /* type_specifier_nonarray: FLOAT16_T */ -#line 1934 "MachineIndependent/glslang.y" +#line 1935 "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 7853 "MachineIndependent/glslang_tab.cpp" +#line 7879 "MachineIndependent/glslang_tab.cpp" break; case 252: /* type_specifier_nonarray: FLOAT32_T */ -#line 1939 "MachineIndependent/glslang.y" +#line 1940 "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 7863 "MachineIndependent/glslang_tab.cpp" +#line 7889 "MachineIndependent/glslang_tab.cpp" break; case 253: /* type_specifier_nonarray: FLOAT64_T */ -#line 1944 "MachineIndependent/glslang.y" +#line 1945 "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 7873 "MachineIndependent/glslang_tab.cpp" +#line 7899 "MachineIndependent/glslang_tab.cpp" break; case 254: /* type_specifier_nonarray: INT8_T */ -#line 1949 "MachineIndependent/glslang.y" +#line 1950 "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 7883 "MachineIndependent/glslang_tab.cpp" +#line 7909 "MachineIndependent/glslang_tab.cpp" break; case 255: /* type_specifier_nonarray: UINT8_T */ -#line 1954 "MachineIndependent/glslang.y" +#line 1955 "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 7893 "MachineIndependent/glslang_tab.cpp" +#line 7919 "MachineIndependent/glslang_tab.cpp" break; case 256: /* type_specifier_nonarray: INT16_T */ -#line 1959 "MachineIndependent/glslang.y" +#line 1960 "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 7903 "MachineIndependent/glslang_tab.cpp" +#line 7929 "MachineIndependent/glslang_tab.cpp" break; case 257: /* type_specifier_nonarray: UINT16_T */ -#line 1964 "MachineIndependent/glslang.y" +#line 1965 "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 7913 "MachineIndependent/glslang_tab.cpp" +#line 7939 "MachineIndependent/glslang_tab.cpp" break; case 258: /* type_specifier_nonarray: INT32_T */ -#line 1969 "MachineIndependent/glslang.y" +#line 1970 "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 7923 "MachineIndependent/glslang_tab.cpp" +#line 7949 "MachineIndependent/glslang_tab.cpp" break; case 259: /* type_specifier_nonarray: UINT32_T */ -#line 1974 "MachineIndependent/glslang.y" +#line 1975 "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 7933 "MachineIndependent/glslang_tab.cpp" +#line 7959 "MachineIndependent/glslang_tab.cpp" break; case 260: /* type_specifier_nonarray: INT64_T */ -#line 1979 "MachineIndependent/glslang.y" +#line 1980 "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 7943 "MachineIndependent/glslang_tab.cpp" +#line 7969 "MachineIndependent/glslang_tab.cpp" break; case 261: /* type_specifier_nonarray: UINT64_T */ -#line 1984 "MachineIndependent/glslang.y" +#line 1985 "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 7953 "MachineIndependent/glslang_tab.cpp" +#line 7979 "MachineIndependent/glslang_tab.cpp" break; case 262: /* type_specifier_nonarray: DVEC2 */ -#line 1989 "MachineIndependent/glslang.y" +#line 1990 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7962,426 +7988,426 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 7966 "MachineIndependent/glslang_tab.cpp" - break; - - case 263: /* type_specifier_nonarray: DVEC3 */ -#line 1997 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(3); - } -#line 7979 "MachineIndependent/glslang_tab.cpp" - break; - - case 264: /* type_specifier_nonarray: DVEC4 */ -#line 2005 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setVector(4); - } #line 7992 "MachineIndependent/glslang_tab.cpp" break; + case 263: /* type_specifier_nonarray: DVEC3 */ +#line 1998 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(3); + } +#line 8005 "MachineIndependent/glslang_tab.cpp" + break; + + case 264: /* type_specifier_nonarray: DVEC4 */ +#line 2006 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setVector(4); + } +#line 8018 "MachineIndependent/glslang_tab.cpp" + break; + case 265: /* type_specifier_nonarray: F16VEC2 */ -#line 2013 "MachineIndependent/glslang.y" +#line 2014 "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 8003 "MachineIndependent/glslang_tab.cpp" +#line 8029 "MachineIndependent/glslang_tab.cpp" break; case 266: /* type_specifier_nonarray: F16VEC3 */ -#line 2019 "MachineIndependent/glslang.y" +#line 2020 "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 8014 "MachineIndependent/glslang_tab.cpp" +#line 8040 "MachineIndependent/glslang_tab.cpp" break; case 267: /* type_specifier_nonarray: F16VEC4 */ -#line 2025 "MachineIndependent/glslang.y" +#line 2026 "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 8025 "MachineIndependent/glslang_tab.cpp" +#line 8051 "MachineIndependent/glslang_tab.cpp" break; case 268: /* type_specifier_nonarray: F32VEC2 */ -#line 2031 "MachineIndependent/glslang.y" +#line 2032 "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 8036 "MachineIndependent/glslang_tab.cpp" +#line 8062 "MachineIndependent/glslang_tab.cpp" break; case 269: /* type_specifier_nonarray: F32VEC3 */ -#line 2037 "MachineIndependent/glslang.y" +#line 2038 "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 8047 "MachineIndependent/glslang_tab.cpp" +#line 8073 "MachineIndependent/glslang_tab.cpp" break; case 270: /* type_specifier_nonarray: F32VEC4 */ -#line 2043 "MachineIndependent/glslang.y" +#line 2044 "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 8058 "MachineIndependent/glslang_tab.cpp" +#line 8084 "MachineIndependent/glslang_tab.cpp" break; case 271: /* type_specifier_nonarray: F64VEC2 */ -#line 2049 "MachineIndependent/glslang.y" +#line 2050 "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 8069 "MachineIndependent/glslang_tab.cpp" +#line 8095 "MachineIndependent/glslang_tab.cpp" break; case 272: /* type_specifier_nonarray: F64VEC3 */ -#line 2055 "MachineIndependent/glslang.y" +#line 2056 "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 8080 "MachineIndependent/glslang_tab.cpp" +#line 8106 "MachineIndependent/glslang_tab.cpp" break; case 273: /* type_specifier_nonarray: F64VEC4 */ -#line 2061 "MachineIndependent/glslang.y" +#line 2062 "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 8091 "MachineIndependent/glslang_tab.cpp" +#line 8117 "MachineIndependent/glslang_tab.cpp" break; case 274: /* type_specifier_nonarray: I8VEC2 */ -#line 2067 "MachineIndependent/glslang.y" +#line 2068 "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 8102 "MachineIndependent/glslang_tab.cpp" +#line 8128 "MachineIndependent/glslang_tab.cpp" break; case 275: /* type_specifier_nonarray: I8VEC3 */ -#line 2073 "MachineIndependent/glslang.y" +#line 2074 "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 8113 "MachineIndependent/glslang_tab.cpp" +#line 8139 "MachineIndependent/glslang_tab.cpp" break; case 276: /* type_specifier_nonarray: I8VEC4 */ -#line 2079 "MachineIndependent/glslang.y" +#line 2080 "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 8124 "MachineIndependent/glslang_tab.cpp" +#line 8150 "MachineIndependent/glslang_tab.cpp" break; case 277: /* type_specifier_nonarray: I16VEC2 */ -#line 2085 "MachineIndependent/glslang.y" +#line 2086 "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 8135 "MachineIndependent/glslang_tab.cpp" +#line 8161 "MachineIndependent/glslang_tab.cpp" break; case 278: /* type_specifier_nonarray: I16VEC3 */ -#line 2091 "MachineIndependent/glslang.y" +#line 2092 "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 8146 "MachineIndependent/glslang_tab.cpp" +#line 8172 "MachineIndependent/glslang_tab.cpp" break; case 279: /* type_specifier_nonarray: I16VEC4 */ -#line 2097 "MachineIndependent/glslang.y" +#line 2098 "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 8157 "MachineIndependent/glslang_tab.cpp" +#line 8183 "MachineIndependent/glslang_tab.cpp" break; case 280: /* type_specifier_nonarray: I32VEC2 */ -#line 2103 "MachineIndependent/glslang.y" +#line 2104 "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 8168 "MachineIndependent/glslang_tab.cpp" +#line 8194 "MachineIndependent/glslang_tab.cpp" break; case 281: /* type_specifier_nonarray: I32VEC3 */ -#line 2109 "MachineIndependent/glslang.y" +#line 2110 "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 8179 "MachineIndependent/glslang_tab.cpp" +#line 8205 "MachineIndependent/glslang_tab.cpp" break; case 282: /* type_specifier_nonarray: I32VEC4 */ -#line 2115 "MachineIndependent/glslang.y" +#line 2116 "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 8190 "MachineIndependent/glslang_tab.cpp" +#line 8216 "MachineIndependent/glslang_tab.cpp" break; case 283: /* type_specifier_nonarray: I64VEC2 */ -#line 2121 "MachineIndependent/glslang.y" +#line 2122 "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 8201 "MachineIndependent/glslang_tab.cpp" +#line 8227 "MachineIndependent/glslang_tab.cpp" break; case 284: /* type_specifier_nonarray: I64VEC3 */ -#line 2127 "MachineIndependent/glslang.y" +#line 2128 "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 8212 "MachineIndependent/glslang_tab.cpp" +#line 8238 "MachineIndependent/glslang_tab.cpp" break; case 285: /* type_specifier_nonarray: I64VEC4 */ -#line 2133 "MachineIndependent/glslang.y" +#line 2134 "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 8223 "MachineIndependent/glslang_tab.cpp" +#line 8249 "MachineIndependent/glslang_tab.cpp" break; case 286: /* type_specifier_nonarray: U8VEC2 */ -#line 2139 "MachineIndependent/glslang.y" +#line 2140 "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 8234 "MachineIndependent/glslang_tab.cpp" +#line 8260 "MachineIndependent/glslang_tab.cpp" break; case 287: /* type_specifier_nonarray: U8VEC3 */ -#line 2145 "MachineIndependent/glslang.y" +#line 2146 "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 8245 "MachineIndependent/glslang_tab.cpp" +#line 8271 "MachineIndependent/glslang_tab.cpp" break; case 288: /* type_specifier_nonarray: U8VEC4 */ -#line 2151 "MachineIndependent/glslang.y" +#line 2152 "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 8256 "MachineIndependent/glslang_tab.cpp" +#line 8282 "MachineIndependent/glslang_tab.cpp" break; case 289: /* type_specifier_nonarray: U16VEC2 */ -#line 2157 "MachineIndependent/glslang.y" +#line 2158 "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 8267 "MachineIndependent/glslang_tab.cpp" +#line 8293 "MachineIndependent/glslang_tab.cpp" break; case 290: /* type_specifier_nonarray: U16VEC3 */ -#line 2163 "MachineIndependent/glslang.y" +#line 2164 "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 8278 "MachineIndependent/glslang_tab.cpp" +#line 8304 "MachineIndependent/glslang_tab.cpp" break; case 291: /* type_specifier_nonarray: U16VEC4 */ -#line 2169 "MachineIndependent/glslang.y" +#line 2170 "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 8289 "MachineIndependent/glslang_tab.cpp" +#line 8315 "MachineIndependent/glslang_tab.cpp" break; case 292: /* type_specifier_nonarray: U32VEC2 */ -#line 2175 "MachineIndependent/glslang.y" +#line 2176 "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 8300 "MachineIndependent/glslang_tab.cpp" +#line 8326 "MachineIndependent/glslang_tab.cpp" break; case 293: /* type_specifier_nonarray: U32VEC3 */ -#line 2181 "MachineIndependent/glslang.y" +#line 2182 "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 8311 "MachineIndependent/glslang_tab.cpp" +#line 8337 "MachineIndependent/glslang_tab.cpp" break; case 294: /* type_specifier_nonarray: U32VEC4 */ -#line 2187 "MachineIndependent/glslang.y" +#line 2188 "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 8322 "MachineIndependent/glslang_tab.cpp" +#line 8348 "MachineIndependent/glslang_tab.cpp" break; case 295: /* type_specifier_nonarray: U64VEC2 */ -#line 2193 "MachineIndependent/glslang.y" +#line 2194 "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 8333 "MachineIndependent/glslang_tab.cpp" +#line 8359 "MachineIndependent/glslang_tab.cpp" break; case 296: /* type_specifier_nonarray: U64VEC3 */ -#line 2199 "MachineIndependent/glslang.y" +#line 2200 "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 8344 "MachineIndependent/glslang_tab.cpp" +#line 8370 "MachineIndependent/glslang_tab.cpp" break; case 297: /* type_specifier_nonarray: U64VEC4 */ -#line 2205 "MachineIndependent/glslang.y" +#line 2206 "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 8355 "MachineIndependent/glslang_tab.cpp" - break; - - case 298: /* type_specifier_nonarray: DMAT2 */ -#line 2211 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 2); - } -#line 8368 "MachineIndependent/glslang_tab.cpp" - break; - - case 299: /* type_specifier_nonarray: DMAT3 */ -#line 2219 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 3); - } #line 8381 "MachineIndependent/glslang_tab.cpp" break; + case 298: /* type_specifier_nonarray: DMAT2 */ +#line 2212 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(2, 2); + } +#line 8394 "MachineIndependent/glslang_tab.cpp" + break; + + case 299: /* type_specifier_nonarray: DMAT3 */ +#line 2220 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(3, 3); + } +#line 8407 "MachineIndependent/glslang_tab.cpp" + break; + case 300: /* type_specifier_nonarray: DMAT4 */ -#line 2227 "MachineIndependent/glslang.y" +#line 2228 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8390,11 +8416,11 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8394 "MachineIndependent/glslang_tab.cpp" +#line 8420 "MachineIndependent/glslang_tab.cpp" break; case 301: /* type_specifier_nonarray: DMAT2X2 */ -#line 2235 "MachineIndependent/glslang.y" +#line 2236 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8403,102 +8429,102 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8407 "MachineIndependent/glslang_tab.cpp" - break; - - case 302: /* type_specifier_nonarray: DMAT2X3 */ -#line 2243 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 3); - } -#line 8420 "MachineIndependent/glslang_tab.cpp" - break; - - case 303: /* type_specifier_nonarray: DMAT2X4 */ -#line 2251 "MachineIndependent/glslang.y" - { - parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); - (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); - (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(2, 4); - } #line 8433 "MachineIndependent/glslang_tab.cpp" break; - case 304: /* type_specifier_nonarray: DMAT3X2 */ -#line 2259 "MachineIndependent/glslang.y" + case 302: /* type_specifier_nonarray: DMAT2X3 */ +#line 2244 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 2); + (yyval.interm.type).setMatrix(2, 3); } #line 8446 "MachineIndependent/glslang_tab.cpp" break; - case 305: /* type_specifier_nonarray: DMAT3X3 */ -#line 2267 "MachineIndependent/glslang.y" + case 303: /* type_specifier_nonarray: DMAT2X4 */ +#line 2252 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 3); + (yyval.interm.type).setMatrix(2, 4); } #line 8459 "MachineIndependent/glslang_tab.cpp" break; - case 306: /* type_specifier_nonarray: DMAT3X4 */ -#line 2275 "MachineIndependent/glslang.y" + case 304: /* type_specifier_nonarray: DMAT3X2 */ +#line 2260 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(3, 4); + (yyval.interm.type).setMatrix(3, 2); } #line 8472 "MachineIndependent/glslang_tab.cpp" break; - case 307: /* type_specifier_nonarray: DMAT4X2 */ -#line 2283 "MachineIndependent/glslang.y" + case 305: /* type_specifier_nonarray: DMAT3X3 */ +#line 2268 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 2); + (yyval.interm.type).setMatrix(3, 3); } #line 8485 "MachineIndependent/glslang_tab.cpp" break; - case 308: /* type_specifier_nonarray: DMAT4X3 */ -#line 2291 "MachineIndependent/glslang.y" + case 306: /* type_specifier_nonarray: DMAT3X4 */ +#line 2276 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; - (yyval.interm.type).setMatrix(4, 3); + (yyval.interm.type).setMatrix(3, 4); } #line 8498 "MachineIndependent/glslang_tab.cpp" break; + case 307: /* type_specifier_nonarray: DMAT4X2 */ +#line 2284 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 2); + } +#line 8511 "MachineIndependent/glslang_tab.cpp" + break; + + case 308: /* type_specifier_nonarray: DMAT4X3 */ +#line 2292 "MachineIndependent/glslang.y" + { + parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); + if (! parseContext.symbolTable.atBuiltInLevel()) + parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtDouble; + (yyval.interm.type).setMatrix(4, 3); + } +#line 8524 "MachineIndependent/glslang_tab.cpp" + break; + case 309: /* type_specifier_nonarray: DMAT4X4 */ -#line 2299 "MachineIndependent/glslang.y" +#line 2300 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8507,2261 +8533,2261 @@ yyreduce: (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8511 "MachineIndependent/glslang_tab.cpp" +#line 8537 "MachineIndependent/glslang_tab.cpp" break; case 310: /* type_specifier_nonarray: F16MAT2 */ -#line 2307 "MachineIndependent/glslang.y" +#line 2308 "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 8522 "MachineIndependent/glslang_tab.cpp" +#line 8548 "MachineIndependent/glslang_tab.cpp" break; case 311: /* type_specifier_nonarray: F16MAT3 */ -#line 2313 "MachineIndependent/glslang.y" +#line 2314 "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 8533 "MachineIndependent/glslang_tab.cpp" +#line 8559 "MachineIndependent/glslang_tab.cpp" break; case 312: /* type_specifier_nonarray: F16MAT4 */ -#line 2319 "MachineIndependent/glslang.y" +#line 2320 "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 8544 "MachineIndependent/glslang_tab.cpp" +#line 8570 "MachineIndependent/glslang_tab.cpp" break; case 313: /* type_specifier_nonarray: F16MAT2X2 */ -#line 2325 "MachineIndependent/glslang.y" +#line 2326 "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 8555 "MachineIndependent/glslang_tab.cpp" +#line 8581 "MachineIndependent/glslang_tab.cpp" break; case 314: /* type_specifier_nonarray: F16MAT2X3 */ -#line 2331 "MachineIndependent/glslang.y" +#line 2332 "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 8566 "MachineIndependent/glslang_tab.cpp" +#line 8592 "MachineIndependent/glslang_tab.cpp" break; case 315: /* type_specifier_nonarray: F16MAT2X4 */ -#line 2337 "MachineIndependent/glslang.y" +#line 2338 "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 8577 "MachineIndependent/glslang_tab.cpp" +#line 8603 "MachineIndependent/glslang_tab.cpp" break; case 316: /* type_specifier_nonarray: F16MAT3X2 */ -#line 2343 "MachineIndependent/glslang.y" +#line 2344 "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 8588 "MachineIndependent/glslang_tab.cpp" +#line 8614 "MachineIndependent/glslang_tab.cpp" break; case 317: /* type_specifier_nonarray: F16MAT3X3 */ -#line 2349 "MachineIndependent/glslang.y" +#line 2350 "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 8599 "MachineIndependent/glslang_tab.cpp" +#line 8625 "MachineIndependent/glslang_tab.cpp" break; case 318: /* type_specifier_nonarray: F16MAT3X4 */ -#line 2355 "MachineIndependent/glslang.y" +#line 2356 "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 8610 "MachineIndependent/glslang_tab.cpp" +#line 8636 "MachineIndependent/glslang_tab.cpp" break; case 319: /* type_specifier_nonarray: F16MAT4X2 */ -#line 2361 "MachineIndependent/glslang.y" +#line 2362 "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 8621 "MachineIndependent/glslang_tab.cpp" +#line 8647 "MachineIndependent/glslang_tab.cpp" break; case 320: /* type_specifier_nonarray: F16MAT4X3 */ -#line 2367 "MachineIndependent/glslang.y" +#line 2368 "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 8632 "MachineIndependent/glslang_tab.cpp" +#line 8658 "MachineIndependent/glslang_tab.cpp" break; case 321: /* type_specifier_nonarray: F16MAT4X4 */ -#line 2373 "MachineIndependent/glslang.y" +#line 2374 "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 8643 "MachineIndependent/glslang_tab.cpp" +#line 8669 "MachineIndependent/glslang_tab.cpp" break; case 322: /* type_specifier_nonarray: F32MAT2 */ -#line 2379 "MachineIndependent/glslang.y" +#line 2380 "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 8654 "MachineIndependent/glslang_tab.cpp" +#line 8680 "MachineIndependent/glslang_tab.cpp" break; case 323: /* type_specifier_nonarray: F32MAT3 */ -#line 2385 "MachineIndependent/glslang.y" +#line 2386 "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 8665 "MachineIndependent/glslang_tab.cpp" +#line 8691 "MachineIndependent/glslang_tab.cpp" break; case 324: /* type_specifier_nonarray: F32MAT4 */ -#line 2391 "MachineIndependent/glslang.y" +#line 2392 "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 8676 "MachineIndependent/glslang_tab.cpp" +#line 8702 "MachineIndependent/glslang_tab.cpp" break; case 325: /* type_specifier_nonarray: F32MAT2X2 */ -#line 2397 "MachineIndependent/glslang.y" +#line 2398 "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 8687 "MachineIndependent/glslang_tab.cpp" +#line 8713 "MachineIndependent/glslang_tab.cpp" break; case 326: /* type_specifier_nonarray: F32MAT2X3 */ -#line 2403 "MachineIndependent/glslang.y" +#line 2404 "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 8698 "MachineIndependent/glslang_tab.cpp" +#line 8724 "MachineIndependent/glslang_tab.cpp" break; case 327: /* type_specifier_nonarray: F32MAT2X4 */ -#line 2409 "MachineIndependent/glslang.y" +#line 2410 "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 8709 "MachineIndependent/glslang_tab.cpp" +#line 8735 "MachineIndependent/glslang_tab.cpp" break; case 328: /* type_specifier_nonarray: F32MAT3X2 */ -#line 2415 "MachineIndependent/glslang.y" +#line 2416 "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 8720 "MachineIndependent/glslang_tab.cpp" +#line 8746 "MachineIndependent/glslang_tab.cpp" break; case 329: /* type_specifier_nonarray: F32MAT3X3 */ -#line 2421 "MachineIndependent/glslang.y" +#line 2422 "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 8731 "MachineIndependent/glslang_tab.cpp" +#line 8757 "MachineIndependent/glslang_tab.cpp" break; case 330: /* type_specifier_nonarray: F32MAT3X4 */ -#line 2427 "MachineIndependent/glslang.y" +#line 2428 "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 8742 "MachineIndependent/glslang_tab.cpp" +#line 8768 "MachineIndependent/glslang_tab.cpp" break; case 331: /* type_specifier_nonarray: F32MAT4X2 */ -#line 2433 "MachineIndependent/glslang.y" +#line 2434 "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 8753 "MachineIndependent/glslang_tab.cpp" +#line 8779 "MachineIndependent/glslang_tab.cpp" break; case 332: /* type_specifier_nonarray: F32MAT4X3 */ -#line 2439 "MachineIndependent/glslang.y" +#line 2440 "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 8764 "MachineIndependent/glslang_tab.cpp" +#line 8790 "MachineIndependent/glslang_tab.cpp" break; case 333: /* type_specifier_nonarray: F32MAT4X4 */ -#line 2445 "MachineIndependent/glslang.y" +#line 2446 "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 8775 "MachineIndependent/glslang_tab.cpp" +#line 8801 "MachineIndependent/glslang_tab.cpp" break; case 334: /* type_specifier_nonarray: F64MAT2 */ -#line 2451 "MachineIndependent/glslang.y" +#line 2452 "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 8786 "MachineIndependent/glslang_tab.cpp" +#line 8812 "MachineIndependent/glslang_tab.cpp" break; case 335: /* type_specifier_nonarray: F64MAT3 */ -#line 2457 "MachineIndependent/glslang.y" +#line 2458 "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 8797 "MachineIndependent/glslang_tab.cpp" +#line 8823 "MachineIndependent/glslang_tab.cpp" break; case 336: /* type_specifier_nonarray: F64MAT4 */ -#line 2463 "MachineIndependent/glslang.y" +#line 2464 "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 8808 "MachineIndependent/glslang_tab.cpp" +#line 8834 "MachineIndependent/glslang_tab.cpp" break; case 337: /* type_specifier_nonarray: F64MAT2X2 */ -#line 2469 "MachineIndependent/glslang.y" +#line 2470 "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 8819 "MachineIndependent/glslang_tab.cpp" +#line 8845 "MachineIndependent/glslang_tab.cpp" break; case 338: /* type_specifier_nonarray: F64MAT2X3 */ -#line 2475 "MachineIndependent/glslang.y" +#line 2476 "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 8830 "MachineIndependent/glslang_tab.cpp" +#line 8856 "MachineIndependent/glslang_tab.cpp" break; case 339: /* type_specifier_nonarray: F64MAT2X4 */ -#line 2481 "MachineIndependent/glslang.y" +#line 2482 "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 8841 "MachineIndependent/glslang_tab.cpp" +#line 8867 "MachineIndependent/glslang_tab.cpp" break; case 340: /* type_specifier_nonarray: F64MAT3X2 */ -#line 2487 "MachineIndependent/glslang.y" +#line 2488 "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 8852 "MachineIndependent/glslang_tab.cpp" +#line 8878 "MachineIndependent/glslang_tab.cpp" break; case 341: /* type_specifier_nonarray: F64MAT3X3 */ -#line 2493 "MachineIndependent/glslang.y" +#line 2494 "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 8863 "MachineIndependent/glslang_tab.cpp" +#line 8889 "MachineIndependent/glslang_tab.cpp" break; case 342: /* type_specifier_nonarray: F64MAT3X4 */ -#line 2499 "MachineIndependent/glslang.y" +#line 2500 "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 8874 "MachineIndependent/glslang_tab.cpp" +#line 8900 "MachineIndependent/glslang_tab.cpp" break; case 343: /* type_specifier_nonarray: F64MAT4X2 */ -#line 2505 "MachineIndependent/glslang.y" +#line 2506 "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 8885 "MachineIndependent/glslang_tab.cpp" +#line 8911 "MachineIndependent/glslang_tab.cpp" break; case 344: /* type_specifier_nonarray: F64MAT4X3 */ -#line 2511 "MachineIndependent/glslang.y" +#line 2512 "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 8896 "MachineIndependent/glslang_tab.cpp" +#line 8922 "MachineIndependent/glslang_tab.cpp" break; case 345: /* type_specifier_nonarray: F64MAT4X4 */ -#line 2517 "MachineIndependent/glslang.y" +#line 2518 "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 8907 "MachineIndependent/glslang_tab.cpp" +#line 8933 "MachineIndependent/glslang_tab.cpp" break; case 346: /* type_specifier_nonarray: ACCSTRUCTNV */ -#line 2523 "MachineIndependent/glslang.y" +#line 2524 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 8916 "MachineIndependent/glslang_tab.cpp" +#line 8942 "MachineIndependent/glslang_tab.cpp" break; case 347: /* type_specifier_nonarray: ACCSTRUCTEXT */ -#line 2527 "MachineIndependent/glslang.y" +#line 2528 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 8925 "MachineIndependent/glslang_tab.cpp" +#line 8951 "MachineIndependent/glslang_tab.cpp" break; case 348: /* type_specifier_nonarray: RAYQUERYEXT */ -#line 2531 "MachineIndependent/glslang.y" +#line 2532 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtRayQuery; } -#line 8934 "MachineIndependent/glslang_tab.cpp" +#line 8960 "MachineIndependent/glslang_tab.cpp" break; case 349: /* type_specifier_nonarray: ATOMIC_UINT */ -#line 2535 "MachineIndependent/glslang.y" +#line 2536 "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 8944 "MachineIndependent/glslang_tab.cpp" +#line 8970 "MachineIndependent/glslang_tab.cpp" break; case 350: /* type_specifier_nonarray: SAMPLER1D */ -#line 2540 "MachineIndependent/glslang.y" +#line 2541 "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 8954 "MachineIndependent/glslang_tab.cpp" +#line 8980 "MachineIndependent/glslang_tab.cpp" break; case 351: /* type_specifier_nonarray: SAMPLER2D */ -#line 2545 "MachineIndependent/glslang.y" +#line 2546 "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 8964 "MachineIndependent/glslang_tab.cpp" +#line 8990 "MachineIndependent/glslang_tab.cpp" break; case 352: /* type_specifier_nonarray: SAMPLER3D */ -#line 2550 "MachineIndependent/glslang.y" +#line 2551 "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 8974 "MachineIndependent/glslang_tab.cpp" +#line 9000 "MachineIndependent/glslang_tab.cpp" break; case 353: /* type_specifier_nonarray: SAMPLERCUBE */ -#line 2555 "MachineIndependent/glslang.y" +#line 2556 "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 8984 "MachineIndependent/glslang_tab.cpp" +#line 9010 "MachineIndependent/glslang_tab.cpp" break; case 354: /* type_specifier_nonarray: SAMPLER2DSHADOW */ -#line 2560 "MachineIndependent/glslang.y" +#line 2561 "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 8994 "MachineIndependent/glslang_tab.cpp" +#line 9020 "MachineIndependent/glslang_tab.cpp" break; case 355: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ -#line 2565 "MachineIndependent/glslang.y" +#line 2566 "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 9004 "MachineIndependent/glslang_tab.cpp" +#line 9030 "MachineIndependent/glslang_tab.cpp" break; case 356: /* type_specifier_nonarray: SAMPLER2DARRAY */ -#line 2570 "MachineIndependent/glslang.y" +#line 2571 "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 9014 "MachineIndependent/glslang_tab.cpp" +#line 9040 "MachineIndependent/glslang_tab.cpp" break; case 357: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ -#line 2575 "MachineIndependent/glslang.y" +#line 2576 "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 9024 "MachineIndependent/glslang_tab.cpp" +#line 9050 "MachineIndependent/glslang_tab.cpp" break; case 358: /* type_specifier_nonarray: SAMPLER1DSHADOW */ -#line 2580 "MachineIndependent/glslang.y" +#line 2581 "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 9034 "MachineIndependent/glslang_tab.cpp" +#line 9060 "MachineIndependent/glslang_tab.cpp" break; case 359: /* type_specifier_nonarray: SAMPLER1DARRAY */ -#line 2585 "MachineIndependent/glslang.y" +#line 2586 "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 9044 "MachineIndependent/glslang_tab.cpp" +#line 9070 "MachineIndependent/glslang_tab.cpp" break; case 360: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ -#line 2590 "MachineIndependent/glslang.y" +#line 2591 "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 9054 "MachineIndependent/glslang_tab.cpp" +#line 9080 "MachineIndependent/glslang_tab.cpp" break; case 361: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ -#line 2595 "MachineIndependent/glslang.y" +#line 2596 "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 9064 "MachineIndependent/glslang_tab.cpp" +#line 9090 "MachineIndependent/glslang_tab.cpp" break; case 362: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ -#line 2600 "MachineIndependent/glslang.y" +#line 2601 "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 9074 "MachineIndependent/glslang_tab.cpp" +#line 9100 "MachineIndependent/glslang_tab.cpp" break; case 363: /* type_specifier_nonarray: F16SAMPLER1D */ -#line 2605 "MachineIndependent/glslang.y" +#line 2606 "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 9085 "MachineIndependent/glslang_tab.cpp" +#line 9111 "MachineIndependent/glslang_tab.cpp" break; case 364: /* type_specifier_nonarray: F16SAMPLER2D */ -#line 2611 "MachineIndependent/glslang.y" +#line 2612 "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 9096 "MachineIndependent/glslang_tab.cpp" +#line 9122 "MachineIndependent/glslang_tab.cpp" break; case 365: /* type_specifier_nonarray: F16SAMPLER3D */ -#line 2617 "MachineIndependent/glslang.y" +#line 2618 "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 9107 "MachineIndependent/glslang_tab.cpp" +#line 9133 "MachineIndependent/glslang_tab.cpp" break; case 366: /* type_specifier_nonarray: F16SAMPLERCUBE */ -#line 2623 "MachineIndependent/glslang.y" +#line 2624 "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 9118 "MachineIndependent/glslang_tab.cpp" +#line 9144 "MachineIndependent/glslang_tab.cpp" break; case 367: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ -#line 2629 "MachineIndependent/glslang.y" +#line 2630 "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 9129 "MachineIndependent/glslang_tab.cpp" +#line 9155 "MachineIndependent/glslang_tab.cpp" break; case 368: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ -#line 2635 "MachineIndependent/glslang.y" +#line 2636 "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 9140 "MachineIndependent/glslang_tab.cpp" +#line 9166 "MachineIndependent/glslang_tab.cpp" break; case 369: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ -#line 2641 "MachineIndependent/glslang.y" +#line 2642 "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 9151 "MachineIndependent/glslang_tab.cpp" +#line 9177 "MachineIndependent/glslang_tab.cpp" break; case 370: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ -#line 2647 "MachineIndependent/glslang.y" +#line 2648 "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 9162 "MachineIndependent/glslang_tab.cpp" +#line 9188 "MachineIndependent/glslang_tab.cpp" break; case 371: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ -#line 2653 "MachineIndependent/glslang.y" +#line 2654 "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 9173 "MachineIndependent/glslang_tab.cpp" +#line 9199 "MachineIndependent/glslang_tab.cpp" break; case 372: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ -#line 2659 "MachineIndependent/glslang.y" +#line 2660 "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 9184 "MachineIndependent/glslang_tab.cpp" +#line 9210 "MachineIndependent/glslang_tab.cpp" break; case 373: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ -#line 2665 "MachineIndependent/glslang.y" +#line 2666 "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 9195 "MachineIndependent/glslang_tab.cpp" +#line 9221 "MachineIndependent/glslang_tab.cpp" break; case 374: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ -#line 2671 "MachineIndependent/glslang.y" +#line 2672 "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 9206 "MachineIndependent/glslang_tab.cpp" +#line 9232 "MachineIndependent/glslang_tab.cpp" break; case 375: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ -#line 2677 "MachineIndependent/glslang.y" +#line 2678 "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 9217 "MachineIndependent/glslang_tab.cpp" +#line 9243 "MachineIndependent/glslang_tab.cpp" break; case 376: /* type_specifier_nonarray: ISAMPLER1D */ -#line 2683 "MachineIndependent/glslang.y" +#line 2684 "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 9227 "MachineIndependent/glslang_tab.cpp" +#line 9253 "MachineIndependent/glslang_tab.cpp" break; case 377: /* type_specifier_nonarray: ISAMPLER2D */ -#line 2688 "MachineIndependent/glslang.y" +#line 2689 "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 9237 "MachineIndependent/glslang_tab.cpp" +#line 9263 "MachineIndependent/glslang_tab.cpp" break; case 378: /* type_specifier_nonarray: ISAMPLER3D */ -#line 2693 "MachineIndependent/glslang.y" +#line 2694 "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 9247 "MachineIndependent/glslang_tab.cpp" +#line 9273 "MachineIndependent/glslang_tab.cpp" break; case 379: /* type_specifier_nonarray: ISAMPLERCUBE */ -#line 2698 "MachineIndependent/glslang.y" +#line 2699 "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 9257 "MachineIndependent/glslang_tab.cpp" +#line 9283 "MachineIndependent/glslang_tab.cpp" break; case 380: /* type_specifier_nonarray: ISAMPLER2DARRAY */ -#line 2703 "MachineIndependent/glslang.y" +#line 2704 "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 9267 "MachineIndependent/glslang_tab.cpp" +#line 9293 "MachineIndependent/glslang_tab.cpp" break; case 381: /* type_specifier_nonarray: USAMPLER2D */ -#line 2708 "MachineIndependent/glslang.y" +#line 2709 "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 9277 "MachineIndependent/glslang_tab.cpp" +#line 9303 "MachineIndependent/glslang_tab.cpp" break; case 382: /* type_specifier_nonarray: USAMPLER3D */ -#line 2713 "MachineIndependent/glslang.y" +#line 2714 "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 9287 "MachineIndependent/glslang_tab.cpp" +#line 9313 "MachineIndependent/glslang_tab.cpp" break; case 383: /* type_specifier_nonarray: USAMPLERCUBE */ -#line 2718 "MachineIndependent/glslang.y" +#line 2719 "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 9297 "MachineIndependent/glslang_tab.cpp" +#line 9323 "MachineIndependent/glslang_tab.cpp" break; case 384: /* type_specifier_nonarray: ISAMPLER1DARRAY */ -#line 2723 "MachineIndependent/glslang.y" +#line 2724 "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 9307 "MachineIndependent/glslang_tab.cpp" +#line 9333 "MachineIndependent/glslang_tab.cpp" break; case 385: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ -#line 2728 "MachineIndependent/glslang.y" +#line 2729 "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 9317 "MachineIndependent/glslang_tab.cpp" +#line 9343 "MachineIndependent/glslang_tab.cpp" break; case 386: /* type_specifier_nonarray: USAMPLER1D */ -#line 2733 "MachineIndependent/glslang.y" +#line 2734 "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 9327 "MachineIndependent/glslang_tab.cpp" +#line 9353 "MachineIndependent/glslang_tab.cpp" break; case 387: /* type_specifier_nonarray: USAMPLER1DARRAY */ -#line 2738 "MachineIndependent/glslang.y" +#line 2739 "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 9337 "MachineIndependent/glslang_tab.cpp" +#line 9363 "MachineIndependent/glslang_tab.cpp" break; case 388: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ -#line 2743 "MachineIndependent/glslang.y" +#line 2744 "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 9347 "MachineIndependent/glslang_tab.cpp" +#line 9373 "MachineIndependent/glslang_tab.cpp" break; case 389: /* type_specifier_nonarray: TEXTURECUBEARRAY */ -#line 2748 "MachineIndependent/glslang.y" +#line 2749 "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 9357 "MachineIndependent/glslang_tab.cpp" +#line 9383 "MachineIndependent/glslang_tab.cpp" break; case 390: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ -#line 2753 "MachineIndependent/glslang.y" +#line 2754 "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 9367 "MachineIndependent/glslang_tab.cpp" +#line 9393 "MachineIndependent/glslang_tab.cpp" break; case 391: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ -#line 2758 "MachineIndependent/glslang.y" +#line 2759 "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 9377 "MachineIndependent/glslang_tab.cpp" +#line 9403 "MachineIndependent/glslang_tab.cpp" break; case 392: /* type_specifier_nonarray: USAMPLER2DARRAY */ -#line 2763 "MachineIndependent/glslang.y" +#line 2764 "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 9387 "MachineIndependent/glslang_tab.cpp" +#line 9413 "MachineIndependent/glslang_tab.cpp" break; case 393: /* type_specifier_nonarray: TEXTURE2D */ -#line 2768 "MachineIndependent/glslang.y" +#line 2769 "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 9397 "MachineIndependent/glslang_tab.cpp" +#line 9423 "MachineIndependent/glslang_tab.cpp" break; case 394: /* type_specifier_nonarray: TEXTURE3D */ -#line 2773 "MachineIndependent/glslang.y" +#line 2774 "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 9407 "MachineIndependent/glslang_tab.cpp" +#line 9433 "MachineIndependent/glslang_tab.cpp" break; case 395: /* type_specifier_nonarray: TEXTURE2DARRAY */ -#line 2778 "MachineIndependent/glslang.y" +#line 2779 "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 9417 "MachineIndependent/glslang_tab.cpp" +#line 9443 "MachineIndependent/glslang_tab.cpp" break; case 396: /* type_specifier_nonarray: TEXTURECUBE */ -#line 2783 "MachineIndependent/glslang.y" +#line 2784 "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 9427 "MachineIndependent/glslang_tab.cpp" +#line 9453 "MachineIndependent/glslang_tab.cpp" break; case 397: /* type_specifier_nonarray: ITEXTURE2D */ -#line 2788 "MachineIndependent/glslang.y" +#line 2789 "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 9437 "MachineIndependent/glslang_tab.cpp" +#line 9463 "MachineIndependent/glslang_tab.cpp" break; case 398: /* type_specifier_nonarray: ITEXTURE3D */ -#line 2793 "MachineIndependent/glslang.y" +#line 2794 "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 9447 "MachineIndependent/glslang_tab.cpp" +#line 9473 "MachineIndependent/glslang_tab.cpp" break; case 399: /* type_specifier_nonarray: ITEXTURECUBE */ -#line 2798 "MachineIndependent/glslang.y" +#line 2799 "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 9457 "MachineIndependent/glslang_tab.cpp" +#line 9483 "MachineIndependent/glslang_tab.cpp" break; case 400: /* type_specifier_nonarray: ITEXTURE2DARRAY */ -#line 2803 "MachineIndependent/glslang.y" +#line 2804 "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 9467 "MachineIndependent/glslang_tab.cpp" +#line 9493 "MachineIndependent/glslang_tab.cpp" break; case 401: /* type_specifier_nonarray: UTEXTURE2D */ -#line 2808 "MachineIndependent/glslang.y" +#line 2809 "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 9477 "MachineIndependent/glslang_tab.cpp" +#line 9503 "MachineIndependent/glslang_tab.cpp" break; case 402: /* type_specifier_nonarray: UTEXTURE3D */ -#line 2813 "MachineIndependent/glslang.y" +#line 2814 "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 9487 "MachineIndependent/glslang_tab.cpp" +#line 9513 "MachineIndependent/glslang_tab.cpp" break; case 403: /* type_specifier_nonarray: UTEXTURECUBE */ -#line 2818 "MachineIndependent/glslang.y" +#line 2819 "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 9497 "MachineIndependent/glslang_tab.cpp" +#line 9523 "MachineIndependent/glslang_tab.cpp" break; case 404: /* type_specifier_nonarray: UTEXTURE2DARRAY */ -#line 2823 "MachineIndependent/glslang.y" +#line 2824 "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 9507 "MachineIndependent/glslang_tab.cpp" +#line 9533 "MachineIndependent/glslang_tab.cpp" break; case 405: /* type_specifier_nonarray: SAMPLER */ -#line 2828 "MachineIndependent/glslang.y" +#line 2829 "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 9517 "MachineIndependent/glslang_tab.cpp" +#line 9543 "MachineIndependent/glslang_tab.cpp" break; case 406: /* type_specifier_nonarray: SAMPLERSHADOW */ -#line 2833 "MachineIndependent/glslang.y" +#line 2834 "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 9527 "MachineIndependent/glslang_tab.cpp" +#line 9553 "MachineIndependent/glslang_tab.cpp" break; case 407: /* type_specifier_nonarray: SAMPLER2DRECT */ -#line 2838 "MachineIndependent/glslang.y" +#line 2839 "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 9537 "MachineIndependent/glslang_tab.cpp" +#line 9563 "MachineIndependent/glslang_tab.cpp" break; case 408: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ -#line 2843 "MachineIndependent/glslang.y" +#line 2844 "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 9547 "MachineIndependent/glslang_tab.cpp" +#line 9573 "MachineIndependent/glslang_tab.cpp" break; case 409: /* type_specifier_nonarray: F16SAMPLER2DRECT */ -#line 2848 "MachineIndependent/glslang.y" +#line 2849 "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 9558 "MachineIndependent/glslang_tab.cpp" +#line 9584 "MachineIndependent/glslang_tab.cpp" break; case 410: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ -#line 2854 "MachineIndependent/glslang.y" +#line 2855 "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 9569 "MachineIndependent/glslang_tab.cpp" +#line 9595 "MachineIndependent/glslang_tab.cpp" break; case 411: /* type_specifier_nonarray: ISAMPLER2DRECT */ -#line 2860 "MachineIndependent/glslang.y" +#line 2861 "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 9579 "MachineIndependent/glslang_tab.cpp" +#line 9605 "MachineIndependent/glslang_tab.cpp" break; case 412: /* type_specifier_nonarray: USAMPLER2DRECT */ -#line 2865 "MachineIndependent/glslang.y" +#line 2866 "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 9589 "MachineIndependent/glslang_tab.cpp" +#line 9615 "MachineIndependent/glslang_tab.cpp" break; case 413: /* type_specifier_nonarray: SAMPLERBUFFER */ -#line 2870 "MachineIndependent/glslang.y" +#line 2871 "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 9599 "MachineIndependent/glslang_tab.cpp" +#line 9625 "MachineIndependent/glslang_tab.cpp" break; case 414: /* type_specifier_nonarray: F16SAMPLERBUFFER */ -#line 2875 "MachineIndependent/glslang.y" +#line 2876 "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 9610 "MachineIndependent/glslang_tab.cpp" +#line 9636 "MachineIndependent/glslang_tab.cpp" break; case 415: /* type_specifier_nonarray: ISAMPLERBUFFER */ -#line 2881 "MachineIndependent/glslang.y" +#line 2882 "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 9620 "MachineIndependent/glslang_tab.cpp" +#line 9646 "MachineIndependent/glslang_tab.cpp" break; case 416: /* type_specifier_nonarray: USAMPLERBUFFER */ -#line 2886 "MachineIndependent/glslang.y" +#line 2887 "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 9630 "MachineIndependent/glslang_tab.cpp" +#line 9656 "MachineIndependent/glslang_tab.cpp" break; case 417: /* type_specifier_nonarray: SAMPLER2DMS */ -#line 2891 "MachineIndependent/glslang.y" +#line 2892 "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 9640 "MachineIndependent/glslang_tab.cpp" +#line 9666 "MachineIndependent/glslang_tab.cpp" break; case 418: /* type_specifier_nonarray: F16SAMPLER2DMS */ -#line 2896 "MachineIndependent/glslang.y" +#line 2897 "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 9651 "MachineIndependent/glslang_tab.cpp" +#line 9677 "MachineIndependent/glslang_tab.cpp" break; case 419: /* type_specifier_nonarray: ISAMPLER2DMS */ -#line 2902 "MachineIndependent/glslang.y" +#line 2903 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 9661 "MachineIndependent/glslang_tab.cpp" +#line 9687 "MachineIndependent/glslang_tab.cpp" break; case 420: /* type_specifier_nonarray: USAMPLER2DMS */ -#line 2907 "MachineIndependent/glslang.y" +#line 2908 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 9671 "MachineIndependent/glslang_tab.cpp" +#line 9697 "MachineIndependent/glslang_tab.cpp" break; case 421: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ -#line 2912 "MachineIndependent/glslang.y" +#line 2913 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 9681 "MachineIndependent/glslang_tab.cpp" +#line 9707 "MachineIndependent/glslang_tab.cpp" break; case 422: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ -#line 2917 "MachineIndependent/glslang.y" +#line 2918 "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 9692 "MachineIndependent/glslang_tab.cpp" +#line 9718 "MachineIndependent/glslang_tab.cpp" break; case 423: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ -#line 2923 "MachineIndependent/glslang.y" +#line 2924 "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 9702 "MachineIndependent/glslang_tab.cpp" +#line 9728 "MachineIndependent/glslang_tab.cpp" break; case 424: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ -#line 2928 "MachineIndependent/glslang.y" +#line 2929 "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 9712 "MachineIndependent/glslang_tab.cpp" +#line 9738 "MachineIndependent/glslang_tab.cpp" break; case 425: /* type_specifier_nonarray: TEXTURE1D */ -#line 2933 "MachineIndependent/glslang.y" +#line 2934 "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 9722 "MachineIndependent/glslang_tab.cpp" +#line 9748 "MachineIndependent/glslang_tab.cpp" break; case 426: /* type_specifier_nonarray: F16TEXTURE1D */ -#line 2938 "MachineIndependent/glslang.y" +#line 2939 "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 9733 "MachineIndependent/glslang_tab.cpp" +#line 9759 "MachineIndependent/glslang_tab.cpp" break; case 427: /* type_specifier_nonarray: F16TEXTURE2D */ -#line 2944 "MachineIndependent/glslang.y" +#line 2945 "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 9744 "MachineIndependent/glslang_tab.cpp" +#line 9770 "MachineIndependent/glslang_tab.cpp" break; case 428: /* type_specifier_nonarray: F16TEXTURE3D */ -#line 2950 "MachineIndependent/glslang.y" +#line 2951 "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 9755 "MachineIndependent/glslang_tab.cpp" +#line 9781 "MachineIndependent/glslang_tab.cpp" break; case 429: /* type_specifier_nonarray: F16TEXTURECUBE */ -#line 2956 "MachineIndependent/glslang.y" +#line 2957 "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 9766 "MachineIndependent/glslang_tab.cpp" +#line 9792 "MachineIndependent/glslang_tab.cpp" break; case 430: /* type_specifier_nonarray: TEXTURE1DARRAY */ -#line 2962 "MachineIndependent/glslang.y" +#line 2963 "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 9776 "MachineIndependent/glslang_tab.cpp" +#line 9802 "MachineIndependent/glslang_tab.cpp" break; case 431: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ -#line 2967 "MachineIndependent/glslang.y" +#line 2968 "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 9787 "MachineIndependent/glslang_tab.cpp" +#line 9813 "MachineIndependent/glslang_tab.cpp" break; case 432: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ -#line 2973 "MachineIndependent/glslang.y" +#line 2974 "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 9798 "MachineIndependent/glslang_tab.cpp" +#line 9824 "MachineIndependent/glslang_tab.cpp" break; case 433: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ -#line 2979 "MachineIndependent/glslang.y" +#line 2980 "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 9809 "MachineIndependent/glslang_tab.cpp" +#line 9835 "MachineIndependent/glslang_tab.cpp" break; case 434: /* type_specifier_nonarray: ITEXTURE1D */ -#line 2985 "MachineIndependent/glslang.y" +#line 2986 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 9819 "MachineIndependent/glslang_tab.cpp" +#line 9845 "MachineIndependent/glslang_tab.cpp" break; case 435: /* type_specifier_nonarray: ITEXTURE1DARRAY */ -#line 2990 "MachineIndependent/glslang.y" +#line 2991 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 9829 "MachineIndependent/glslang_tab.cpp" +#line 9855 "MachineIndependent/glslang_tab.cpp" break; case 436: /* type_specifier_nonarray: UTEXTURE1D */ -#line 2995 "MachineIndependent/glslang.y" +#line 2996 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 9839 "MachineIndependent/glslang_tab.cpp" +#line 9865 "MachineIndependent/glslang_tab.cpp" break; case 437: /* type_specifier_nonarray: UTEXTURE1DARRAY */ -#line 3000 "MachineIndependent/glslang.y" +#line 3001 "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 9849 "MachineIndependent/glslang_tab.cpp" +#line 9875 "MachineIndependent/glslang_tab.cpp" break; case 438: /* type_specifier_nonarray: TEXTURE2DRECT */ -#line 3005 "MachineIndependent/glslang.y" +#line 3006 "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 9859 "MachineIndependent/glslang_tab.cpp" +#line 9885 "MachineIndependent/glslang_tab.cpp" break; case 439: /* type_specifier_nonarray: F16TEXTURE2DRECT */ -#line 3010 "MachineIndependent/glslang.y" +#line 3011 "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 9870 "MachineIndependent/glslang_tab.cpp" +#line 9896 "MachineIndependent/glslang_tab.cpp" break; case 440: /* type_specifier_nonarray: ITEXTURE2DRECT */ -#line 3016 "MachineIndependent/glslang.y" +#line 3017 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 9880 "MachineIndependent/glslang_tab.cpp" +#line 9906 "MachineIndependent/glslang_tab.cpp" break; case 441: /* type_specifier_nonarray: UTEXTURE2DRECT */ -#line 3021 "MachineIndependent/glslang.y" +#line 3022 "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 9890 "MachineIndependent/glslang_tab.cpp" +#line 9916 "MachineIndependent/glslang_tab.cpp" break; case 442: /* type_specifier_nonarray: TEXTUREBUFFER */ -#line 3026 "MachineIndependent/glslang.y" +#line 3027 "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 9900 "MachineIndependent/glslang_tab.cpp" +#line 9926 "MachineIndependent/glslang_tab.cpp" break; case 443: /* type_specifier_nonarray: F16TEXTUREBUFFER */ -#line 3031 "MachineIndependent/glslang.y" +#line 3032 "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 9911 "MachineIndependent/glslang_tab.cpp" +#line 9937 "MachineIndependent/glslang_tab.cpp" break; case 444: /* type_specifier_nonarray: ITEXTUREBUFFER */ -#line 3037 "MachineIndependent/glslang.y" +#line 3038 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 9921 "MachineIndependent/glslang_tab.cpp" +#line 9947 "MachineIndependent/glslang_tab.cpp" break; case 445: /* type_specifier_nonarray: UTEXTUREBUFFER */ -#line 3042 "MachineIndependent/glslang.y" +#line 3043 "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 9931 "MachineIndependent/glslang_tab.cpp" +#line 9957 "MachineIndependent/glslang_tab.cpp" break; case 446: /* type_specifier_nonarray: TEXTURE2DMS */ -#line 3047 "MachineIndependent/glslang.y" +#line 3048 "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 9941 "MachineIndependent/glslang_tab.cpp" +#line 9967 "MachineIndependent/glslang_tab.cpp" break; case 447: /* type_specifier_nonarray: F16TEXTURE2DMS */ -#line 3052 "MachineIndependent/glslang.y" +#line 3053 "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 9952 "MachineIndependent/glslang_tab.cpp" +#line 9978 "MachineIndependent/glslang_tab.cpp" break; case 448: /* type_specifier_nonarray: ITEXTURE2DMS */ -#line 3058 "MachineIndependent/glslang.y" +#line 3059 "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 9962 "MachineIndependent/glslang_tab.cpp" +#line 9988 "MachineIndependent/glslang_tab.cpp" break; case 449: /* type_specifier_nonarray: UTEXTURE2DMS */ -#line 3063 "MachineIndependent/glslang.y" +#line 3064 "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 9972 "MachineIndependent/glslang_tab.cpp" +#line 9998 "MachineIndependent/glslang_tab.cpp" break; case 450: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ -#line 3068 "MachineIndependent/glslang.y" +#line 3069 "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 9982 "MachineIndependent/glslang_tab.cpp" +#line 10008 "MachineIndependent/glslang_tab.cpp" break; case 451: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ -#line 3073 "MachineIndependent/glslang.y" +#line 3074 "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 9993 "MachineIndependent/glslang_tab.cpp" +#line 10019 "MachineIndependent/glslang_tab.cpp" break; case 452: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ -#line 3079 "MachineIndependent/glslang.y" +#line 3080 "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 10003 "MachineIndependent/glslang_tab.cpp" +#line 10029 "MachineIndependent/glslang_tab.cpp" break; case 453: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ -#line 3084 "MachineIndependent/glslang.y" +#line 3085 "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 10013 "MachineIndependent/glslang_tab.cpp" +#line 10039 "MachineIndependent/glslang_tab.cpp" break; case 454: /* type_specifier_nonarray: IMAGE1D */ -#line 3089 "MachineIndependent/glslang.y" +#line 3090 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 10023 "MachineIndependent/glslang_tab.cpp" +#line 10049 "MachineIndependent/glslang_tab.cpp" break; case 455: /* type_specifier_nonarray: F16IMAGE1D */ -#line 3094 "MachineIndependent/glslang.y" +#line 3095 "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 10034 "MachineIndependent/glslang_tab.cpp" +#line 10060 "MachineIndependent/glslang_tab.cpp" break; case 456: /* type_specifier_nonarray: IIMAGE1D */ -#line 3100 "MachineIndependent/glslang.y" +#line 3101 "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 10044 "MachineIndependent/glslang_tab.cpp" +#line 10070 "MachineIndependent/glslang_tab.cpp" break; case 457: /* type_specifier_nonarray: UIMAGE1D */ -#line 3105 "MachineIndependent/glslang.y" +#line 3106 "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 10054 "MachineIndependent/glslang_tab.cpp" +#line 10080 "MachineIndependent/glslang_tab.cpp" break; case 458: /* type_specifier_nonarray: IMAGE2D */ -#line 3110 "MachineIndependent/glslang.y" +#line 3111 "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 10064 "MachineIndependent/glslang_tab.cpp" +#line 10090 "MachineIndependent/glslang_tab.cpp" break; case 459: /* type_specifier_nonarray: F16IMAGE2D */ -#line 3115 "MachineIndependent/glslang.y" +#line 3116 "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 10075 "MachineIndependent/glslang_tab.cpp" +#line 10101 "MachineIndependent/glslang_tab.cpp" break; case 460: /* type_specifier_nonarray: IIMAGE2D */ -#line 3121 "MachineIndependent/glslang.y" +#line 3122 "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 10085 "MachineIndependent/glslang_tab.cpp" +#line 10111 "MachineIndependent/glslang_tab.cpp" break; case 461: /* type_specifier_nonarray: UIMAGE2D */ -#line 3126 "MachineIndependent/glslang.y" +#line 3127 "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 10095 "MachineIndependent/glslang_tab.cpp" +#line 10121 "MachineIndependent/glslang_tab.cpp" break; case 462: /* type_specifier_nonarray: IMAGE3D */ -#line 3131 "MachineIndependent/glslang.y" +#line 3132 "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 10105 "MachineIndependent/glslang_tab.cpp" +#line 10131 "MachineIndependent/glslang_tab.cpp" break; case 463: /* type_specifier_nonarray: F16IMAGE3D */ -#line 3136 "MachineIndependent/glslang.y" +#line 3137 "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 10116 "MachineIndependent/glslang_tab.cpp" +#line 10142 "MachineIndependent/glslang_tab.cpp" break; case 464: /* type_specifier_nonarray: IIMAGE3D */ -#line 3142 "MachineIndependent/glslang.y" +#line 3143 "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 10126 "MachineIndependent/glslang_tab.cpp" +#line 10152 "MachineIndependent/glslang_tab.cpp" break; case 465: /* type_specifier_nonarray: UIMAGE3D */ -#line 3147 "MachineIndependent/glslang.y" +#line 3148 "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 10136 "MachineIndependent/glslang_tab.cpp" +#line 10162 "MachineIndependent/glslang_tab.cpp" break; case 466: /* type_specifier_nonarray: IMAGE2DRECT */ -#line 3152 "MachineIndependent/glslang.y" +#line 3153 "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 10146 "MachineIndependent/glslang_tab.cpp" +#line 10172 "MachineIndependent/glslang_tab.cpp" break; case 467: /* type_specifier_nonarray: F16IMAGE2DRECT */ -#line 3157 "MachineIndependent/glslang.y" +#line 3158 "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 10157 "MachineIndependent/glslang_tab.cpp" +#line 10183 "MachineIndependent/glslang_tab.cpp" break; case 468: /* type_specifier_nonarray: IIMAGE2DRECT */ -#line 3163 "MachineIndependent/glslang.y" +#line 3164 "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 10167 "MachineIndependent/glslang_tab.cpp" +#line 10193 "MachineIndependent/glslang_tab.cpp" break; case 469: /* type_specifier_nonarray: UIMAGE2DRECT */ -#line 3168 "MachineIndependent/glslang.y" +#line 3169 "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 10177 "MachineIndependent/glslang_tab.cpp" +#line 10203 "MachineIndependent/glslang_tab.cpp" break; case 470: /* type_specifier_nonarray: IMAGECUBE */ -#line 3173 "MachineIndependent/glslang.y" +#line 3174 "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 10187 "MachineIndependent/glslang_tab.cpp" +#line 10213 "MachineIndependent/glslang_tab.cpp" break; case 471: /* type_specifier_nonarray: F16IMAGECUBE */ -#line 3178 "MachineIndependent/glslang.y" +#line 3179 "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 10198 "MachineIndependent/glslang_tab.cpp" +#line 10224 "MachineIndependent/glslang_tab.cpp" break; case 472: /* type_specifier_nonarray: IIMAGECUBE */ -#line 3184 "MachineIndependent/glslang.y" +#line 3185 "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 10208 "MachineIndependent/glslang_tab.cpp" +#line 10234 "MachineIndependent/glslang_tab.cpp" break; case 473: /* type_specifier_nonarray: UIMAGECUBE */ -#line 3189 "MachineIndependent/glslang.y" +#line 3190 "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 10218 "MachineIndependent/glslang_tab.cpp" +#line 10244 "MachineIndependent/glslang_tab.cpp" break; case 474: /* type_specifier_nonarray: IMAGEBUFFER */ -#line 3194 "MachineIndependent/glslang.y" +#line 3195 "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 10228 "MachineIndependent/glslang_tab.cpp" +#line 10254 "MachineIndependent/glslang_tab.cpp" break; case 475: /* type_specifier_nonarray: F16IMAGEBUFFER */ -#line 3199 "MachineIndependent/glslang.y" +#line 3200 "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 10239 "MachineIndependent/glslang_tab.cpp" +#line 10265 "MachineIndependent/glslang_tab.cpp" break; case 476: /* type_specifier_nonarray: IIMAGEBUFFER */ -#line 3205 "MachineIndependent/glslang.y" +#line 3206 "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 10249 "MachineIndependent/glslang_tab.cpp" +#line 10275 "MachineIndependent/glslang_tab.cpp" break; case 477: /* type_specifier_nonarray: UIMAGEBUFFER */ -#line 3210 "MachineIndependent/glslang.y" +#line 3211 "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 10259 "MachineIndependent/glslang_tab.cpp" +#line 10285 "MachineIndependent/glslang_tab.cpp" break; case 478: /* type_specifier_nonarray: IMAGE1DARRAY */ -#line 3215 "MachineIndependent/glslang.y" +#line 3216 "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 10269 "MachineIndependent/glslang_tab.cpp" +#line 10295 "MachineIndependent/glslang_tab.cpp" break; case 479: /* type_specifier_nonarray: F16IMAGE1DARRAY */ -#line 3220 "MachineIndependent/glslang.y" +#line 3221 "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 10280 "MachineIndependent/glslang_tab.cpp" +#line 10306 "MachineIndependent/glslang_tab.cpp" break; case 480: /* type_specifier_nonarray: IIMAGE1DARRAY */ -#line 3226 "MachineIndependent/glslang.y" +#line 3227 "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 10290 "MachineIndependent/glslang_tab.cpp" +#line 10316 "MachineIndependent/glslang_tab.cpp" break; case 481: /* type_specifier_nonarray: UIMAGE1DARRAY */ -#line 3231 "MachineIndependent/glslang.y" +#line 3232 "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 10300 "MachineIndependent/glslang_tab.cpp" +#line 10326 "MachineIndependent/glslang_tab.cpp" break; case 482: /* type_specifier_nonarray: IMAGE2DARRAY */ -#line 3236 "MachineIndependent/glslang.y" +#line 3237 "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 10310 "MachineIndependent/glslang_tab.cpp" +#line 10336 "MachineIndependent/glslang_tab.cpp" break; case 483: /* type_specifier_nonarray: F16IMAGE2DARRAY */ -#line 3241 "MachineIndependent/glslang.y" +#line 3242 "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 10321 "MachineIndependent/glslang_tab.cpp" +#line 10347 "MachineIndependent/glslang_tab.cpp" break; case 484: /* type_specifier_nonarray: IIMAGE2DARRAY */ -#line 3247 "MachineIndependent/glslang.y" +#line 3248 "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 10331 "MachineIndependent/glslang_tab.cpp" +#line 10357 "MachineIndependent/glslang_tab.cpp" break; case 485: /* type_specifier_nonarray: UIMAGE2DARRAY */ -#line 3252 "MachineIndependent/glslang.y" +#line 3253 "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 10341 "MachineIndependent/glslang_tab.cpp" +#line 10367 "MachineIndependent/glslang_tab.cpp" break; case 486: /* type_specifier_nonarray: IMAGECUBEARRAY */ -#line 3257 "MachineIndependent/glslang.y" +#line 3258 "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 10351 "MachineIndependent/glslang_tab.cpp" +#line 10377 "MachineIndependent/glslang_tab.cpp" break; case 487: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ -#line 3262 "MachineIndependent/glslang.y" +#line 3263 "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 10362 "MachineIndependent/glslang_tab.cpp" +#line 10388 "MachineIndependent/glslang_tab.cpp" break; case 488: /* type_specifier_nonarray: IIMAGECUBEARRAY */ -#line 3268 "MachineIndependent/glslang.y" +#line 3269 "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 10372 "MachineIndependent/glslang_tab.cpp" +#line 10398 "MachineIndependent/glslang_tab.cpp" break; case 489: /* type_specifier_nonarray: UIMAGECUBEARRAY */ -#line 3273 "MachineIndependent/glslang.y" +#line 3274 "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 10382 "MachineIndependent/glslang_tab.cpp" +#line 10408 "MachineIndependent/glslang_tab.cpp" break; case 490: /* type_specifier_nonarray: IMAGE2DMS */ -#line 3278 "MachineIndependent/glslang.y" +#line 3279 "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 10392 "MachineIndependent/glslang_tab.cpp" +#line 10418 "MachineIndependent/glslang_tab.cpp" break; case 491: /* type_specifier_nonarray: F16IMAGE2DMS */ -#line 3283 "MachineIndependent/glslang.y" +#line 3284 "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 10403 "MachineIndependent/glslang_tab.cpp" +#line 10429 "MachineIndependent/glslang_tab.cpp" break; case 492: /* type_specifier_nonarray: IIMAGE2DMS */ -#line 3289 "MachineIndependent/glslang.y" +#line 3290 "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 10413 "MachineIndependent/glslang_tab.cpp" +#line 10439 "MachineIndependent/glslang_tab.cpp" break; case 493: /* type_specifier_nonarray: UIMAGE2DMS */ -#line 3294 "MachineIndependent/glslang.y" +#line 3295 "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 10423 "MachineIndependent/glslang_tab.cpp" +#line 10449 "MachineIndependent/glslang_tab.cpp" break; case 494: /* type_specifier_nonarray: IMAGE2DMSARRAY */ -#line 3299 "MachineIndependent/glslang.y" +#line 3300 "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 10433 "MachineIndependent/glslang_tab.cpp" +#line 10459 "MachineIndependent/glslang_tab.cpp" break; case 495: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ -#line 3304 "MachineIndependent/glslang.y" +#line 3305 "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 10444 "MachineIndependent/glslang_tab.cpp" +#line 10470 "MachineIndependent/glslang_tab.cpp" break; case 496: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ -#line 3310 "MachineIndependent/glslang.y" +#line 3311 "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 10454 "MachineIndependent/glslang_tab.cpp" +#line 10480 "MachineIndependent/glslang_tab.cpp" break; case 497: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ -#line 3315 "MachineIndependent/glslang.y" +#line 3316 "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 10464 "MachineIndependent/glslang_tab.cpp" +#line 10490 "MachineIndependent/glslang_tab.cpp" break; case 498: /* type_specifier_nonarray: I64IMAGE1D */ -#line 3320 "MachineIndependent/glslang.y" +#line 3321 "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 10474 "MachineIndependent/glslang_tab.cpp" +#line 10500 "MachineIndependent/glslang_tab.cpp" break; case 499: /* type_specifier_nonarray: U64IMAGE1D */ -#line 3325 "MachineIndependent/glslang.y" +#line 3326 "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 10484 "MachineIndependent/glslang_tab.cpp" +#line 10510 "MachineIndependent/glslang_tab.cpp" break; case 500: /* type_specifier_nonarray: I64IMAGE2D */ -#line 3330 "MachineIndependent/glslang.y" +#line 3331 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D); } -#line 10494 "MachineIndependent/glslang_tab.cpp" +#line 10520 "MachineIndependent/glslang_tab.cpp" break; case 501: /* type_specifier_nonarray: U64IMAGE2D */ -#line 3335 "MachineIndependent/glslang.y" +#line 3336 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D); } -#line 10504 "MachineIndependent/glslang_tab.cpp" +#line 10530 "MachineIndependent/glslang_tab.cpp" break; case 502: /* type_specifier_nonarray: I64IMAGE3D */ -#line 3340 "MachineIndependent/glslang.y" +#line 3341 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D); } -#line 10514 "MachineIndependent/glslang_tab.cpp" +#line 10540 "MachineIndependent/glslang_tab.cpp" break; case 503: /* type_specifier_nonarray: U64IMAGE3D */ -#line 3345 "MachineIndependent/glslang.y" +#line 3346 "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 10524 "MachineIndependent/glslang_tab.cpp" +#line 10550 "MachineIndependent/glslang_tab.cpp" break; case 504: /* type_specifier_nonarray: I64IMAGE2DRECT */ -#line 3350 "MachineIndependent/glslang.y" +#line 3351 "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 10534 "MachineIndependent/glslang_tab.cpp" +#line 10560 "MachineIndependent/glslang_tab.cpp" break; case 505: /* type_specifier_nonarray: U64IMAGE2DRECT */ -#line 3355 "MachineIndependent/glslang.y" +#line 3356 "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 10544 "MachineIndependent/glslang_tab.cpp" +#line 10570 "MachineIndependent/glslang_tab.cpp" break; case 506: /* type_specifier_nonarray: I64IMAGECUBE */ -#line 3360 "MachineIndependent/glslang.y" +#line 3361 "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 10554 "MachineIndependent/glslang_tab.cpp" +#line 10580 "MachineIndependent/glslang_tab.cpp" break; case 507: /* type_specifier_nonarray: U64IMAGECUBE */ -#line 3365 "MachineIndependent/glslang.y" +#line 3366 "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 10564 "MachineIndependent/glslang_tab.cpp" +#line 10590 "MachineIndependent/glslang_tab.cpp" break; case 508: /* type_specifier_nonarray: I64IMAGEBUFFER */ -#line 3370 "MachineIndependent/glslang.y" +#line 3371 "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 10574 "MachineIndependent/glslang_tab.cpp" +#line 10600 "MachineIndependent/glslang_tab.cpp" break; case 509: /* type_specifier_nonarray: U64IMAGEBUFFER */ -#line 3375 "MachineIndependent/glslang.y" +#line 3376 "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 10584 "MachineIndependent/glslang_tab.cpp" +#line 10610 "MachineIndependent/glslang_tab.cpp" break; case 510: /* type_specifier_nonarray: I64IMAGE1DARRAY */ -#line 3380 "MachineIndependent/glslang.y" +#line 3381 "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 10594 "MachineIndependent/glslang_tab.cpp" +#line 10620 "MachineIndependent/glslang_tab.cpp" break; case 511: /* type_specifier_nonarray: U64IMAGE1DARRAY */ -#line 3385 "MachineIndependent/glslang.y" +#line 3386 "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 10604 "MachineIndependent/glslang_tab.cpp" +#line 10630 "MachineIndependent/glslang_tab.cpp" break; case 512: /* type_specifier_nonarray: I64IMAGE2DARRAY */ -#line 3390 "MachineIndependent/glslang.y" +#line 3391 "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 10614 "MachineIndependent/glslang_tab.cpp" +#line 10640 "MachineIndependent/glslang_tab.cpp" break; case 513: /* type_specifier_nonarray: U64IMAGE2DARRAY */ -#line 3395 "MachineIndependent/glslang.y" +#line 3396 "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 10624 "MachineIndependent/glslang_tab.cpp" +#line 10650 "MachineIndependent/glslang_tab.cpp" break; case 514: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ -#line 3400 "MachineIndependent/glslang.y" +#line 3401 "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 10634 "MachineIndependent/glslang_tab.cpp" +#line 10660 "MachineIndependent/glslang_tab.cpp" break; case 515: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ -#line 3405 "MachineIndependent/glslang.y" +#line 3406 "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 10644 "MachineIndependent/glslang_tab.cpp" +#line 10670 "MachineIndependent/glslang_tab.cpp" break; case 516: /* type_specifier_nonarray: I64IMAGE2DMS */ -#line 3410 "MachineIndependent/glslang.y" +#line 3411 "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 10654 "MachineIndependent/glslang_tab.cpp" +#line 10680 "MachineIndependent/glslang_tab.cpp" break; case 517: /* type_specifier_nonarray: U64IMAGE2DMS */ -#line 3415 "MachineIndependent/glslang.y" +#line 3416 "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 10664 "MachineIndependent/glslang_tab.cpp" +#line 10690 "MachineIndependent/glslang_tab.cpp" break; case 518: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ -#line 3420 "MachineIndependent/glslang.y" +#line 3421 "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 10674 "MachineIndependent/glslang_tab.cpp" +#line 10700 "MachineIndependent/glslang_tab.cpp" break; case 519: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ -#line 3425 "MachineIndependent/glslang.y" +#line 3426 "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 10684 "MachineIndependent/glslang_tab.cpp" +#line 10710 "MachineIndependent/glslang_tab.cpp" break; case 520: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ -#line 3430 "MachineIndependent/glslang.y" +#line 3431 "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 10695 "MachineIndependent/glslang_tab.cpp" +#line 10721 "MachineIndependent/glslang_tab.cpp" break; case 521: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ -#line 3436 "MachineIndependent/glslang.y" +#line 3437 "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 10706 "MachineIndependent/glslang_tab.cpp" +#line 10732 "MachineIndependent/glslang_tab.cpp" break; case 522: /* type_specifier_nonarray: ATTACHMENTEXT */ -#line 3442 "MachineIndependent/glslang.y" +#line 3443 "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 10717 "MachineIndependent/glslang_tab.cpp" +#line 10743 "MachineIndependent/glslang_tab.cpp" break; case 523: /* type_specifier_nonarray: IATTACHMENTEXT */ -#line 3448 "MachineIndependent/glslang.y" +#line 3449 "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 10728 "MachineIndependent/glslang_tab.cpp" +#line 10754 "MachineIndependent/glslang_tab.cpp" break; case 524: /* type_specifier_nonarray: UATTACHMENTEXT */ -#line 3454 "MachineIndependent/glslang.y" +#line 3455 "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 10739 "MachineIndependent/glslang_tab.cpp" +#line 10765 "MachineIndependent/glslang_tab.cpp" break; case 525: /* type_specifier_nonarray: SUBPASSINPUT */ -#line 3460 "MachineIndependent/glslang.y" +#line 3461 "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 10750 "MachineIndependent/glslang_tab.cpp" +#line 10776 "MachineIndependent/glslang_tab.cpp" break; case 526: /* type_specifier_nonarray: SUBPASSINPUTMS */ -#line 3466 "MachineIndependent/glslang.y" +#line 3467 "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 10761 "MachineIndependent/glslang_tab.cpp" +#line 10787 "MachineIndependent/glslang_tab.cpp" break; case 527: /* type_specifier_nonarray: F16SUBPASSINPUT */ -#line 3472 "MachineIndependent/glslang.y" +#line 3473 "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"); @@ -10769,11 +10795,11 @@ yyreduce: (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16); } -#line 10773 "MachineIndependent/glslang_tab.cpp" +#line 10799 "MachineIndependent/glslang_tab.cpp" break; case 528: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ -#line 3479 "MachineIndependent/glslang.y" +#line 3480 "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"); @@ -10781,55 +10807,55 @@ yyreduce: (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); } -#line 10785 "MachineIndependent/glslang_tab.cpp" +#line 10811 "MachineIndependent/glslang_tab.cpp" break; case 529: /* type_specifier_nonarray: ISUBPASSINPUT */ -#line 3486 "MachineIndependent/glslang.y" +#line 3487 "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 10796 "MachineIndependent/glslang_tab.cpp" +#line 10822 "MachineIndependent/glslang_tab.cpp" break; case 530: /* type_specifier_nonarray: ISUBPASSINPUTMS */ -#line 3492 "MachineIndependent/glslang.y" +#line 3493 "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 10807 "MachineIndependent/glslang_tab.cpp" +#line 10833 "MachineIndependent/glslang_tab.cpp" break; case 531: /* type_specifier_nonarray: USUBPASSINPUT */ -#line 3498 "MachineIndependent/glslang.y" +#line 3499 "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 10818 "MachineIndependent/glslang_tab.cpp" +#line 10844 "MachineIndependent/glslang_tab.cpp" break; case 532: /* type_specifier_nonarray: USUBPASSINPUTMS */ -#line 3504 "MachineIndependent/glslang.y" +#line 3505 "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 10829 "MachineIndependent/glslang_tab.cpp" +#line 10855 "MachineIndependent/glslang_tab.cpp" break; case 533: /* type_specifier_nonarray: FCOOPMATNV */ -#line 3510 "MachineIndependent/glslang.y" +#line 3511 "MachineIndependent/glslang.y" { parseContext.fcoopmatCheckNV((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10837,11 +10863,11 @@ yyreduce: (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10841 "MachineIndependent/glslang_tab.cpp" +#line 10867 "MachineIndependent/glslang_tab.cpp" break; case 534: /* type_specifier_nonarray: ICOOPMATNV */ -#line 3517 "MachineIndependent/glslang.y" +#line 3518 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10849,11 +10875,11 @@ yyreduce: (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10853 "MachineIndependent/glslang_tab.cpp" +#line 10879 "MachineIndependent/glslang_tab.cpp" break; case 535: /* type_specifier_nonarray: UCOOPMATNV */ -#line 3524 "MachineIndependent/glslang.y" +#line 3525 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10861,11 +10887,11 @@ yyreduce: (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10865 "MachineIndependent/glslang_tab.cpp" +#line 10891 "MachineIndependent/glslang_tab.cpp" break; case 536: /* type_specifier_nonarray: COOPMAT */ -#line 3531 "MachineIndependent/glslang.y" +#line 3532 "MachineIndependent/glslang.y" { parseContext.coopmatCheck((yyvsp[0].lex).loc, "coopmat", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10873,39 +10899,68 @@ yyreduce: (yyval.interm.type).coopmatNV = false; (yyval.interm.type).coopmatKHR = true; } -#line 10877 "MachineIndependent/glslang_tab.cpp" +#line 10903 "MachineIndependent/glslang_tab.cpp" break; - case 537: /* type_specifier_nonarray: spirv_type_specifier */ -#line 3538 "MachineIndependent/glslang.y" + case 537: /* type_specifier_nonarray: TENSORLAYOUTNV */ +#line 3539 "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" + break; + + case 538: /* type_specifier_nonarray: TENSORVIEWNV */ +#line 3544 "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" + break; + + case 539: /* type_specifier_nonarray: FUNCTION */ +#line 3549 "MachineIndependent/glslang.y" + { + (yyval.interm.type).init((yyvsp[0].lex).loc); + (yyval.interm.type).basicType = EbtFunction; + } +#line 10932 "MachineIndependent/glslang_tab.cpp" + break; + + case 540: /* type_specifier_nonarray: spirv_type_specifier */ +#line 3553 "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 10886 "MachineIndependent/glslang_tab.cpp" +#line 10941 "MachineIndependent/glslang_tab.cpp" break; - case 538: /* type_specifier_nonarray: HITOBJECTNV */ -#line 3542 "MachineIndependent/glslang.y" + case 541: /* type_specifier_nonarray: HITOBJECTNV */ +#line 3557 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtHitObjectNV; } -#line 10895 "MachineIndependent/glslang_tab.cpp" +#line 10950 "MachineIndependent/glslang_tab.cpp" break; - case 539: /* type_specifier_nonarray: struct_specifier */ -#line 3546 "MachineIndependent/glslang.y" + case 542: /* type_specifier_nonarray: struct_specifier */ +#line 3561 "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 10905 "MachineIndependent/glslang_tab.cpp" +#line 10960 "MachineIndependent/glslang_tab.cpp" break; - case 540: /* type_specifier_nonarray: TYPE_NAME */ -#line 3551 "MachineIndependent/glslang.y" + case 543: /* type_specifier_nonarray: TYPE_NAME */ +#line 3566 "MachineIndependent/glslang.y" { // // This is for user defined type names. The lexical phase looked up the @@ -10919,47 +10974,47 @@ yyreduce: } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 10923 "MachineIndependent/glslang_tab.cpp" +#line 10978 "MachineIndependent/glslang_tab.cpp" break; - case 541: /* precision_qualifier: HIGH_PRECISION */ -#line 3567 "MachineIndependent/glslang.y" + case 544: /* precision_qualifier: HIGH_PRECISION */ +#line 3582 "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 10933 "MachineIndependent/glslang_tab.cpp" +#line 10988 "MachineIndependent/glslang_tab.cpp" break; - case 542: /* precision_qualifier: MEDIUM_PRECISION */ -#line 3572 "MachineIndependent/glslang.y" + case 545: /* precision_qualifier: MEDIUM_PRECISION */ +#line 3587 "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 10943 "MachineIndependent/glslang_tab.cpp" +#line 10998 "MachineIndependent/glslang_tab.cpp" break; - case 543: /* precision_qualifier: LOW_PRECISION */ -#line 3577 "MachineIndependent/glslang.y" + case 546: /* precision_qualifier: LOW_PRECISION */ +#line 3592 "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 10953 "MachineIndependent/glslang_tab.cpp" +#line 11008 "MachineIndependent/glslang_tab.cpp" break; - case 544: /* $@3: %empty */ -#line 3585 "MachineIndependent/glslang.y" + case 547: /* $@3: %empty */ +#line 3600 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 10959 "MachineIndependent/glslang_tab.cpp" +#line 11014 "MachineIndependent/glslang_tab.cpp" break; - case 545: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ -#line 3585 "MachineIndependent/glslang.y" + case 548: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ +#line 3600 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); @@ -10977,17 +11032,17 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 10981 "MachineIndependent/glslang_tab.cpp" +#line 11036 "MachineIndependent/glslang_tab.cpp" break; - case 546: /* $@4: %empty */ -#line 3602 "MachineIndependent/glslang.y" + case 549: /* $@4: %empty */ +#line 3617 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 10987 "MachineIndependent/glslang_tab.cpp" +#line 11042 "MachineIndependent/glslang_tab.cpp" break; - case 547: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ -#line 3602 "MachineIndependent/glslang.y" + case 550: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ +#line 3617 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -10995,19 +11050,19 @@ yyreduce: (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 10999 "MachineIndependent/glslang_tab.cpp" +#line 11054 "MachineIndependent/glslang_tab.cpp" break; - case 548: /* struct_declaration_list: struct_declaration */ -#line 3612 "MachineIndependent/glslang.y" + case 551: /* struct_declaration_list: struct_declaration */ +#line 3627 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11007 "MachineIndependent/glslang_tab.cpp" +#line 11062 "MachineIndependent/glslang_tab.cpp" break; - case 549: /* struct_declaration_list: struct_declaration_list struct_declaration */ -#line 3615 "MachineIndependent/glslang.y" + case 552: /* struct_declaration_list: struct_declaration_list struct_declaration */ +#line 3630 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11018,11 +11073,11 @@ yyreduce: (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11022 "MachineIndependent/glslang_tab.cpp" +#line 11077 "MachineIndependent/glslang_tab.cpp" break; - case 550: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ -#line 3628 "MachineIndependent/glslang.y" + case 553: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ +#line 3643 "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"); @@ -11045,11 +11100,11 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11049 "MachineIndependent/glslang_tab.cpp" +#line 11104 "MachineIndependent/glslang_tab.cpp" break; - case 551: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ -#line 3650 "MachineIndependent/glslang.y" + case 554: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ +#line 3665 "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"); @@ -11074,38 +11129,38 @@ yyreduce: (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11078 "MachineIndependent/glslang_tab.cpp" +#line 11133 "MachineIndependent/glslang_tab.cpp" break; - case 552: /* struct_declarator_list: struct_declarator */ -#line 3677 "MachineIndependent/glslang.y" + case 555: /* struct_declarator_list: struct_declarator */ +#line 3692 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11087 "MachineIndependent/glslang_tab.cpp" +#line 11142 "MachineIndependent/glslang_tab.cpp" break; - case 553: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ -#line 3681 "MachineIndependent/glslang.y" + case 556: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ +#line 3696 "MachineIndependent/glslang.y" { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11095 "MachineIndependent/glslang_tab.cpp" +#line 11150 "MachineIndependent/glslang_tab.cpp" break; - case 554: /* struct_declarator: IDENTIFIER */ -#line 3687 "MachineIndependent/glslang.y" + case 557: /* struct_declarator: IDENTIFIER */ +#line 3702 "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 11105 "MachineIndependent/glslang_tab.cpp" +#line 11160 "MachineIndependent/glslang_tab.cpp" break; - case 555: /* struct_declarator: IDENTIFIER array_specifier */ -#line 3692 "MachineIndependent/glslang.y" + case 558: /* struct_declarator: IDENTIFIER array_specifier */ +#line 3707 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -11114,168 +11169,168 @@ yyreduce: (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 11118 "MachineIndependent/glslang_tab.cpp" +#line 11173 "MachineIndependent/glslang_tab.cpp" break; - case 556: /* initializer: assignment_expression */ -#line 3703 "MachineIndependent/glslang.y" + case 559: /* initializer: assignment_expression */ +#line 3718 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11126 "MachineIndependent/glslang_tab.cpp" +#line 11181 "MachineIndependent/glslang_tab.cpp" break; - case 557: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ -#line 3706 "MachineIndependent/glslang.y" + case 560: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ +#line 3721 "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 11137 "MachineIndependent/glslang_tab.cpp" +#line 11192 "MachineIndependent/glslang_tab.cpp" break; - case 558: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ -#line 3712 "MachineIndependent/glslang.y" + case 561: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ +#line 3727 "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 11148 "MachineIndependent/glslang_tab.cpp" +#line 11203 "MachineIndependent/glslang_tab.cpp" break; - case 559: /* initializer: LEFT_BRACE RIGHT_BRACE */ -#line 3718 "MachineIndependent/glslang.y" + case 562: /* initializer: LEFT_BRACE RIGHT_BRACE */ +#line 3733 "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 11159 "MachineIndependent/glslang_tab.cpp" +#line 11214 "MachineIndependent/glslang_tab.cpp" break; - case 560: /* initializer_list: initializer */ -#line 3727 "MachineIndependent/glslang.y" + case 563: /* initializer_list: initializer */ +#line 3742 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); } -#line 11167 "MachineIndependent/glslang_tab.cpp" +#line 11222 "MachineIndependent/glslang_tab.cpp" break; - case 561: /* initializer_list: initializer_list COMMA initializer */ -#line 3730 "MachineIndependent/glslang.y" + case 564: /* initializer_list: initializer_list COMMA initializer */ +#line 3745 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); } -#line 11175 "MachineIndependent/glslang_tab.cpp" +#line 11230 "MachineIndependent/glslang_tab.cpp" break; - case 562: /* declaration_statement: declaration */ -#line 3736 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11181 "MachineIndependent/glslang_tab.cpp" - break; - - case 563: /* statement: compound_statement */ -#line 3740 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11187 "MachineIndependent/glslang_tab.cpp" - break; - - case 564: /* statement: simple_statement */ -#line 3741 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11193 "MachineIndependent/glslang_tab.cpp" - break; - - case 565: /* simple_statement: declaration_statement */ -#line 3747 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11199 "MachineIndependent/glslang_tab.cpp" - break; - - case 566: /* simple_statement: expression_statement */ -#line 3748 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11205 "MachineIndependent/glslang_tab.cpp" - break; - - case 567: /* simple_statement: selection_statement */ -#line 3749 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11211 "MachineIndependent/glslang_tab.cpp" - break; - - case 568: /* simple_statement: switch_statement */ -#line 3750 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11217 "MachineIndependent/glslang_tab.cpp" - break; - - case 569: /* simple_statement: case_label */ + case 565: /* declaration_statement: declaration */ #line 3751 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11223 "MachineIndependent/glslang_tab.cpp" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11236 "MachineIndependent/glslang_tab.cpp" break; - case 570: /* simple_statement: iteration_statement */ -#line 3752 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11229 "MachineIndependent/glslang_tab.cpp" + case 566: /* statement: compound_statement */ +#line 3755 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11242 "MachineIndependent/glslang_tab.cpp" break; - case 571: /* simple_statement: jump_statement */ -#line 3753 "MachineIndependent/glslang.y" - { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11235 "MachineIndependent/glslang_tab.cpp" + case 567: /* statement: simple_statement */ +#line 3756 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11248 "MachineIndependent/glslang_tab.cpp" break; - case 572: /* simple_statement: demote_statement */ -#line 3754 "MachineIndependent/glslang.y" + case 568: /* simple_statement: declaration_statement */ +#line 3762 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11241 "MachineIndependent/glslang_tab.cpp" +#line 11254 "MachineIndependent/glslang_tab.cpp" break; - case 573: /* demote_statement: DEMOTE SEMICOLON */ -#line 3758 "MachineIndependent/glslang.y" + case 569: /* simple_statement: expression_statement */ +#line 3763 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11260 "MachineIndependent/glslang_tab.cpp" + break; + + case 570: /* simple_statement: selection_statement */ +#line 3764 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11266 "MachineIndependent/glslang_tab.cpp" + break; + + case 571: /* simple_statement: switch_statement */ +#line 3765 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11272 "MachineIndependent/glslang_tab.cpp" + break; + + case 572: /* simple_statement: case_label */ +#line 3766 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11278 "MachineIndependent/glslang_tab.cpp" + break; + + case 573: /* simple_statement: iteration_statement */ +#line 3767 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11284 "MachineIndependent/glslang_tab.cpp" + break; + + case 574: /* simple_statement: jump_statement */ +#line 3768 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11290 "MachineIndependent/glslang_tab.cpp" + break; + + case 575: /* simple_statement: demote_statement */ +#line 3769 "MachineIndependent/glslang.y" + { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } +#line 11296 "MachineIndependent/glslang_tab.cpp" + break; + + case 576: /* demote_statement: DEMOTE SEMICOLON */ +#line 3773 "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 11251 "MachineIndependent/glslang_tab.cpp" +#line 11306 "MachineIndependent/glslang_tab.cpp" break; - case 574: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ -#line 3766 "MachineIndependent/glslang.y" + case 577: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ +#line 3781 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11257 "MachineIndependent/glslang_tab.cpp" +#line 11312 "MachineIndependent/glslang_tab.cpp" break; - case 575: /* $@5: %empty */ -#line 3767 "MachineIndependent/glslang.y" + case 578: /* $@5: %empty */ +#line 3782 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 11266 "MachineIndependent/glslang_tab.cpp" +#line 11321 "MachineIndependent/glslang_tab.cpp" break; - case 576: /* $@6: %empty */ -#line 3771 "MachineIndependent/glslang.y" + case 579: /* $@6: %empty */ +#line 3786 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 11275 "MachineIndependent/glslang_tab.cpp" +#line 11330 "MachineIndependent/glslang_tab.cpp" break; - case 577: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ -#line 3775 "MachineIndependent/glslang.y" + case 580: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ +#line 3790 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) { (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(parseContext.intermediate.getDebugInfo() ? EOpScope : EOpSequence); @@ -11283,69 +11338,69 @@ yyreduce: } (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 11287 "MachineIndependent/glslang_tab.cpp" +#line 11342 "MachineIndependent/glslang_tab.cpp" break; - case 578: /* statement_no_new_scope: compound_statement_no_new_scope */ -#line 3785 "MachineIndependent/glslang.y" + case 581: /* statement_no_new_scope: compound_statement_no_new_scope */ +#line 3800 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11293 "MachineIndependent/glslang_tab.cpp" +#line 11348 "MachineIndependent/glslang_tab.cpp" break; - case 579: /* statement_no_new_scope: simple_statement */ -#line 3786 "MachineIndependent/glslang.y" + case 582: /* statement_no_new_scope: simple_statement */ +#line 3801 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11299 "MachineIndependent/glslang_tab.cpp" +#line 11354 "MachineIndependent/glslang_tab.cpp" break; - case 580: /* $@7: %empty */ -#line 3790 "MachineIndependent/glslang.y" + case 583: /* $@7: %empty */ +#line 3805 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 11307 "MachineIndependent/glslang_tab.cpp" +#line 11362 "MachineIndependent/glslang_tab.cpp" break; - case 581: /* statement_scoped: $@7 compound_statement */ -#line 3793 "MachineIndependent/glslang.y" + case 584: /* statement_scoped: $@7 compound_statement */ +#line 3808 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11316 "MachineIndependent/glslang_tab.cpp" +#line 11371 "MachineIndependent/glslang_tab.cpp" break; - case 582: /* $@8: %empty */ -#line 3797 "MachineIndependent/glslang.y" + case 585: /* $@8: %empty */ +#line 3812 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11326 "MachineIndependent/glslang_tab.cpp" +#line 11381 "MachineIndependent/glslang_tab.cpp" break; - case 583: /* statement_scoped: $@8 simple_statement */ -#line 3802 "MachineIndependent/glslang.y" + case 586: /* statement_scoped: $@8 simple_statement */ +#line 3817 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11337 "MachineIndependent/glslang_tab.cpp" +#line 11392 "MachineIndependent/glslang_tab.cpp" break; - case 584: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ -#line 3811 "MachineIndependent/glslang.y" + case 587: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ +#line 3826 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11345 "MachineIndependent/glslang_tab.cpp" +#line 11400 "MachineIndependent/glslang_tab.cpp" break; - case 585: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ -#line 3814 "MachineIndependent/glslang.y" + case 588: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ +#line 3829 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) { (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -11353,11 +11408,11 @@ yyreduce: } (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 11357 "MachineIndependent/glslang_tab.cpp" +#line 11412 "MachineIndependent/glslang_tab.cpp" break; - case 586: /* statement_list: statement */ -#line 3824 "MachineIndependent/glslang.y" + case 589: /* statement_list: statement */ +#line 3839 "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 || @@ -11366,11 +11421,11 @@ yyreduce: (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 11370 "MachineIndependent/glslang_tab.cpp" +#line 11425 "MachineIndependent/glslang_tab.cpp" break; - case 587: /* statement_list: statement_list statement */ -#line 3832 "MachineIndependent/glslang.y" + case 590: /* statement_list: statement_list statement */ +#line 3847 "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)) { @@ -11379,77 +11434,77 @@ yyreduce: } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 11383 "MachineIndependent/glslang_tab.cpp" +#line 11438 "MachineIndependent/glslang_tab.cpp" break; - case 588: /* expression_statement: SEMICOLON */ -#line 3843 "MachineIndependent/glslang.y" + case 591: /* expression_statement: SEMICOLON */ +#line 3858 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11389 "MachineIndependent/glslang_tab.cpp" +#line 11444 "MachineIndependent/glslang_tab.cpp" break; - case 589: /* expression_statement: expression SEMICOLON */ -#line 3844 "MachineIndependent/glslang.y" + case 592: /* expression_statement: expression SEMICOLON */ +#line 3859 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 11395 "MachineIndependent/glslang_tab.cpp" +#line 11450 "MachineIndependent/glslang_tab.cpp" break; - case 590: /* selection_statement: selection_statement_nonattributed */ -#line 3848 "MachineIndependent/glslang.y" + case 593: /* selection_statement: selection_statement_nonattributed */ +#line 3863 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11403 "MachineIndependent/glslang_tab.cpp" +#line 11458 "MachineIndependent/glslang_tab.cpp" break; - case 591: /* selection_statement: attribute selection_statement_nonattributed */ -#line 3851 "MachineIndependent/glslang.y" + case 594: /* selection_statement: attribute selection_statement_nonattributed */ +#line 3866 "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 11413 "MachineIndependent/glslang_tab.cpp" +#line 11468 "MachineIndependent/glslang_tab.cpp" break; - case 592: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ -#line 3858 "MachineIndependent/glslang.y" + case 595: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ +#line 3873 "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 11422 "MachineIndependent/glslang_tab.cpp" +#line 11477 "MachineIndependent/glslang_tab.cpp" break; - case 593: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ -#line 3865 "MachineIndependent/glslang.y" + case 596: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ +#line 3880 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 11431 "MachineIndependent/glslang_tab.cpp" +#line 11486 "MachineIndependent/glslang_tab.cpp" break; - case 594: /* selection_rest_statement: statement_scoped */ -#line 3869 "MachineIndependent/glslang.y" + case 597: /* selection_rest_statement: statement_scoped */ +#line 3884 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 11440 "MachineIndependent/glslang_tab.cpp" +#line 11495 "MachineIndependent/glslang_tab.cpp" break; - case 595: /* condition: expression */ -#line 3877 "MachineIndependent/glslang.y" + case 598: /* condition: expression */ +#line 3892 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 11449 "MachineIndependent/glslang_tab.cpp" +#line 11504 "MachineIndependent/glslang_tab.cpp" break; - case 596: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 3881 "MachineIndependent/glslang.y" + case 599: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 3896 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -11460,29 +11515,29 @@ yyreduce: else (yyval.interm.intermTypedNode) = 0; } -#line 11464 "MachineIndependent/glslang_tab.cpp" +#line 11519 "MachineIndependent/glslang_tab.cpp" break; - case 597: /* switch_statement: switch_statement_nonattributed */ -#line 3894 "MachineIndependent/glslang.y" + case 600: /* switch_statement: switch_statement_nonattributed */ +#line 3909 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11472 "MachineIndependent/glslang_tab.cpp" +#line 11527 "MachineIndependent/glslang_tab.cpp" break; - case 598: /* switch_statement: attribute switch_statement_nonattributed */ -#line 3897 "MachineIndependent/glslang.y" + case 601: /* switch_statement: attribute switch_statement_nonattributed */ +#line 3912 "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 11482 "MachineIndependent/glslang_tab.cpp" +#line 11537 "MachineIndependent/glslang_tab.cpp" break; - case 599: /* $@9: %empty */ -#line 3904 "MachineIndependent/glslang.y" + case 602: /* $@9: %empty */ +#line 3919 "MachineIndependent/glslang.y" { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -11491,11 +11546,11 @@ yyreduce: parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 11495 "MachineIndependent/glslang_tab.cpp" +#line 11550 "MachineIndependent/glslang_tab.cpp" break; - case 600: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ -#line 3912 "MachineIndependent/glslang.y" + case 603: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ +#line 3927 "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(); @@ -11505,27 +11560,27 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11509 "MachineIndependent/glslang_tab.cpp" +#line 11564 "MachineIndependent/glslang_tab.cpp" break; - case 601: /* switch_statement_list: %empty */ -#line 3924 "MachineIndependent/glslang.y" + case 604: /* switch_statement_list: %empty */ +#line 3939 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11517 "MachineIndependent/glslang_tab.cpp" +#line 11572 "MachineIndependent/glslang_tab.cpp" break; - case 602: /* switch_statement_list: statement_list */ -#line 3927 "MachineIndependent/glslang.y" + case 605: /* switch_statement_list: statement_list */ +#line 3942 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11525 "MachineIndependent/glslang_tab.cpp" +#line 11580 "MachineIndependent/glslang_tab.cpp" break; - case 603: /* case_label: CASE expression COLON */ -#line 3933 "MachineIndependent/glslang.y" + case 606: /* case_label: CASE expression COLON */ +#line 3948 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11538,11 +11593,11 @@ yyreduce: (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 11542 "MachineIndependent/glslang_tab.cpp" +#line 11597 "MachineIndependent/glslang_tab.cpp" break; - case 604: /* case_label: DEFAULT COLON */ -#line 3945 "MachineIndependent/glslang.y" + case 607: /* case_label: DEFAULT COLON */ +#line 3960 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11552,30 +11607,30 @@ yyreduce: else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 11556 "MachineIndependent/glslang_tab.cpp" +#line 11611 "MachineIndependent/glslang_tab.cpp" break; - case 605: /* iteration_statement: iteration_statement_nonattributed */ -#line 3957 "MachineIndependent/glslang.y" + case 608: /* iteration_statement: iteration_statement_nonattributed */ +#line 3972 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11564 "MachineIndependent/glslang_tab.cpp" +#line 11619 "MachineIndependent/glslang_tab.cpp" break; - case 606: /* iteration_statement: attribute iteration_statement_nonattributed */ -#line 3960 "MachineIndependent/glslang.y" + case 609: /* iteration_statement: attribute iteration_statement_nonattributed */ +#line 3975 "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 11575 "MachineIndependent/glslang_tab.cpp" +#line 11630 "MachineIndependent/glslang_tab.cpp" break; - case 607: /* $@10: %empty */ -#line 3968 "MachineIndependent/glslang.y" + case 610: /* $@10: %empty */ +#line 3983 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -11584,11 +11639,11 @@ yyreduce: ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11588 "MachineIndependent/glslang_tab.cpp" +#line 11643 "MachineIndependent/glslang_tab.cpp" break; - case 608: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ -#line 3976 "MachineIndependent/glslang.y" + case 611: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ +#line 3991 "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); @@ -11596,22 +11651,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11600 "MachineIndependent/glslang_tab.cpp" +#line 11655 "MachineIndependent/glslang_tab.cpp" break; - case 609: /* $@11: %empty */ -#line 3983 "MachineIndependent/glslang.y" + case 612: /* $@11: %empty */ +#line 3998 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11611 "MachineIndependent/glslang_tab.cpp" +#line 11666 "MachineIndependent/glslang_tab.cpp" break; - case 610: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ -#line 3989 "MachineIndependent/glslang.y" + case 613: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ +#line 4004 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -11624,22 +11679,22 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11628 "MachineIndependent/glslang_tab.cpp" +#line 11683 "MachineIndependent/glslang_tab.cpp" break; - case 611: /* $@12: %empty */ -#line 4001 "MachineIndependent/glslang.y" + case 614: /* $@12: %empty */ +#line 4016 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11639 "MachineIndependent/glslang_tab.cpp" +#line 11694 "MachineIndependent/glslang_tab.cpp" break; - case 612: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ -#line 4007 "MachineIndependent/glslang.y" + 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" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -11652,81 +11707,81 @@ yyreduce: --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11656 "MachineIndependent/glslang_tab.cpp" +#line 11711 "MachineIndependent/glslang_tab.cpp" break; - case 613: /* for_init_statement: expression_statement */ -#line 4022 "MachineIndependent/glslang.y" + case 616: /* for_init_statement: expression_statement */ +#line 4037 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11664 "MachineIndependent/glslang_tab.cpp" +#line 11719 "MachineIndependent/glslang_tab.cpp" break; - case 614: /* for_init_statement: declaration_statement */ -#line 4025 "MachineIndependent/glslang.y" + case 617: /* for_init_statement: declaration_statement */ +#line 4040 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11672 "MachineIndependent/glslang_tab.cpp" +#line 11727 "MachineIndependent/glslang_tab.cpp" break; - case 615: /* conditionopt: condition */ -#line 4031 "MachineIndependent/glslang.y" + case 618: /* conditionopt: condition */ +#line 4046 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11680 "MachineIndependent/glslang_tab.cpp" +#line 11735 "MachineIndependent/glslang_tab.cpp" break; - case 616: /* conditionopt: %empty */ -#line 4034 "MachineIndependent/glslang.y" + case 619: /* conditionopt: %empty */ +#line 4049 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = 0; } -#line 11688 "MachineIndependent/glslang_tab.cpp" +#line 11743 "MachineIndependent/glslang_tab.cpp" break; - case 617: /* for_rest_statement: conditionopt SEMICOLON */ -#line 4040 "MachineIndependent/glslang.y" + case 620: /* for_rest_statement: conditionopt SEMICOLON */ +#line 4055 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 11697 "MachineIndependent/glslang_tab.cpp" +#line 11752 "MachineIndependent/glslang_tab.cpp" break; - case 618: /* for_rest_statement: conditionopt SEMICOLON expression */ -#line 4044 "MachineIndependent/glslang.y" + case 621: /* for_rest_statement: conditionopt SEMICOLON expression */ +#line 4059 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 11706 "MachineIndependent/glslang_tab.cpp" +#line 11761 "MachineIndependent/glslang_tab.cpp" break; - case 619: /* jump_statement: CONTINUE SEMICOLON */ -#line 4051 "MachineIndependent/glslang.y" + case 622: /* jump_statement: CONTINUE SEMICOLON */ +#line 4066 "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 11716 "MachineIndependent/glslang_tab.cpp" +#line 11771 "MachineIndependent/glslang_tab.cpp" break; - case 620: /* jump_statement: BREAK SEMICOLON */ -#line 4056 "MachineIndependent/glslang.y" + case 623: /* jump_statement: BREAK SEMICOLON */ +#line 4071 "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 11726 "MachineIndependent/glslang_tab.cpp" +#line 11781 "MachineIndependent/glslang_tab.cpp" break; - case 621: /* jump_statement: RETURN SEMICOLON */ -#line 4061 "MachineIndependent/glslang.y" + case 624: /* jump_statement: RETURN SEMICOLON */ +#line 4076 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -11734,101 +11789,101 @@ yyreduce: if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 11738 "MachineIndependent/glslang_tab.cpp" +#line 11793 "MachineIndependent/glslang_tab.cpp" break; - case 622: /* jump_statement: RETURN expression SEMICOLON */ -#line 4068 "MachineIndependent/glslang.y" + case 625: /* jump_statement: RETURN expression SEMICOLON */ +#line 4083 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 11746 "MachineIndependent/glslang_tab.cpp" +#line 11801 "MachineIndependent/glslang_tab.cpp" break; - case 623: /* jump_statement: DISCARD SEMICOLON */ -#line 4071 "MachineIndependent/glslang.y" + case 626: /* jump_statement: DISCARD SEMICOLON */ +#line 4086 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 11755 "MachineIndependent/glslang_tab.cpp" +#line 11810 "MachineIndependent/glslang_tab.cpp" break; - case 624: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ -#line 4075 "MachineIndependent/glslang.y" + case 627: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ +#line 4090 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc); } -#line 11764 "MachineIndependent/glslang_tab.cpp" +#line 11819 "MachineIndependent/glslang_tab.cpp" break; - case 625: /* jump_statement: TERMINATE_RAY SEMICOLON */ -#line 4079 "MachineIndependent/glslang.y" + case 628: /* jump_statement: TERMINATE_RAY SEMICOLON */ +#line 4094 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc); } -#line 11773 "MachineIndependent/glslang_tab.cpp" +#line 11828 "MachineIndependent/glslang_tab.cpp" break; - case 626: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ -#line 4083 "MachineIndependent/glslang.y" + case 629: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ +#line 4098 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc); } -#line 11782 "MachineIndependent/glslang_tab.cpp" +#line 11837 "MachineIndependent/glslang_tab.cpp" break; - case 627: /* translation_unit: external_declaration */ -#line 4092 "MachineIndependent/glslang.y" + case 630: /* translation_unit: external_declaration */ +#line 4107 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 11791 "MachineIndependent/glslang_tab.cpp" +#line 11846 "MachineIndependent/glslang_tab.cpp" break; - case 628: /* translation_unit: translation_unit external_declaration */ -#line 4096 "MachineIndependent/glslang.y" + case 631: /* translation_unit: translation_unit external_declaration */ +#line 4111 "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 11802 "MachineIndependent/glslang_tab.cpp" +#line 11857 "MachineIndependent/glslang_tab.cpp" break; - case 629: /* external_declaration: function_definition */ -#line 4105 "MachineIndependent/glslang.y" + case 632: /* external_declaration: function_definition */ +#line 4120 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11810 "MachineIndependent/glslang_tab.cpp" +#line 11865 "MachineIndependent/glslang_tab.cpp" break; - case 630: /* external_declaration: declaration */ -#line 4108 "MachineIndependent/glslang.y" + case 633: /* external_declaration: declaration */ +#line 4123 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11818 "MachineIndependent/glslang_tab.cpp" +#line 11873 "MachineIndependent/glslang_tab.cpp" break; - case 631: /* external_declaration: SEMICOLON */ -#line 4111 "MachineIndependent/glslang.y" + case 634: /* external_declaration: SEMICOLON */ +#line 4126 "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 11828 "MachineIndependent/glslang_tab.cpp" +#line 11883 "MachineIndependent/glslang_tab.cpp" break; - case 632: /* $@13: %empty */ -#line 4119 "MachineIndependent/glslang.y" + case 635: /* $@13: %empty */ +#line 4134 "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); @@ -11841,11 +11896,11 @@ yyreduce: ++parseContext.statementNestingLevel; } } -#line 11845 "MachineIndependent/glslang_tab.cpp" +#line 11900 "MachineIndependent/glslang_tab.cpp" break; - case 633: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ -#line 4131 "MachineIndependent/glslang.y" + case 636: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ +#line 4146 "MachineIndependent/glslang.y" { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -11873,228 +11928,228 @@ yyreduce: --parseContext.statementNestingLevel; } } -#line 11877 "MachineIndependent/glslang_tab.cpp" +#line 11932 "MachineIndependent/glslang_tab.cpp" break; - case 634: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ -#line 4161 "MachineIndependent/glslang.y" + case 637: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ +#line 4176 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); } -#line 11885 "MachineIndependent/glslang_tab.cpp" +#line 11940 "MachineIndependent/glslang_tab.cpp" break; - case 635: /* attribute_list: single_attribute */ -#line 4166 "MachineIndependent/glslang.y" + case 638: /* attribute_list: single_attribute */ +#line 4181 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 11893 "MachineIndependent/glslang_tab.cpp" +#line 11948 "MachineIndependent/glslang_tab.cpp" break; - case 636: /* attribute_list: attribute_list COMMA single_attribute */ -#line 4169 "MachineIndependent/glslang.y" + case 639: /* attribute_list: attribute_list COMMA single_attribute */ +#line 4184 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 11901 "MachineIndependent/glslang_tab.cpp" +#line 11956 "MachineIndependent/glslang_tab.cpp" break; - case 637: /* single_attribute: IDENTIFIER */ -#line 4174 "MachineIndependent/glslang.y" + case 640: /* single_attribute: IDENTIFIER */ +#line 4189 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 11909 "MachineIndependent/glslang_tab.cpp" +#line 11964 "MachineIndependent/glslang_tab.cpp" break; - case 638: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ -#line 4177 "MachineIndependent/glslang.y" + case 641: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ +#line 4192 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 11917 "MachineIndependent/glslang_tab.cpp" +#line 11972 "MachineIndependent/glslang_tab.cpp" break; - case 639: /* spirv_requirements_list: spirv_requirements_parameter */ -#line 4182 "MachineIndependent/glslang.y" + case 642: /* spirv_requirements_list: spirv_requirements_parameter */ +#line 4197 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq); } -#line 11925 "MachineIndependent/glslang_tab.cpp" +#line 11980 "MachineIndependent/glslang_tab.cpp" break; - case 640: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ -#line 4185 "MachineIndependent/glslang.y" + case 643: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ +#line 4200 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq)); } -#line 11933 "MachineIndependent/glslang_tab.cpp" +#line 11988 "MachineIndependent/glslang_tab.cpp" break; - case 641: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ -#line 4190 "MachineIndependent/glslang.y" + case 644: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ +#line 4205 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr); } -#line 11941 "MachineIndependent/glslang_tab.cpp" +#line 11996 "MachineIndependent/glslang_tab.cpp" break; - case 642: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ -#line 4193 "MachineIndependent/glslang.y" + case 645: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ +#line 4208 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 11949 "MachineIndependent/glslang_tab.cpp" +#line 12004 "MachineIndependent/glslang_tab.cpp" break; - case 643: /* spirv_extension_list: STRING_LITERAL */ -#line 4198 "MachineIndependent/glslang.y" + case 646: /* spirv_extension_list: STRING_LITERAL */ +#line 4213 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 11957 "MachineIndependent/glslang_tab.cpp" +#line 12012 "MachineIndependent/glslang_tab.cpp" break; - case 644: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ -#line 4201 "MachineIndependent/glslang.y" + case 647: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ +#line 4216 "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 11965 "MachineIndependent/glslang_tab.cpp" +#line 12020 "MachineIndependent/glslang_tab.cpp" break; - case 645: /* spirv_capability_list: INTCONSTANT */ -#line 4206 "MachineIndependent/glslang.y" + case 648: /* spirv_capability_list: INTCONSTANT */ +#line 4221 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 11973 "MachineIndependent/glslang_tab.cpp" +#line 12028 "MachineIndependent/glslang_tab.cpp" break; - case 646: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ -#line 4209 "MachineIndependent/glslang.y" + case 649: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ +#line 4224 "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 11981 "MachineIndependent/glslang_tab.cpp" +#line 12036 "MachineIndependent/glslang_tab.cpp" break; - case 647: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4214 "MachineIndependent/glslang.y" + case 650: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4229 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 11990 "MachineIndependent/glslang_tab.cpp" +#line 12045 "MachineIndependent/glslang_tab.cpp" break; - case 648: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4218 "MachineIndependent/glslang.y" + case 651: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4233 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12000 "MachineIndependent/glslang_tab.cpp" +#line 12055 "MachineIndependent/glslang_tab.cpp" break; - case 649: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4223 "MachineIndependent/glslang.y" + 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" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12009 "MachineIndependent/glslang_tab.cpp" +#line 12064 "MachineIndependent/glslang_tab.cpp" break; - case 650: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4227 "MachineIndependent/glslang.y" + 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" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12019 "MachineIndependent/glslang_tab.cpp" +#line 12074 "MachineIndependent/glslang_tab.cpp" break; - case 651: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4232 "MachineIndependent/glslang.y" + 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" { parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12028 "MachineIndependent/glslang_tab.cpp" +#line 12083 "MachineIndependent/glslang_tab.cpp" break; - case 652: /* 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 4236 "MachineIndependent/glslang.y" + 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" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12038 "MachineIndependent/glslang_tab.cpp" +#line 12093 "MachineIndependent/glslang_tab.cpp" break; - case 653: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ -#line 4243 "MachineIndependent/glslang.y" + case 656: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ +#line 4258 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12046 "MachineIndependent/glslang_tab.cpp" +#line 12101 "MachineIndependent/glslang_tab.cpp" break; - case 654: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ -#line 4246 "MachineIndependent/glslang.y" + case 657: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ +#line 4261 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12054 "MachineIndependent/glslang_tab.cpp" +#line 12109 "MachineIndependent/glslang_tab.cpp" break; - case 655: /* spirv_execution_mode_parameter: FLOATCONSTANT */ -#line 4251 "MachineIndependent/glslang.y" + case 658: /* spirv_execution_mode_parameter: FLOATCONSTANT */ +#line 4266 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12062 "MachineIndependent/glslang_tab.cpp" +#line 12117 "MachineIndependent/glslang_tab.cpp" break; - case 656: /* spirv_execution_mode_parameter: INTCONSTANT */ -#line 4254 "MachineIndependent/glslang.y" + case 659: /* spirv_execution_mode_parameter: INTCONSTANT */ +#line 4269 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12070 "MachineIndependent/glslang_tab.cpp" +#line 12125 "MachineIndependent/glslang_tab.cpp" break; - case 657: /* spirv_execution_mode_parameter: UINTCONSTANT */ -#line 4257 "MachineIndependent/glslang.y" + case 660: /* spirv_execution_mode_parameter: UINTCONSTANT */ +#line 4272 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12078 "MachineIndependent/glslang_tab.cpp" +#line 12133 "MachineIndependent/glslang_tab.cpp" break; - case 658: /* spirv_execution_mode_parameter: BOOLCONSTANT */ -#line 4260 "MachineIndependent/glslang.y" + case 661: /* spirv_execution_mode_parameter: BOOLCONSTANT */ +#line 4275 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12086 "MachineIndependent/glslang_tab.cpp" +#line 12141 "MachineIndependent/glslang_tab.cpp" break; - case 659: /* spirv_execution_mode_parameter: STRING_LITERAL */ -#line 4263 "MachineIndependent/glslang.y" + case 662: /* spirv_execution_mode_parameter: STRING_LITERAL */ +#line 4278 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 12094 "MachineIndependent/glslang_tab.cpp" +#line 12149 "MachineIndependent/glslang_tab.cpp" break; - case 660: /* spirv_execution_mode_id_parameter_list: constant_expression */ -#line 4268 "MachineIndependent/glslang.y" + case 663: /* spirv_execution_mode_id_parameter_list: constant_expression */ +#line 4283 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12104,11 +12159,11 @@ yyreduce: parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode)); } -#line 12108 "MachineIndependent/glslang_tab.cpp" +#line 12163 "MachineIndependent/glslang_tab.cpp" break; - case 661: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ -#line 4277 "MachineIndependent/glslang.y" + case 664: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ +#line 4292 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12118,351 +12173,351 @@ yyreduce: parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode)); } -#line 12122 "MachineIndependent/glslang_tab.cpp" +#line 12177 "MachineIndependent/glslang_tab.cpp" break; - case 662: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4288 "MachineIndependent/glslang.y" + case 665: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4303 "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 12132 "MachineIndependent/glslang_tab.cpp" +#line 12187 "MachineIndependent/glslang_tab.cpp" break; - case 663: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4293 "MachineIndependent/glslang.y" + case 666: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4308 "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 12143 "MachineIndependent/glslang_tab.cpp" +#line 12198 "MachineIndependent/glslang_tab.cpp" break; - case 664: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4301 "MachineIndependent/glslang.y" + case 667: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4316 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12152 "MachineIndependent/glslang_tab.cpp" +#line 12207 "MachineIndependent/glslang_tab.cpp" break; - case 665: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4305 "MachineIndependent/glslang.y" + case 668: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4320 "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 12162 "MachineIndependent/glslang_tab.cpp" +#line 12217 "MachineIndependent/glslang_tab.cpp" break; - case 666: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4310 "MachineIndependent/glslang.y" + case 669: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4325 "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 12171 "MachineIndependent/glslang_tab.cpp" +#line 12226 "MachineIndependent/glslang_tab.cpp" break; - case 667: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4314 "MachineIndependent/glslang.y" + 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" { (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 12181 "MachineIndependent/glslang_tab.cpp" +#line 12236 "MachineIndependent/glslang_tab.cpp" break; - case 668: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4319 "MachineIndependent/glslang.y" + case 671: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4334 "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 12190 "MachineIndependent/glslang_tab.cpp" +#line 12245 "MachineIndependent/glslang_tab.cpp" break; - case 669: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4323 "MachineIndependent/glslang.y" + 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" { (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 12200 "MachineIndependent/glslang_tab.cpp" +#line 12255 "MachineIndependent/glslang_tab.cpp" break; - case 670: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4328 "MachineIndependent/glslang.y" + case 673: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4343 "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 12209 "MachineIndependent/glslang_tab.cpp" +#line 12264 "MachineIndependent/glslang_tab.cpp" break; - case 671: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4332 "MachineIndependent/glslang.y" + 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" { (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 12219 "MachineIndependent/glslang_tab.cpp" +#line 12274 "MachineIndependent/glslang_tab.cpp" break; - case 672: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ -#line 4339 "MachineIndependent/glslang.y" + case 675: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ +#line 4354 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12227 "MachineIndependent/glslang_tab.cpp" +#line 12282 "MachineIndependent/glslang_tab.cpp" break; - case 673: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ -#line 4342 "MachineIndependent/glslang.y" + case 676: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ +#line 4357 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12235 "MachineIndependent/glslang_tab.cpp" +#line 12290 "MachineIndependent/glslang_tab.cpp" break; - case 674: /* spirv_decorate_parameter: FLOATCONSTANT */ -#line 4347 "MachineIndependent/glslang.y" + case 677: /* spirv_decorate_parameter: FLOATCONSTANT */ +#line 4362 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12243 "MachineIndependent/glslang_tab.cpp" +#line 12298 "MachineIndependent/glslang_tab.cpp" break; - case 675: /* spirv_decorate_parameter: INTCONSTANT */ -#line 4350 "MachineIndependent/glslang.y" + case 678: /* spirv_decorate_parameter: INTCONSTANT */ +#line 4365 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12251 "MachineIndependent/glslang_tab.cpp" +#line 12306 "MachineIndependent/glslang_tab.cpp" break; - case 676: /* spirv_decorate_parameter: UINTCONSTANT */ -#line 4353 "MachineIndependent/glslang.y" + case 679: /* spirv_decorate_parameter: UINTCONSTANT */ +#line 4368 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12259 "MachineIndependent/glslang_tab.cpp" +#line 12314 "MachineIndependent/glslang_tab.cpp" break; - case 677: /* spirv_decorate_parameter: BOOLCONSTANT */ -#line 4356 "MachineIndependent/glslang.y" + case 680: /* spirv_decorate_parameter: BOOLCONSTANT */ +#line 4371 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12267 "MachineIndependent/glslang_tab.cpp" +#line 12322 "MachineIndependent/glslang_tab.cpp" break; - case 678: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ -#line 4361 "MachineIndependent/glslang.y" + case 681: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ +#line 4376 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12275 "MachineIndependent/glslang_tab.cpp" +#line 12330 "MachineIndependent/glslang_tab.cpp" break; - case 679: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ -#line 4364 "MachineIndependent/glslang.y" + case 682: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ +#line 4379 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12283 "MachineIndependent/glslang_tab.cpp" +#line 12338 "MachineIndependent/glslang_tab.cpp" break; - case 680: /* spirv_decorate_id_parameter: variable_identifier */ -#line 4369 "MachineIndependent/glslang.y" + case 683: /* spirv_decorate_id_parameter: variable_identifier */ +#line 4384 "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 12294 "MachineIndependent/glslang_tab.cpp" +#line 12349 "MachineIndependent/glslang_tab.cpp" break; - case 681: /* spirv_decorate_id_parameter: FLOATCONSTANT */ -#line 4375 "MachineIndependent/glslang.y" + case 684: /* spirv_decorate_id_parameter: FLOATCONSTANT */ +#line 4390 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12302 "MachineIndependent/glslang_tab.cpp" +#line 12357 "MachineIndependent/glslang_tab.cpp" break; - case 682: /* spirv_decorate_id_parameter: INTCONSTANT */ -#line 4378 "MachineIndependent/glslang.y" + case 685: /* spirv_decorate_id_parameter: INTCONSTANT */ +#line 4393 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12310 "MachineIndependent/glslang_tab.cpp" +#line 12365 "MachineIndependent/glslang_tab.cpp" break; - case 683: /* spirv_decorate_id_parameter: UINTCONSTANT */ -#line 4381 "MachineIndependent/glslang.y" + case 686: /* spirv_decorate_id_parameter: UINTCONSTANT */ +#line 4396 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12318 "MachineIndependent/glslang_tab.cpp" +#line 12373 "MachineIndependent/glslang_tab.cpp" break; - case 684: /* spirv_decorate_id_parameter: BOOLCONSTANT */ -#line 4384 "MachineIndependent/glslang.y" + case 687: /* spirv_decorate_id_parameter: BOOLCONSTANT */ +#line 4399 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12326 "MachineIndependent/glslang_tab.cpp" +#line 12381 "MachineIndependent/glslang_tab.cpp" break; - case 685: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ -#line 4389 "MachineIndependent/glslang.y" + case 688: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ +#line 4404 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate( parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12335 "MachineIndependent/glslang_tab.cpp" +#line 12390 "MachineIndependent/glslang_tab.cpp" break; - case 686: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ -#line 4393 "MachineIndependent/glslang.y" + case 689: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ +#line 4408 "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 12343 "MachineIndependent/glslang_tab.cpp" +#line 12398 "MachineIndependent/glslang_tab.cpp" break; - case 687: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4398 "MachineIndependent/glslang.y" + 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" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12352 "MachineIndependent/glslang_tab.cpp" +#line 12407 "MachineIndependent/glslang_tab.cpp" break; - case 688: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4402 "MachineIndependent/glslang.y" + 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" { (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 12362 "MachineIndependent/glslang_tab.cpp" +#line 12417 "MachineIndependent/glslang_tab.cpp" break; - case 689: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4407 "MachineIndependent/glslang.y" + case 692: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4422 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 12371 "MachineIndependent/glslang_tab.cpp" +#line 12426 "MachineIndependent/glslang_tab.cpp" break; - case 690: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4411 "MachineIndependent/glslang.y" + case 693: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4426 "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 12381 "MachineIndependent/glslang_tab.cpp" +#line 12436 "MachineIndependent/glslang_tab.cpp" break; - case 691: /* spirv_type_parameter_list: spirv_type_parameter */ -#line 4418 "MachineIndependent/glslang.y" + case 694: /* spirv_type_parameter_list: spirv_type_parameter */ +#line 4433 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams); } -#line 12389 "MachineIndependent/glslang_tab.cpp" +#line 12444 "MachineIndependent/glslang_tab.cpp" break; - case 692: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ -#line 4421 "MachineIndependent/glslang.y" + case 695: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ +#line 4436 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams)); } -#line 12397 "MachineIndependent/glslang_tab.cpp" +#line 12452 "MachineIndependent/glslang_tab.cpp" break; - case 693: /* spirv_type_parameter: constant_expression */ -#line 4426 "MachineIndependent/glslang.y" + case 696: /* spirv_type_parameter: constant_expression */ +#line 4441 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion()); } -#line 12405 "MachineIndependent/glslang_tab.cpp" +#line 12460 "MachineIndependent/glslang_tab.cpp" break; - case 694: /* spirv_type_parameter: type_specifier_nonarray */ -#line 4429 "MachineIndependent/glslang.y" + case 697: /* spirv_type_parameter: type_specifier_nonarray */ +#line 4444 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 12413 "MachineIndependent/glslang_tab.cpp" +#line 12468 "MachineIndependent/glslang_tab.cpp" break; - case 695: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4434 "MachineIndependent/glslang.y" + case 698: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4449 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12421 "MachineIndependent/glslang_tab.cpp" +#line 12476 "MachineIndependent/glslang_tab.cpp" break; - case 696: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4437 "MachineIndependent/glslang.y" + case 699: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4452 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12430 "MachineIndependent/glslang_tab.cpp" +#line 12485 "MachineIndependent/glslang_tab.cpp" break; - case 697: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ -#line 4443 "MachineIndependent/glslang.y" + case 700: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ +#line 4458 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst); } -#line 12438 "MachineIndependent/glslang_tab.cpp" +#line 12493 "MachineIndependent/glslang_tab.cpp" break; - case 698: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ -#line 4446 "MachineIndependent/glslang.y" + case 701: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ +#line 4461 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst)); } -#line 12446 "MachineIndependent/glslang_tab.cpp" +#line 12501 "MachineIndependent/glslang_tab.cpp" break; - case 699: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ -#line 4451 "MachineIndependent/glslang.y" + case 702: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ +#line 4466 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string); } -#line 12454 "MachineIndependent/glslang_tab.cpp" +#line 12509 "MachineIndependent/glslang_tab.cpp" break; - case 700: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ -#line 4454 "MachineIndependent/glslang.y" + case 703: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ +#line 4469 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i); } -#line 12462 "MachineIndependent/glslang_tab.cpp" +#line 12517 "MachineIndependent/glslang_tab.cpp" break; -#line 12466 "MachineIndependent/glslang_tab.cpp" +#line 12521 "MachineIndependent/glslang_tab.cpp" default: break; } @@ -12686,5 +12741,5 @@ yyreturnlab: return yyresult; } -#line 4458 "MachineIndependent/glslang.y" +#line 4473 "MachineIndependent/glslang.y" diff --git a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h index d6484924d..7fcfe3e89 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h @@ -220,302 +220,305 @@ extern int yydebug; COOPMAT = 421, /* COOPMAT */ HITOBJECTNV = 422, /* HITOBJECTNV */ HITOBJECTATTRNV = 423, /* HITOBJECTATTRNV */ - SAMPLERCUBEARRAY = 424, /* SAMPLERCUBEARRAY */ - SAMPLERCUBEARRAYSHADOW = 425, /* SAMPLERCUBEARRAYSHADOW */ - ISAMPLERCUBEARRAY = 426, /* ISAMPLERCUBEARRAY */ - USAMPLERCUBEARRAY = 427, /* USAMPLERCUBEARRAY */ - SAMPLER1D = 428, /* SAMPLER1D */ - SAMPLER1DARRAY = 429, /* SAMPLER1DARRAY */ - SAMPLER1DARRAYSHADOW = 430, /* SAMPLER1DARRAYSHADOW */ - ISAMPLER1D = 431, /* ISAMPLER1D */ - SAMPLER1DSHADOW = 432, /* SAMPLER1DSHADOW */ - SAMPLER2DRECT = 433, /* SAMPLER2DRECT */ - SAMPLER2DRECTSHADOW = 434, /* SAMPLER2DRECTSHADOW */ - ISAMPLER2DRECT = 435, /* ISAMPLER2DRECT */ - USAMPLER2DRECT = 436, /* USAMPLER2DRECT */ - SAMPLERBUFFER = 437, /* SAMPLERBUFFER */ - ISAMPLERBUFFER = 438, /* ISAMPLERBUFFER */ - USAMPLERBUFFER = 439, /* USAMPLERBUFFER */ - SAMPLER2DMS = 440, /* SAMPLER2DMS */ - ISAMPLER2DMS = 441, /* ISAMPLER2DMS */ - USAMPLER2DMS = 442, /* USAMPLER2DMS */ - SAMPLER2DMSARRAY = 443, /* SAMPLER2DMSARRAY */ - ISAMPLER2DMSARRAY = 444, /* ISAMPLER2DMSARRAY */ - USAMPLER2DMSARRAY = 445, /* USAMPLER2DMSARRAY */ - SAMPLEREXTERNALOES = 446, /* SAMPLEREXTERNALOES */ - SAMPLEREXTERNAL2DY2YEXT = 447, /* SAMPLEREXTERNAL2DY2YEXT */ - ISAMPLER1DARRAY = 448, /* ISAMPLER1DARRAY */ - USAMPLER1D = 449, /* USAMPLER1D */ - USAMPLER1DARRAY = 450, /* USAMPLER1DARRAY */ - F16SAMPLER1D = 451, /* F16SAMPLER1D */ - F16SAMPLER2D = 452, /* F16SAMPLER2D */ - F16SAMPLER3D = 453, /* F16SAMPLER3D */ - F16SAMPLER2DRECT = 454, /* F16SAMPLER2DRECT */ - F16SAMPLERCUBE = 455, /* F16SAMPLERCUBE */ - F16SAMPLER1DARRAY = 456, /* F16SAMPLER1DARRAY */ - F16SAMPLER2DARRAY = 457, /* F16SAMPLER2DARRAY */ - F16SAMPLERCUBEARRAY = 458, /* F16SAMPLERCUBEARRAY */ - F16SAMPLERBUFFER = 459, /* F16SAMPLERBUFFER */ - F16SAMPLER2DMS = 460, /* F16SAMPLER2DMS */ - F16SAMPLER2DMSARRAY = 461, /* F16SAMPLER2DMSARRAY */ - F16SAMPLER1DSHADOW = 462, /* F16SAMPLER1DSHADOW */ - F16SAMPLER2DSHADOW = 463, /* F16SAMPLER2DSHADOW */ - F16SAMPLER1DARRAYSHADOW = 464, /* F16SAMPLER1DARRAYSHADOW */ - F16SAMPLER2DARRAYSHADOW = 465, /* F16SAMPLER2DARRAYSHADOW */ - F16SAMPLER2DRECTSHADOW = 466, /* F16SAMPLER2DRECTSHADOW */ - F16SAMPLERCUBESHADOW = 467, /* F16SAMPLERCUBESHADOW */ - F16SAMPLERCUBEARRAYSHADOW = 468, /* F16SAMPLERCUBEARRAYSHADOW */ - IMAGE1D = 469, /* IMAGE1D */ - IIMAGE1D = 470, /* IIMAGE1D */ - UIMAGE1D = 471, /* UIMAGE1D */ - IMAGE2D = 472, /* IMAGE2D */ - IIMAGE2D = 473, /* IIMAGE2D */ - UIMAGE2D = 474, /* UIMAGE2D */ - IMAGE3D = 475, /* IMAGE3D */ - IIMAGE3D = 476, /* IIMAGE3D */ - UIMAGE3D = 477, /* UIMAGE3D */ - IMAGE2DRECT = 478, /* IMAGE2DRECT */ - IIMAGE2DRECT = 479, /* IIMAGE2DRECT */ - UIMAGE2DRECT = 480, /* UIMAGE2DRECT */ - IMAGECUBE = 481, /* IMAGECUBE */ - IIMAGECUBE = 482, /* IIMAGECUBE */ - UIMAGECUBE = 483, /* UIMAGECUBE */ - IMAGEBUFFER = 484, /* IMAGEBUFFER */ - IIMAGEBUFFER = 485, /* IIMAGEBUFFER */ - UIMAGEBUFFER = 486, /* UIMAGEBUFFER */ - IMAGE1DARRAY = 487, /* IMAGE1DARRAY */ - IIMAGE1DARRAY = 488, /* IIMAGE1DARRAY */ - UIMAGE1DARRAY = 489, /* UIMAGE1DARRAY */ - IMAGE2DARRAY = 490, /* IMAGE2DARRAY */ - IIMAGE2DARRAY = 491, /* IIMAGE2DARRAY */ - UIMAGE2DARRAY = 492, /* UIMAGE2DARRAY */ - IMAGECUBEARRAY = 493, /* IMAGECUBEARRAY */ - IIMAGECUBEARRAY = 494, /* IIMAGECUBEARRAY */ - UIMAGECUBEARRAY = 495, /* UIMAGECUBEARRAY */ - IMAGE2DMS = 496, /* IMAGE2DMS */ - IIMAGE2DMS = 497, /* IIMAGE2DMS */ - UIMAGE2DMS = 498, /* UIMAGE2DMS */ - IMAGE2DMSARRAY = 499, /* IMAGE2DMSARRAY */ - IIMAGE2DMSARRAY = 500, /* IIMAGE2DMSARRAY */ - UIMAGE2DMSARRAY = 501, /* UIMAGE2DMSARRAY */ - F16IMAGE1D = 502, /* F16IMAGE1D */ - F16IMAGE2D = 503, /* F16IMAGE2D */ - F16IMAGE3D = 504, /* F16IMAGE3D */ - F16IMAGE2DRECT = 505, /* F16IMAGE2DRECT */ - F16IMAGECUBE = 506, /* F16IMAGECUBE */ - F16IMAGE1DARRAY = 507, /* F16IMAGE1DARRAY */ - F16IMAGE2DARRAY = 508, /* F16IMAGE2DARRAY */ - F16IMAGECUBEARRAY = 509, /* F16IMAGECUBEARRAY */ - F16IMAGEBUFFER = 510, /* F16IMAGEBUFFER */ - F16IMAGE2DMS = 511, /* F16IMAGE2DMS */ - F16IMAGE2DMSARRAY = 512, /* F16IMAGE2DMSARRAY */ - I64IMAGE1D = 513, /* I64IMAGE1D */ - U64IMAGE1D = 514, /* U64IMAGE1D */ - I64IMAGE2D = 515, /* I64IMAGE2D */ - U64IMAGE2D = 516, /* U64IMAGE2D */ - I64IMAGE3D = 517, /* I64IMAGE3D */ - U64IMAGE3D = 518, /* U64IMAGE3D */ - I64IMAGE2DRECT = 519, /* I64IMAGE2DRECT */ - U64IMAGE2DRECT = 520, /* U64IMAGE2DRECT */ - I64IMAGECUBE = 521, /* I64IMAGECUBE */ - U64IMAGECUBE = 522, /* U64IMAGECUBE */ - I64IMAGEBUFFER = 523, /* I64IMAGEBUFFER */ - U64IMAGEBUFFER = 524, /* U64IMAGEBUFFER */ - I64IMAGE1DARRAY = 525, /* I64IMAGE1DARRAY */ - U64IMAGE1DARRAY = 526, /* U64IMAGE1DARRAY */ - I64IMAGE2DARRAY = 527, /* I64IMAGE2DARRAY */ - U64IMAGE2DARRAY = 528, /* U64IMAGE2DARRAY */ - I64IMAGECUBEARRAY = 529, /* I64IMAGECUBEARRAY */ - U64IMAGECUBEARRAY = 530, /* U64IMAGECUBEARRAY */ - I64IMAGE2DMS = 531, /* I64IMAGE2DMS */ - U64IMAGE2DMS = 532, /* U64IMAGE2DMS */ - I64IMAGE2DMSARRAY = 533, /* I64IMAGE2DMSARRAY */ - U64IMAGE2DMSARRAY = 534, /* U64IMAGE2DMSARRAY */ - TEXTURECUBEARRAY = 535, /* TEXTURECUBEARRAY */ - ITEXTURECUBEARRAY = 536, /* ITEXTURECUBEARRAY */ - UTEXTURECUBEARRAY = 537, /* UTEXTURECUBEARRAY */ - TEXTURE1D = 538, /* TEXTURE1D */ - ITEXTURE1D = 539, /* ITEXTURE1D */ - UTEXTURE1D = 540, /* UTEXTURE1D */ - TEXTURE1DARRAY = 541, /* TEXTURE1DARRAY */ - ITEXTURE1DARRAY = 542, /* ITEXTURE1DARRAY */ - UTEXTURE1DARRAY = 543, /* UTEXTURE1DARRAY */ - TEXTURE2DRECT = 544, /* TEXTURE2DRECT */ - ITEXTURE2DRECT = 545, /* ITEXTURE2DRECT */ - UTEXTURE2DRECT = 546, /* UTEXTURE2DRECT */ - TEXTUREBUFFER = 547, /* TEXTUREBUFFER */ - ITEXTUREBUFFER = 548, /* ITEXTUREBUFFER */ - UTEXTUREBUFFER = 549, /* UTEXTUREBUFFER */ - TEXTURE2DMS = 550, /* TEXTURE2DMS */ - ITEXTURE2DMS = 551, /* ITEXTURE2DMS */ - UTEXTURE2DMS = 552, /* UTEXTURE2DMS */ - TEXTURE2DMSARRAY = 553, /* TEXTURE2DMSARRAY */ - ITEXTURE2DMSARRAY = 554, /* ITEXTURE2DMSARRAY */ - UTEXTURE2DMSARRAY = 555, /* UTEXTURE2DMSARRAY */ - F16TEXTURE1D = 556, /* F16TEXTURE1D */ - F16TEXTURE2D = 557, /* F16TEXTURE2D */ - F16TEXTURE3D = 558, /* F16TEXTURE3D */ - F16TEXTURE2DRECT = 559, /* F16TEXTURE2DRECT */ - F16TEXTURECUBE = 560, /* F16TEXTURECUBE */ - F16TEXTURE1DARRAY = 561, /* F16TEXTURE1DARRAY */ - F16TEXTURE2DARRAY = 562, /* F16TEXTURE2DARRAY */ - F16TEXTURECUBEARRAY = 563, /* F16TEXTURECUBEARRAY */ - F16TEXTUREBUFFER = 564, /* F16TEXTUREBUFFER */ - F16TEXTURE2DMS = 565, /* F16TEXTURE2DMS */ - F16TEXTURE2DMSARRAY = 566, /* F16TEXTURE2DMSARRAY */ - SUBPASSINPUT = 567, /* SUBPASSINPUT */ - SUBPASSINPUTMS = 568, /* SUBPASSINPUTMS */ - ISUBPASSINPUT = 569, /* ISUBPASSINPUT */ - ISUBPASSINPUTMS = 570, /* ISUBPASSINPUTMS */ - USUBPASSINPUT = 571, /* USUBPASSINPUT */ - USUBPASSINPUTMS = 572, /* USUBPASSINPUTMS */ - F16SUBPASSINPUT = 573, /* F16SUBPASSINPUT */ - F16SUBPASSINPUTMS = 574, /* F16SUBPASSINPUTMS */ - SPIRV_INSTRUCTION = 575, /* SPIRV_INSTRUCTION */ - SPIRV_EXECUTION_MODE = 576, /* SPIRV_EXECUTION_MODE */ - SPIRV_EXECUTION_MODE_ID = 577, /* SPIRV_EXECUTION_MODE_ID */ - SPIRV_DECORATE = 578, /* SPIRV_DECORATE */ - SPIRV_DECORATE_ID = 579, /* SPIRV_DECORATE_ID */ - SPIRV_DECORATE_STRING = 580, /* SPIRV_DECORATE_STRING */ - SPIRV_TYPE = 581, /* SPIRV_TYPE */ - SPIRV_STORAGE_CLASS = 582, /* SPIRV_STORAGE_CLASS */ - SPIRV_BY_REFERENCE = 583, /* SPIRV_BY_REFERENCE */ - SPIRV_LITERAL = 584, /* SPIRV_LITERAL */ - ATTACHMENTEXT = 585, /* ATTACHMENTEXT */ - IATTACHMENTEXT = 586, /* IATTACHMENTEXT */ - UATTACHMENTEXT = 587, /* UATTACHMENTEXT */ - LEFT_OP = 588, /* LEFT_OP */ - RIGHT_OP = 589, /* RIGHT_OP */ - INC_OP = 590, /* INC_OP */ - DEC_OP = 591, /* DEC_OP */ - LE_OP = 592, /* LE_OP */ - GE_OP = 593, /* GE_OP */ - EQ_OP = 594, /* EQ_OP */ - NE_OP = 595, /* NE_OP */ - AND_OP = 596, /* AND_OP */ - OR_OP = 597, /* OR_OP */ - XOR_OP = 598, /* XOR_OP */ - MUL_ASSIGN = 599, /* MUL_ASSIGN */ - DIV_ASSIGN = 600, /* DIV_ASSIGN */ - ADD_ASSIGN = 601, /* ADD_ASSIGN */ - MOD_ASSIGN = 602, /* MOD_ASSIGN */ - LEFT_ASSIGN = 603, /* LEFT_ASSIGN */ - RIGHT_ASSIGN = 604, /* RIGHT_ASSIGN */ - AND_ASSIGN = 605, /* AND_ASSIGN */ - XOR_ASSIGN = 606, /* XOR_ASSIGN */ - OR_ASSIGN = 607, /* OR_ASSIGN */ - SUB_ASSIGN = 608, /* SUB_ASSIGN */ - STRING_LITERAL = 609, /* STRING_LITERAL */ - LEFT_PAREN = 610, /* LEFT_PAREN */ - RIGHT_PAREN = 611, /* RIGHT_PAREN */ - LEFT_BRACKET = 612, /* LEFT_BRACKET */ - RIGHT_BRACKET = 613, /* RIGHT_BRACKET */ - LEFT_BRACE = 614, /* LEFT_BRACE */ - RIGHT_BRACE = 615, /* RIGHT_BRACE */ - DOT = 616, /* DOT */ - COMMA = 617, /* COMMA */ - COLON = 618, /* COLON */ - EQUAL = 619, /* EQUAL */ - SEMICOLON = 620, /* SEMICOLON */ - BANG = 621, /* BANG */ - DASH = 622, /* DASH */ - TILDE = 623, /* TILDE */ - PLUS = 624, /* PLUS */ - STAR = 625, /* STAR */ - SLASH = 626, /* SLASH */ - PERCENT = 627, /* PERCENT */ - LEFT_ANGLE = 628, /* LEFT_ANGLE */ - RIGHT_ANGLE = 629, /* RIGHT_ANGLE */ - VERTICAL_BAR = 630, /* VERTICAL_BAR */ - CARET = 631, /* CARET */ - AMPERSAND = 632, /* AMPERSAND */ - QUESTION = 633, /* QUESTION */ - INVARIANT = 634, /* INVARIANT */ - HIGH_PRECISION = 635, /* HIGH_PRECISION */ - MEDIUM_PRECISION = 636, /* MEDIUM_PRECISION */ - LOW_PRECISION = 637, /* LOW_PRECISION */ - PRECISION = 638, /* PRECISION */ - PACKED = 639, /* PACKED */ - RESOURCE = 640, /* RESOURCE */ - SUPERP = 641, /* SUPERP */ - FLOATCONSTANT = 642, /* FLOATCONSTANT */ - INTCONSTANT = 643, /* INTCONSTANT */ - UINTCONSTANT = 644, /* UINTCONSTANT */ - BOOLCONSTANT = 645, /* BOOLCONSTANT */ - IDENTIFIER = 646, /* IDENTIFIER */ - TYPE_NAME = 647, /* TYPE_NAME */ - CENTROID = 648, /* CENTROID */ - IN = 649, /* IN */ - OUT = 650, /* OUT */ - INOUT = 651, /* INOUT */ - STRUCT = 652, /* STRUCT */ - VOID = 653, /* VOID */ - WHILE = 654, /* WHILE */ - BREAK = 655, /* BREAK */ - CONTINUE = 656, /* CONTINUE */ - DO = 657, /* DO */ - ELSE = 658, /* ELSE */ - FOR = 659, /* FOR */ - IF = 660, /* IF */ - DISCARD = 661, /* DISCARD */ - RETURN = 662, /* RETURN */ - SWITCH = 663, /* SWITCH */ - CASE = 664, /* CASE */ - DEFAULT = 665, /* DEFAULT */ - TERMINATE_INVOCATION = 666, /* TERMINATE_INVOCATION */ - TERMINATE_RAY = 667, /* TERMINATE_RAY */ - IGNORE_INTERSECTION = 668, /* IGNORE_INTERSECTION */ - UNIFORM = 669, /* UNIFORM */ - SHARED = 670, /* SHARED */ - BUFFER = 671, /* BUFFER */ - TILEIMAGEEXT = 672, /* TILEIMAGEEXT */ - FLAT = 673, /* FLAT */ - SMOOTH = 674, /* SMOOTH */ - LAYOUT = 675, /* LAYOUT */ - DOUBLECONSTANT = 676, /* DOUBLECONSTANT */ - INT16CONSTANT = 677, /* INT16CONSTANT */ - UINT16CONSTANT = 678, /* UINT16CONSTANT */ - FLOAT16CONSTANT = 679, /* FLOAT16CONSTANT */ - INT32CONSTANT = 680, /* INT32CONSTANT */ - UINT32CONSTANT = 681, /* UINT32CONSTANT */ - INT64CONSTANT = 682, /* INT64CONSTANT */ - UINT64CONSTANT = 683, /* UINT64CONSTANT */ - SUBROUTINE = 684, /* SUBROUTINE */ - DEMOTE = 685, /* DEMOTE */ - PAYLOADNV = 686, /* PAYLOADNV */ - PAYLOADINNV = 687, /* PAYLOADINNV */ - HITATTRNV = 688, /* HITATTRNV */ - CALLDATANV = 689, /* CALLDATANV */ - CALLDATAINNV = 690, /* CALLDATAINNV */ - PAYLOADEXT = 691, /* PAYLOADEXT */ - PAYLOADINEXT = 692, /* PAYLOADINEXT */ - HITATTREXT = 693, /* HITATTREXT */ - CALLDATAEXT = 694, /* CALLDATAEXT */ - CALLDATAINEXT = 695, /* CALLDATAINEXT */ - PATCH = 696, /* PATCH */ - SAMPLE = 697, /* SAMPLE */ - NONUNIFORM = 698, /* NONUNIFORM */ - COHERENT = 699, /* COHERENT */ - VOLATILE = 700, /* VOLATILE */ - RESTRICT = 701, /* RESTRICT */ - READONLY = 702, /* READONLY */ - WRITEONLY = 703, /* WRITEONLY */ - DEVICECOHERENT = 704, /* DEVICECOHERENT */ - QUEUEFAMILYCOHERENT = 705, /* QUEUEFAMILYCOHERENT */ - WORKGROUPCOHERENT = 706, /* WORKGROUPCOHERENT */ - SUBGROUPCOHERENT = 707, /* SUBGROUPCOHERENT */ - NONPRIVATE = 708, /* NONPRIVATE */ - SHADERCALLCOHERENT = 709, /* SHADERCALLCOHERENT */ - NOPERSPECTIVE = 710, /* NOPERSPECTIVE */ - EXPLICITINTERPAMD = 711, /* EXPLICITINTERPAMD */ - PERVERTEXEXT = 712, /* PERVERTEXEXT */ - PERVERTEXNV = 713, /* PERVERTEXNV */ - PERPRIMITIVENV = 714, /* PERPRIMITIVENV */ - PERVIEWNV = 715, /* PERVIEWNV */ - PERTASKNV = 716, /* PERTASKNV */ - PERPRIMITIVEEXT = 717, /* PERPRIMITIVEEXT */ - TASKPAYLOADWORKGROUPEXT = 718, /* TASKPAYLOADWORKGROUPEXT */ - PRECISE = 719 /* PRECISE */ + 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 */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -563,7 +566,7 @@ union YYSTYPE glslang::TTypeParameters* typeParameters; } interm; -#line 567 "MachineIndependent/glslang_tab.cpp.h" +#line 570 "MachineIndependent/glslang_tab.cpp.h" }; typedef union YYSTYPE YYSTYPE; diff --git a/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp b/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp index f0621bd9e..ccfff38c4 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp @@ -204,6 +204,13 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) OutputTreeText(out, node, depth); + if (IsOpNumericConv(node->getAsOperator()->getOp())) { + out.debug << "Convert " << TType::getBasicString(node->getOperand()->getType().getBasicType()) << " to " << TType::getBasicString(node->getType().getBasicType()); + out.debug << " (" << node->getCompleteString() << ")"; + out.debug << "\n"; + return true; + } + switch (node->getOp()) { case EOpNegative: out.debug << "Negate value"; break; case EOpVectorLogicalNot: @@ -216,192 +223,6 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpPreDecrement: out.debug << "Pre-Decrement"; break; case EOpCopyObject: out.debug << "copy object"; break; - // * -> bool - case EOpConvInt8ToBool: out.debug << "Convert int8_t to bool"; break; - case EOpConvUint8ToBool: out.debug << "Convert uint8_t to bool"; break; - case EOpConvInt16ToBool: out.debug << "Convert int16_t to bool"; break; - case EOpConvUint16ToBool: out.debug << "Convert uint16_t to bool";break; - case EOpConvIntToBool: out.debug << "Convert int to bool"; break; - case EOpConvUintToBool: out.debug << "Convert uint to bool"; break; - case EOpConvInt64ToBool: out.debug << "Convert int64 to bool"; break; - case EOpConvUint64ToBool: out.debug << "Convert uint64 to bool"; break; - case EOpConvFloat16ToBool: out.debug << "Convert float16_t to bool"; break; - case EOpConvFloatToBool: out.debug << "Convert float to bool"; break; - case EOpConvDoubleToBool: out.debug << "Convert double to bool"; break; - - // bool -> * - case EOpConvBoolToInt8: out.debug << "Convert bool to int8_t"; break; - case EOpConvBoolToUint8: out.debug << "Convert bool to uint8_t"; break; - case EOpConvBoolToInt16: out.debug << "Convert bool to in16t_t"; break; - case EOpConvBoolToUint16: out.debug << "Convert bool to uint16_t";break; - case EOpConvBoolToInt: out.debug << "Convert bool to int" ; break; - case EOpConvBoolToUint: out.debug << "Convert bool to uint"; break; - case EOpConvBoolToInt64: out.debug << "Convert bool to int64"; break; - case EOpConvBoolToUint64: out.debug << "Convert bool to uint64";break; - case EOpConvBoolToFloat16: out.debug << "Convert bool to float16_t"; break; - case EOpConvBoolToFloat: out.debug << "Convert bool to float"; break; - case EOpConvBoolToDouble: out.debug << "Convert bool to double"; break; - - // int8_t -> (u)int* - case EOpConvInt8ToInt16: out.debug << "Convert int8_t to int16_t";break; - case EOpConvInt8ToInt: out.debug << "Convert int8_t to int"; break; - case EOpConvInt8ToInt64: out.debug << "Convert int8_t to int64"; break; - case EOpConvInt8ToUint8: out.debug << "Convert int8_t to uint8_t";break; - case EOpConvInt8ToUint16: out.debug << "Convert int8_t to uint16_t";break; - case EOpConvInt8ToUint: out.debug << "Convert int8_t to uint"; break; - case EOpConvInt8ToUint64: out.debug << "Convert int8_t to uint64"; break; - - // uint8_t -> (u)int* - case EOpConvUint8ToInt8: out.debug << "Convert uint8_t to int8_t";break; - case EOpConvUint8ToInt16: out.debug << "Convert uint8_t to int16_t";break; - case EOpConvUint8ToInt: out.debug << "Convert uint8_t to int"; break; - case EOpConvUint8ToInt64: out.debug << "Convert uint8_t to int64"; break; - case EOpConvUint8ToUint16: out.debug << "Convert uint8_t to uint16_t";break; - case EOpConvUint8ToUint: out.debug << "Convert uint8_t to uint"; break; - case EOpConvUint8ToUint64: out.debug << "Convert uint8_t to uint64"; break; - - // int8_t -> float* - case EOpConvInt8ToFloat16: out.debug << "Convert int8_t to float16_t";break; - case EOpConvInt8ToFloat: out.debug << "Convert int8_t to float"; break; - case EOpConvInt8ToDouble: out.debug << "Convert int8_t to double"; break; - - // uint8_t -> float* - case EOpConvUint8ToFloat16: out.debug << "Convert uint8_t to float16_t";break; - case EOpConvUint8ToFloat: out.debug << "Convert uint8_t to float"; break; - case EOpConvUint8ToDouble: out.debug << "Convert uint8_t to double"; break; - - // int16_t -> (u)int* - case EOpConvInt16ToInt8: out.debug << "Convert int16_t to int8_t";break; - case EOpConvInt16ToInt: out.debug << "Convert int16_t to int"; break; - case EOpConvInt16ToInt64: out.debug << "Convert int16_t to int64"; break; - case EOpConvInt16ToUint8: out.debug << "Convert int16_t to uint8_t";break; - case EOpConvInt16ToUint16: out.debug << "Convert int16_t to uint16_t";break; - case EOpConvInt16ToUint: out.debug << "Convert int16_t to uint"; break; - case EOpConvInt16ToUint64: out.debug << "Convert int16_t to uint64"; break; - - // int16_t -> float* - case EOpConvInt16ToFloat16: out.debug << "Convert int16_t to float16_t";break; - case EOpConvInt16ToFloat: out.debug << "Convert int16_t to float"; break; - case EOpConvInt16ToDouble: out.debug << "Convert int16_t to double"; break; - - // uint16_t -> (u)int* - case EOpConvUint16ToInt8: out.debug << "Convert uint16_t to int8_t";break; - case EOpConvUint16ToInt16: out.debug << "Convert uint16_t to int16_t";break; - case EOpConvUint16ToInt: out.debug << "Convert uint16_t to int"; break; - case EOpConvUint16ToInt64: out.debug << "Convert uint16_t to int64"; break; - case EOpConvUint16ToUint8: out.debug << "Convert uint16_t to uint8_t";break; - case EOpConvUint16ToUint: out.debug << "Convert uint16_t to uint"; break; - case EOpConvUint16ToUint64: out.debug << "Convert uint16_t to uint64"; break; - - // uint16_t -> float* - case EOpConvUint16ToFloat16: out.debug << "Convert uint16_t to float16_t";break; - case EOpConvUint16ToFloat: out.debug << "Convert uint16_t to float"; break; - case EOpConvUint16ToDouble: out.debug << "Convert uint16_t to double"; break; - - // int32_t -> (u)int* - case EOpConvIntToInt8: out.debug << "Convert int to int8_t";break; - case EOpConvIntToInt16: out.debug << "Convert int to int16_t";break; - case EOpConvIntToInt64: out.debug << "Convert int to int64"; break; - case EOpConvIntToUint8: out.debug << "Convert int to uint8_t";break; - case EOpConvIntToUint16: out.debug << "Convert int to uint16_t";break; - case EOpConvIntToUint: out.debug << "Convert int to uint"; break; - case EOpConvIntToUint64: out.debug << "Convert int to uint64"; break; - - // int32_t -> float* - case EOpConvIntToFloat16: out.debug << "Convert int to float16_t";break; - case EOpConvIntToFloat: out.debug << "Convert int to float"; break; - case EOpConvIntToDouble: out.debug << "Convert int to double"; break; - - // uint32_t -> (u)int* - case EOpConvUintToInt8: out.debug << "Convert uint to int8_t";break; - case EOpConvUintToInt16: out.debug << "Convert uint to int16_t";break; - case EOpConvUintToInt: out.debug << "Convert uint to int";break; - case EOpConvUintToInt64: out.debug << "Convert uint to int64"; break; - case EOpConvUintToUint8: out.debug << "Convert uint to uint8_t";break; - case EOpConvUintToUint16: out.debug << "Convert uint to uint16_t";break; - case EOpConvUintToUint64: out.debug << "Convert uint to uint64"; break; - - // uint32_t -> float* - case EOpConvUintToFloat16: out.debug << "Convert uint to float16_t";break; - case EOpConvUintToFloat: out.debug << "Convert uint to float"; break; - case EOpConvUintToDouble: out.debug << "Convert uint to double"; break; - - // int64 -> (u)int* - case EOpConvInt64ToInt8: out.debug << "Convert int64 to int8_t"; break; - case EOpConvInt64ToInt16: out.debug << "Convert int64 to int16_t"; break; - case EOpConvInt64ToInt: out.debug << "Convert int64 to int"; break; - case EOpConvInt64ToUint8: out.debug << "Convert int64 to uint8_t";break; - case EOpConvInt64ToUint16: out.debug << "Convert int64 to uint16_t";break; - case EOpConvInt64ToUint: out.debug << "Convert int64 to uint"; break; - case EOpConvInt64ToUint64: out.debug << "Convert int64 to uint64"; break; - - // int64 -> float* - case EOpConvInt64ToFloat16: out.debug << "Convert int64 to float16_t";break; - case EOpConvInt64ToFloat: out.debug << "Convert int64 to float"; break; - case EOpConvInt64ToDouble: out.debug << "Convert int64 to double"; break; - - // uint64 -> (u)int* - case EOpConvUint64ToInt8: out.debug << "Convert uint64 to int8_t";break; - case EOpConvUint64ToInt16: out.debug << "Convert uint64 to int16_t";break; - case EOpConvUint64ToInt: out.debug << "Convert uint64 to int"; break; - case EOpConvUint64ToInt64: out.debug << "Convert uint64 to int64"; break; - case EOpConvUint64ToUint8: out.debug << "Convert uint64 to uint8_t";break; - case EOpConvUint64ToUint16: out.debug << "Convert uint64 to uint16"; break; - case EOpConvUint64ToUint: out.debug << "Convert uint64 to uint"; break; - - // uint64 -> float* - case EOpConvUint64ToFloat16: out.debug << "Convert uint64 to float16_t";break; - case EOpConvUint64ToFloat: out.debug << "Convert uint64 to float"; break; - case EOpConvUint64ToDouble: out.debug << "Convert uint64 to double"; break; - - // float16_t -> int* - case EOpConvFloat16ToInt8: out.debug << "Convert float16_t to int8_t"; break; - case EOpConvFloat16ToInt16: out.debug << "Convert float16_t to int16_t"; break; - case EOpConvFloat16ToInt: out.debug << "Convert float16_t to int"; break; - case EOpConvFloat16ToInt64: out.debug << "Convert float16_t to int64"; break; - - // float16_t -> uint* - case EOpConvFloat16ToUint8: out.debug << "Convert float16_t to uint8_t"; break; - case EOpConvFloat16ToUint16: out.debug << "Convert float16_t to uint16_t"; break; - case EOpConvFloat16ToUint: out.debug << "Convert float16_t to uint"; break; - case EOpConvFloat16ToUint64: out.debug << "Convert float16_t to uint64"; break; - - // float16_t -> float* - case EOpConvFloat16ToFloat: out.debug << "Convert float16_t to float"; break; - case EOpConvFloat16ToDouble: out.debug << "Convert float16_t to double"; break; - - // float32 -> float* - case EOpConvFloatToFloat16: out.debug << "Convert float to float16_t"; break; - case EOpConvFloatToDouble: out.debug << "Convert float to double"; break; - - // float32_t -> int* - case EOpConvFloatToInt8: out.debug << "Convert float to int8_t"; break; - case EOpConvFloatToInt16: out.debug << "Convert float to int16_t"; break; - case EOpConvFloatToInt: out.debug << "Convert float to int"; break; - case EOpConvFloatToInt64: out.debug << "Convert float to int64"; break; - - // float32_t -> uint* - case EOpConvFloatToUint8: out.debug << "Convert float to uint8_t"; break; - case EOpConvFloatToUint16: out.debug << "Convert float to uint16_t"; break; - case EOpConvFloatToUint: out.debug << "Convert float to uint"; break; - case EOpConvFloatToUint64: out.debug << "Convert float to uint64"; break; - - // double -> float* - case EOpConvDoubleToFloat16: out.debug << "Convert double to float16_t"; break; - case EOpConvDoubleToFloat: out.debug << "Convert double to float"; break; - - // double -> int* - case EOpConvDoubleToInt8: out.debug << "Convert double to int8_t"; break; - case EOpConvDoubleToInt16: out.debug << "Convert double to int16_t"; break; - case EOpConvDoubleToInt: out.debug << "Convert double to int"; break; - case EOpConvDoubleToInt64: out.debug << "Convert double to int64"; break; - - // float32_t -> uint* - case EOpConvDoubleToUint8: out.debug << "Convert double to uint8_t"; break; - case EOpConvDoubleToUint16: out.debug << "Convert double to uint16_t"; break; - case EOpConvDoubleToUint: out.debug << "Convert double to uint"; break; - case EOpConvDoubleToUint64: out.debug << "Convert double to uint64"; break; - case EOpConvUint64ToPtr: out.debug << "Convert uint64_t to pointer"; break; case EOpConvPtrToUint64: out.debug << "Convert pointer to uint64_t"; break; @@ -673,6 +494,17 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node) case EOpSpirvInst: out.debug << "spirv_instruction"; break; + case EOpCreateTensorLayoutNV: out.debug << "createTensorLayoutNV"; break; + case EOpTensorLayoutSetBlockSizeNV: out.debug << "setTensorLayoutBlockSizeNV"; break; + case EOpTensorLayoutSetDimensionNV: out.debug << "setTensorLayoutDimensionNV"; break; + case EOpTensorLayoutSetStrideNV: out.debug << "setTensorLayoutStrideNV"; break; + case EOpTensorLayoutSliceNV: out.debug << "sliceTensorLayoutNV"; break; + case EOpTensorLayoutSetClampValueNV: out.debug << "setTensorLayoutClampValueNV"; break; + case EOpCreateTensorViewNV: out.debug << "createTensorViewNV"; break; + case EOpTensorViewSetDimensionNV: out.debug << "setTensorViewDimensionsNV"; break; + case EOpTensorViewSetStrideNV: out.debug << "setTensorViewStrideNV"; break; + case EOpTensorViewSetClipNV: out.debug << "setTensorViewClipNV"; break; + default: out.debug.message(EPrefixError, "Bad unary op"); } @@ -1113,7 +945,12 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices KHR"; break; case EOpCooperativeMatrixLoadNV: out.debug << "Load cooperative matrix NV"; break; case EOpCooperativeMatrixStoreNV: out.debug << "Store cooperative matrix NV"; break; + case EOpCooperativeMatrixLoadTensorNV: out.debug << "Load cooperative matrix tensor NV"; break; + case EOpCooperativeMatrixStoreTensorNV: out.debug << "Store cooperative matrix tensor NV"; break; case EOpCooperativeMatrixMulAddNV: out.debug << "MulAdd cooperative matrices NV"; break; + case EOpCooperativeMatrixReduceNV: out.debug << "Reduce cooperative matrices"; break; + case EOpCooperativeMatrixPerElementOpNV: out.debug << "cooperative matrix per element op"; break; + case EOpCooperativeMatrixTransposeNV: out.debug << "Transpose cooperative matrix"; break; case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break; case EOpDebugPrintf: out.debug << "Debug printf"; break; @@ -1156,6 +993,17 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpStencilAttachmentReadEXT: out.debug << "stencilAttachmentReadEXT"; break; case EOpDepthAttachmentReadEXT: out.debug << "depthAttachmentReadEXT"; break; + case EOpCreateTensorLayoutNV: out.debug << "createTensorLayout"; break; + case EOpTensorLayoutSetBlockSizeNV: out.debug << "setBlockSize"; break; + case EOpTensorLayoutSetDimensionNV: out.debug << "setDimension"; break; + case EOpTensorLayoutSetStrideNV: out.debug << "setStride"; break; + case EOpTensorLayoutSliceNV: out.debug << "slice"; break; + case EOpTensorLayoutSetClampValueNV: out.debug << "setClampValue"; break; + case EOpCreateTensorViewNV: out.debug << "createTensorView"; break; + case EOpTensorViewSetDimensionNV: out.debug << "setTensorViewDimensions"; break; + case EOpTensorViewSetStrideNV: out.debug << "setTensorViewStride"; break; + case EOpTensorViewSetClipNV: out.debug << "clipTensorView"; break; + default: out.debug.message(EPrefixError, "Bad aggregation op"); } diff --git a/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp b/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp index 3e7749d3a..26c3eaa62 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp @@ -65,7 +65,7 @@ struct TVarEntryInfo { long long id; TIntermSymbol* symbol; bool live; - bool upgradedToPushConstant; + TLayoutPacking upgradedToPushConstantPacking; // ElpNone means it hasn't been upgraded int newBinding; int newSet; int newLocation; @@ -74,7 +74,7 @@ struct TVarEntryInfo { EShLanguage stage; void clearNewAssignments() { - upgradedToPushConstant = false; + upgradedToPushConstantPacking = ElpNone; newBinding = -1; newSet = -1; newLocation = -1; @@ -246,8 +246,11 @@ public: base->getWritableType().getQualifier().layoutComponent = at->second.newComponent; if (at->second.newIndex != -1) base->getWritableType().getQualifier().layoutIndex = at->second.newIndex; - if (at->second.upgradedToPushConstant) + if (at->second.upgradedToPushConstantPacking != ElpNone) { base->getWritableType().getQualifier().layoutPushConstant = true; + base->getWritableType().getQualifier().setBlockStorage(EbsPushConstant); + base->getWritableType().getQualifier().layoutPacking = at->second.upgradedToPushConstantPacking; + } } private: @@ -1810,7 +1813,8 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) { std::for_each(uniformVector.begin(), uniformVector.end(), [this](TVarLivePair& p) { if (p.first == autoPushConstantBlockName) { - p.second.upgradedToPushConstant = true; + p.second.upgradedToPushConstantPacking = autoPushConstantBlockPacking; + p.second.newSet = TQualifier::layoutSetEnd; } }); } @@ -1823,8 +1827,8 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) { std::for_each(uniformVector.begin(), uniformVector.end(), [pUniformVarMap, stage](TVarLivePair p) { auto at = pUniformVarMap[stage]->find(p.second.symbol->getAccessName()); if (at != pUniformVarMap[stage]->end() && at->second.id == p.second.id){ - if (p.second.upgradedToPushConstant) { - at->second.upgradedToPushConstant = true; + if (p.second.upgradedToPushConstantPacking != ElpNone) { + at->second.upgradedToPushConstantPacking = p.second.upgradedToPushConstantPacking; } else { int resolvedBinding = at->second.newBinding; at->second = p.second; diff --git a/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp b/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp index b0c27e84e..584cc8a9f 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp +++ b/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp @@ -46,6 +46,7 @@ // even if no merging was done (i.e., the stage was only one compilation unit). // +#include "glslang/Public/ShaderLang.h" #include "localintermediate.h" #include "../Include/InfoSink.h" #include "SymbolTable.h" @@ -59,10 +60,12 @@ namespace glslang { void TIntermediate::error(TInfoSink& infoSink, const char* message, EShLanguage unitStage) { infoSink.info.prefix(EPrefixError); - if (unitStage < EShLangCount) - infoSink.info << "Linking " << StageName(getStage()) << " and " << StageName(unitStage) << " stages: " << message << "\n"; - else + if (unitStage == EShLangCount) infoSink.info << "Linking " << StageName(language) << " stage: " << message << "\n"; + else if (language == EShLangCount) + infoSink.info << "Linking " << StageName(unitStage) << " stage: " << message << "\n"; + else + infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n"; ++numErrors; } @@ -71,10 +74,12 @@ void TIntermediate::error(TInfoSink& infoSink, const char* message, EShLanguage void TIntermediate::warn(TInfoSink& infoSink, const char* message, EShLanguage unitStage) { infoSink.info.prefix(EPrefixWarning); - if (unitStage < EShLangCount) - infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n"; - else + if (unitStage == EShLangCount) infoSink.info << "Linking " << StageName(language) << " stage: " << message << "\n"; + else if (language == EShLangCount) + infoSink.info << "Linking " << StageName(unitStage) << " stage: " << message << "\n"; + else + infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n"; } // TODO: 4.4 offset/align: "Two blocks linked together in the same program with the same block @@ -114,7 +119,9 @@ void TIntermediate::mergeUniformObjects(TInfoSink& infoSink, TIntermediate& unit mergeLinkerObjects(infoSink, linkerObjects, unitLinkerObjects, unit.getStage()); } -static inline bool isSameInterface(TIntermSymbol* symbol, EShLanguage stage, TIntermSymbol* unitSymbol, EShLanguage unitStage) { +static inline bool isSameInterface(TIntermSymbol* symbol, TIntermSymbol* unitSymbol) { + EShLanguage stage = symbol->getStage(); + EShLanguage unitStage = unitSymbol->getStage(); return // 1) same stage and same shader interface (stage == unitStage && symbol->getType().getShaderInterface() == unitSymbol->getType().getShaderInterface()) || // 2) accross stages and both are uniform or buffer @@ -125,11 +132,11 @@ static inline bool isSameInterface(TIntermSymbol* symbol, EShLanguage stage, TIn (unitStage < stage && symbol->getQualifier().storage == EvqVaryingIn && unitSymbol->getQualifier().storage == EvqVaryingOut); } -static bool isSameSymbol(TIntermSymbol* symbol1, EShLanguage stage1, TIntermSymbol* symbol2, EShLanguage stage2) { +static bool isSameSymbol(TIntermSymbol* symbol1, TIntermSymbol* symbol2) { // If they are both blocks in the same shader interface, // match by the block-name, not the identifier name. if (symbol1->getType().getBasicType() == EbtBlock && symbol2->getType().getBasicType() == EbtBlock) { - if (isSameInterface(symbol1, stage1, symbol2, stage2)) { + if (isSameInterface(symbol1, symbol2)) { return symbol1->getType().getTypeName() == symbol2->getType().getTypeName(); } } else if (symbol1->getName() == symbol2->getName()) @@ -168,7 +175,7 @@ void TIntermediate::checkStageIO(TInfoSink& infoSink, TIntermediate& unit) { auto* nextStageSymbol = nextStageInterm->getAsSymbolNode(); bool found = false; for (auto& curStageInterm : linkerObjects) { - if (isSameSymbol(curStageInterm->getAsSymbolNode(), getStage(), nextStageSymbol, unit.getStage())) { + if (isSameSymbol(curStageInterm->getAsSymbolNode(), nextStageSymbol)) { found = true; break; } @@ -749,10 +756,10 @@ void TIntermediate::mergeBlockDefinitions(TInfoSink& infoSink, TIntermSymbol* bl // don't need as many checks as when merging symbols, since // initializers and most qualifiers are stripped when the member is moved into the block if ((*memberType) != (*unitMemberType)) { - error(infoSink, "Types must match:"); + error(infoSink, "Types must match:", unitBlock->getStage()); infoSink.info << " " << memberType->getFieldName() << ": "; - infoSink.info << "\"" << memberType->getCompleteString() << "\" versus "; - infoSink.info << "\"" << unitMemberType->getCompleteString() << "\"\n"; + infoSink.info << "\"" << memberType->getCompleteString() << "\" in stage " << StageName(block->getStage()) << " versus "; + infoSink.info << "\"" << unitMemberType->getCompleteString() << "\" in stage " << StageName(unitBlock->getStage()) << "\n"; } memberIndexUpdates[i] = j; @@ -856,7 +863,7 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode(); assert(symbol && unitSymbol); - if (isSameSymbol(symbol, getStage(), unitSymbol, unitStage)) { + if (isSameSymbol(symbol, unitSymbol)) { // filter out copy merge = false; @@ -893,7 +900,7 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin mergeImplicitArraySizes(symbol->getWritableType(), unitSymbol->getType()); // Check for consistent types/qualification/initializers etc. - mergeErrorCheck(infoSink, *symbol, *unitSymbol, unitStage); + mergeErrorCheck(infoSink, *symbol, *unitSymbol); } // If different symbols, verify they arn't push_constant since there can only be one per stage else if (symbol->getQualifier().isPushConstant() && unitSymbol->getQualifier().isPushConstant() && getStage() == unitStage) @@ -935,7 +942,7 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin } }; - if (isSameInterface(symbol, getStage(), unitSymbol, unitStage)) { + if (isSameInterface(symbol, unitSymbol)) { checkName(symbol->getName()); // check members of other anonymous blocks @@ -979,9 +986,11 @@ void TIntermediate::mergeImplicitArraySizes(TType& type, const TType& unitType) // // This function only does one of intra- or cross-stage matching per call. // -void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& symbol, const TIntermSymbol& unitSymbol, EShLanguage unitStage) +void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& symbol, const TIntermSymbol& unitSymbol) { - bool crossStage = getStage() != unitStage; + EShLanguage stage = symbol.getStage(); + EShLanguage unitStage = unitSymbol.getStage(); + bool crossStage = stage != unitStage; bool writeTypeComparison = false; bool errorReported = false; bool printQualifiers = false; @@ -993,10 +1002,10 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy // but, we make an exception if one is an implicit array and the other is sized // or if the array sizes differ because of the extra array dimension on some in/out boundaries bool arraysMatch = false; - if (isIoResizeArray(symbol.getType(), getStage()) || isIoResizeArray(unitSymbol.getType(), unitStage)) { + if (isIoResizeArray(symbol.getType(), stage) || isIoResizeArray(unitSymbol.getType(), unitStage)) { // if the arrays have an extra dimension because of the stage. // compare dimensions while ignoring the outer dimension - unsigned int firstDim = isIoResizeArray(symbol.getType(), getStage()) ? 1 : 0; + unsigned int firstDim = isIoResizeArray(symbol.getType(), stage) ? 1 : 0; unsigned int numDim = symbol.getArraySizes() ? symbol.getArraySizes()->getNumDims() : 0; unsigned int unitFirstDim = isIoResizeArray(unitSymbol.getType(), unitStage) ? 1 : 0; @@ -1025,7 +1034,7 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy if (lpidx >= 0 && rpidx >= 0) { error(infoSink, "Member names and types must match:", unitStage); infoSink.info << " Block: " << symbol.getType().getTypeName() << "\n"; - infoSink.info << " " << StageName(getStage()) << " stage: \"" + infoSink.info << " " << StageName(stage) << " stage: \"" << (*symbol.getType().getStruct())[lpidx].type->getCompleteString(true, false, false, true, (*symbol.getType().getStruct())[lpidx].type->getFieldName()) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: \"" @@ -1033,20 +1042,20 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy (*unitSymbol.getType().getStruct())[rpidx].type->getFieldName()) << "\"\n"; errorReported = true; } else if (lpidx >= 0 && rpidx == -1) { - TString errmsg = StageName(getStage()); + TString errmsg = StageName(stage); errmsg.append(" block member has no corresponding member in ").append(StageName(unitStage)).append(" block:"); error(infoSink, errmsg.c_str(), unitStage); - infoSink.info << " " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: " + infoSink.info << " " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: " << (*symbol.getType().getStruct())[lpidx].type->getFieldName() << "\n"; infoSink.info << " " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: n/a \n"; errorReported = true; } else if (lpidx == -1 && rpidx >= 0) { TString errmsg = StageName(unitStage); - errmsg.append(" block member has no corresponding member in ").append(StageName(getStage())).append(" block:"); + errmsg.append(" block member has no corresponding member in ").append(StageName(stage)).append(" block:"); error(infoSink, errmsg.c_str(), unitStage); infoSink.info << " " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: " << (*unitSymbol.getType().getStruct())[rpidx].type->getFieldName() << "\n"; - infoSink.info << " " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: n/a \n"; + infoSink.info << " " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: n/a \n"; errorReported = true; } else { error(infoSink, "Types must match:", unitStage); @@ -1103,7 +1112,7 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy layoutQualifierError = true; } if (layoutQualifierError) { - infoSink.info << " " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: " + infoSink.info << " " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: " << (*symbol.getType().getStruct())[li].type->getFieldName() << " \"" << (*symbol.getType().getStruct())[li].type->getCompleteString(true, true, false, false) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: " @@ -1284,24 +1293,24 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy if (symbol.getType().getBasicType() == EbtBlock && unitSymbol.getType().getBasicType() == EbtBlock && symbol.getType().getStruct() && unitSymbol.getType().getStruct()) { if (printType) { - infoSink.info << " " << StageName(getStage()) << " stage: \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, + infoSink.info << " " << StageName(stage) << " stage: \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, symbol.getName(), symbol.getType().getTypeName()) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, unitSymbol.getName(), unitSymbol.getType().getTypeName()) << "\"\n"; } else { - infoSink.info << " " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << " Instance: " << symbol.getName() + infoSink.info << " " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << " Instance: " << symbol.getName() << ": \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << " Instance: " << unitSymbol.getName() << ": \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n"; } } else { if (printType) { - infoSink.info << " " << StageName(getStage()) << " stage: \"" + infoSink.info << " " << StageName(stage) << " stage: \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, symbol.getName()) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, unitSymbol.getName()) << "\"\n"; } else { - infoSink.info << " " << StageName(getStage()) << " stage: " << symbol.getName() << " \"" + infoSink.info << " " << StageName(stage) << " stage: " << symbol.getName() << " \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n"; infoSink.info << " " << StageName(unitStage) << " stage: " << unitSymbol.getName() << " \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n"; diff --git a/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h b/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h index a2fb95143..2fae237a2 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h +++ b/3rdparty/glslang/glslang/MachineIndependent/localintermediate.h @@ -439,6 +439,9 @@ public: case EShTargetVulkan_1_3: processes.addProcess("target-env vulkan1.3"); break; + case EShTargetVulkan_1_4: + processes.addProcess("target-env vulkan1.4"); + break; default: processes.addProcess("target-env vulkanUnknown"); break; @@ -1120,7 +1123,7 @@ public: { on ? numericFeatures.insert(f) : numericFeatures.erase(f); } protected: - TIntermSymbol* addSymbol(long long Id, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&); + TIntermSymbol* addSymbol(long long Id, const TString&, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&); void error(TInfoSink& infoSink, const char*, EShLanguage unitStage = EShLangCount); void warn(TInfoSink& infoSink, const char*, EShLanguage unitStage = EShLangCount); void mergeCallGraphs(TInfoSink&, TIntermediate&); @@ -1132,7 +1135,7 @@ protected: void mergeLinkerObjects(TInfoSink&, TIntermSequence& linkerObjects, const TIntermSequence& unitLinkerObjects, EShLanguage); void mergeBlockDefinitions(TInfoSink&, TIntermSymbol* block, TIntermSymbol* unitBlock, TIntermediate* unitRoot); void mergeImplicitArraySizes(TType&, const TType&); - void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&, EShLanguage); + void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&); void checkCallGraphCycles(TInfoSink&); void checkCallGraphBodies(TInfoSink&, bool keepUncalled); void inOutLocationCheck(TInfoSink&); diff --git a/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h b/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h index 5c77e42ce..6b9bc0429 100644 --- a/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h +++ b/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h @@ -121,6 +121,7 @@ public: virtual void fcoopmatCheckNV(const TSourceLoc&, const char* op, bool builtIn = false); 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); bool relaxedErrors() const { return (messages & EShMsgRelaxedErrors) != 0; } bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; } bool isForwardCompatible() const { return forwardCompatible; } diff --git a/3rdparty/glslang/glslang/Public/ShaderLang.h b/3rdparty/glslang/glslang/Public/ShaderLang.h index 739d7f7b2..1a3a0b243 100644 --- a/3rdparty/glslang/glslang/Public/ShaderLang.h +++ b/3rdparty/glslang/glslang/Public/ShaderLang.h @@ -156,8 +156,9 @@ typedef enum { EShTargetVulkan_1_1 = (1 << 22) | (1 << 12), // Vulkan 1.1 EShTargetVulkan_1_2 = (1 << 22) | (2 << 12), // Vulkan 1.2 EShTargetVulkan_1_3 = (1 << 22) | (3 << 12), // Vulkan 1.3 + EShTargetVulkan_1_4 = (1 << 22) | (4 << 12), // Vulkan 1.4 EShTargetOpenGL_450 = 450, // OpenGL - LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 5), + LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6), } EShTargetClientVersion; typedef EShTargetClientVersion EshTargetClientVersion;