Implement the extension GL_ARB_gpu_shader_int64

- Add new keyword int64_t/uint64_t/i64vec/u64vec.
- Support 64-bit integer literals (dec/hex/oct).
- Support built-in operators for 64-bit integer type.
- Add implicit and explicit type conversion for 64-bit integer type.
- Add new built-in functions defined in this extension.

diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index 07ed51c..0c62d52 100755 (executable)
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -1069,9 +1069,13 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
     case glslang::EOpPreDecrement:
         {
             // we need the integer value "1" or the floating point "1.0" to add/subtract
-            spv::Id one = node->getBasicType() == glslang::EbtFloat ?
-                                     builder.makeFloatConstant(1.0F) :
-                                     builder.makeIntConstant(1);
+            spv::Id one = 0;
+            if (node->getBasicType() == glslang::EbtFloat)
+                one = builder.makeFloatConstant(1.0F);
+            else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64)
+                one = builder.makeInt64Constant(1);
+            else
+                one = builder.makeIntConstant(1);
             glslang::TOperator op;
             if (node->getOp() == glslang::EOpPreIncrement ||
                 node->getOp() == glslang::EOpPostIncrement)
@@ -1080,8 +1084,8 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
                 op = glslang::EOpSub;
 
             spv::Id result = createBinaryOperation(op, TranslatePrecisionDecoration(node->getType()), 
-                                                     convertGlslangToSpvType(node->getType()), operand, one, 
-                                                     node->getType().getBasicType());
+                                                   convertGlslangToSpvType(node->getType()), operand, one,
+                                                   node->getType().getBasicType());
             assert(result != spv::NoResult);
 
             // The result of operation is always stored, but conditionally the
@@ -1260,6 +1264,14 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpConstructUVec2:
     case glslang::EOpConstructUVec3:
     case glslang::EOpConstructUVec4:
+    case glslang::EOpConstructInt64:
+    case glslang::EOpConstructI64Vec2:
+    case glslang::EOpConstructI64Vec3:
+    case glslang::EOpConstructI64Vec4:
+    case glslang::EOpConstructUint64:
+    case glslang::EOpConstructU64Vec2:
+    case glslang::EOpConstructU64Vec3:
+    case glslang::EOpConstructU64Vec4:
     case glslang::EOpConstructStruct:
     case glslang::EOpConstructTextureSampler:
     {
@@ -1740,6 +1752,14 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
     case glslang::EbtUint:
         spvType = builder.makeUintType(32);
         break;
+    case glslang::EbtInt64:
+        builder.addCapability(spv::CapabilityInt64);
+        spvType = builder.makeIntType(64);
+        break;
+    case glslang::EbtUint64:
+        builder.addCapability(spv::CapabilityInt64);
+        spvType = builder.makeUintType(64);
+        break;
     case glslang::EbtAtomicUint:
         spv::TbdFunctionality("Is atomic_uint an opaque handle in the uniform storage class, or an addresses in the atomic storage class?");
         spvType = builder.makeUintType(32);
@@ -2631,7 +2651,7 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, spv
                                                       spv::Id typeId, spv::Id left, spv::Id right,
                                                       glslang::TBasicType typeProxy, bool reduceComparison)
 {
-    bool isUnsigned = typeProxy == glslang::EbtUint;
+    bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
     bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
     bool isBool = typeProxy == glslang::EbtBool;
 
@@ -2948,7 +2968,7 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv:
 {
     spv::Op unaryOp = spv::OpNop;
     int libCall = -1;
-    bool isUnsigned = typeProxy == glslang::EbtUint;
+    bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
     bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
 
     switch (op) {
@@ -3079,6 +3099,10 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv:
     case glslang::EOpFloatBitsToUint:
     case glslang::EOpIntBitsToFloat:
     case glslang::EOpUintBitsToFloat:
+    case glslang::EOpDoubleBitsToInt64:
+    case glslang::EOpDoubleBitsToUint64:
+    case glslang::EOpInt64BitsToDouble:
+    case glslang::EOpUint64BitsToDouble:
         unaryOp = spv::OpBitcast;
         break;
 
@@ -3119,6 +3143,14 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv:
         libCall = spv::GLSLstd450UnpackDouble2x32;
         break;
 
+    case glslang::EOpPackInt2x32:
+    case glslang::EOpUnpackInt2x32:
+    case glslang::EOpPackUint2x32:
+    case glslang::EOpUnpackUint2x32:
+        spv::MissingFunctionality("shader int64");
+        libCall = spv::GLSLstd450Bad; // TODO: This is a placeholder.
+        break;
+
     case glslang::EOpDPdx:
         unaryOp = spv::OpDPdx;
         break;
@@ -3252,13 +3284,17 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec
     spv::Op convOp = spv::OpNop;
     spv::Id zero = 0;
     spv::Id one = 0;
+    spv::Id type = 0;
 
     int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0;
 
     switch (op) {
     case glslang::EOpConvIntToBool:
     case glslang::EOpConvUintToBool:
-        zero = builder.makeUintConstant(0);
+    case glslang::EOpConvInt64ToBool:
+    case glslang::EOpConvUint64ToBool:
+        zero = (op == glslang::EOpConvInt64ToBool ||
+                op == glslang::EOpConvUint64ToBool) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0);
         zero = makeSmearedConstant(zero, vectorSize);
         return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
 
@@ -3283,23 +3319,29 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec
         one  = builder.makeDoubleConstant(1.0);
         break;
     case glslang::EOpConvBoolToInt:
-        zero = builder.makeIntConstant(0);
-        one  = builder.makeIntConstant(1);
+    case glslang::EOpConvBoolToInt64:
+        zero = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(0) : builder.makeIntConstant(0);
+        one  = (op == glslang::EOpConvBoolToInt64) ? builder.makeInt64Constant(1) : builder.makeIntConstant(1);
         convOp = spv::OpSelect;
         break;
     case glslang::EOpConvBoolToUint:
-        zero = builder.makeUintConstant(0);
-        one  = builder.makeUintConstant(1);
+    case glslang::EOpConvBoolToUint64:
+        zero = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0);
+        one  = (op == glslang::EOpConvBoolToUint64) ? builder.makeUint64Constant(1) : builder.makeUintConstant(1);
         convOp = spv::OpSelect;
         break;
 
     case glslang::EOpConvIntToFloat:
     case glslang::EOpConvIntToDouble:
+    case glslang::EOpConvInt64ToFloat:
+    case glslang::EOpConvInt64ToDouble:
         convOp = spv::OpConvertSToF;
         break;
 
     case glslang::EOpConvUintToFloat:
     case glslang::EOpConvUintToDouble:
+    case glslang::EOpConvUint64ToFloat:
+    case glslang::EOpConvUint64ToDouble:
         convOp = spv::OpConvertUToF;
         break;
 
@@ -3310,14 +3352,19 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec
 
     case glslang::EOpConvFloatToInt:
     case glslang::EOpConvDoubleToInt:
+    case glslang::EOpConvFloatToInt64:
+    case glslang::EOpConvDoubleToInt64:
         convOp = spv::OpConvertFToS;
         break;
 
     case glslang::EOpConvUintToInt:
     case glslang::EOpConvIntToUint:
+    case glslang::EOpConvUint64ToInt64:
+    case glslang::EOpConvInt64ToUint64:
         if (builder.isInSpecConstCodeGenMode()) {
             // Build zero scalar or vector for OpIAdd.
-            zero = builder.makeUintConstant(0);
+            zero = (op == glslang::EOpConvUintToInt64 ||
+                    op == glslang::EOpConvIntToUint64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(0);
             zero = makeSmearedConstant(zero, vectorSize);
             // Use OpIAdd, instead of OpBitcast to do the conversion when
             // generating for OpSpecConstantOp instruction.
@@ -3329,8 +3376,65 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Dec
 
     case glslang::EOpConvFloatToUint:
     case glslang::EOpConvDoubleToUint:
+    case glslang::EOpConvFloatToUint64:
+    case glslang::EOpConvDoubleToUint64:
         convOp = spv::OpConvertFToU;
         break;
+
+    case glslang::EOpConvIntToInt64:
+    case glslang::EOpConvInt64ToInt:
+        convOp = spv::OpSConvert;
+        break;
+
+    case glslang::EOpConvUintToUint64:
+    case glslang::EOpConvUint64ToUint:
+        convOp = spv::OpUConvert;
+        break;
+
+    case glslang::EOpConvIntToUint64:
+    case glslang::EOpConvInt64ToUint:
+    case glslang::EOpConvUint64ToInt:
+    case glslang::EOpConvUintToInt64:
+        // OpSConvert/OpUConvert + OpBitCast
+        switch (op) {
+        case glslang::EOpConvIntToUint64:
+            convOp = spv::OpSConvert;
+            type   = builder.makeIntType(64);
+            break;
+        case glslang::EOpConvInt64ToUint:
+            convOp = spv::OpSConvert;
+            type   = builder.makeIntType(32);
+            break;
+        case glslang::EOpConvUint64ToInt:
+            convOp = spv::OpUConvert;
+            type   = builder.makeUintType(32);
+            break;
+        case glslang::EOpConvUintToInt64:
+            convOp = spv::OpUConvert;
+            type   = builder.makeUintType(64);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+
+        if (vectorSize > 0)
+            type = builder.makeVectorType(type, vectorSize);
+
+        operand = builder.createUnaryOp(convOp, type, operand);
+
+        if (builder.isInSpecConstCodeGenMode()) {
+            // Build zero scalar or vector for OpIAdd.
+            zero = (op == glslang::EOpConvIntToUint64 ||
+                    op == glslang::EOpConvUintToInt64) ? builder.makeUint64Constant(0) : builder.makeUintConstant(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;
     default:
         break;
     }
@@ -3441,7 +3545,7 @@ spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv
 
 spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
 {
-    bool isUnsigned = typeProxy == glslang::EbtUint;
+    bool isUnsigned = typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64;
     bool isFloat = typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble;
 
     spv::Op opCode = spv::OpNop;
@@ -3876,6 +3980,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla
             case glslang::EbtUint:
                 spvConsts.push_back(builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst()));
                 break;
+            case glslang::EbtInt64:
+                spvConsts.push_back(builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const()));
+                break;
+            case glslang::EbtUint64:
+                spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const()));
+                break;
             case glslang::EbtFloat:
                 spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
                 break;
@@ -3902,6 +4012,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla
         case glslang::EbtUint:
             scalar = builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst(), specConstant);
             break;
+        case glslang::EbtInt64:
+            scalar = builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const(), specConstant);
+            break;
+        case glslang::EbtUint64:
+            scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
+            break;
         case glslang::EbtFloat:
             scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
             break;

diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index bbb30c3..0171b15 100644 (file)
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -606,7 +606,7 @@ Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned valu
     return 0;
 }
 
-// Version of findScalarConstant (see above) for scalars that take two operands (e.g. a 'double').
+// Version of findScalarConstant (see above) for scalars that take two operands (e.g. a 'double' or 'int64').
 Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2) const
 {
     Instruction* constant;
@@ -711,6 +711,31 @@ Id Builder::makeIntConstant(Id typeId, unsigned value, bool specConstant)
     return c->getResultId();
 }
 
+Id Builder::makeInt64Constant(Id typeId, unsigned long long value, bool specConstant)
+{
+    Op opcode = specConstant ? OpSpecConstant : OpConstant;
+
+    unsigned op1 = value & 0xFFFFFFFF;
+    unsigned op2 = value >> 32;
+
+    // See if we already made it. Applies only to regular constants, because specialization constants
+    // must remain distinct for the purpose of applying a SpecId decoration.
+    if (! specConstant) {
+        Id existing = findScalarConstant(OpTypeInt, opcode, typeId, op1, op2);
+        if (existing)
+            return existing;
+    }
+
+    Instruction* c = new Instruction(getUniqueId(), typeId, opcode);
+    c->addImmediateOperand(op1);
+    c->addImmediateOperand(op2);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(c));
+    groupedConstants[OpTypeInt].push_back(c);
+    module.mapInstruction(c);
+
+    return c->getResultId();
+}
+
 Id Builder::makeFloatConstant(float f, bool specConstant)
 {
     Op opcode = specConstant ? OpSpecConstant : OpConstant;

diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index 661bb11..8c05f4e 100755 (executable)
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -188,6 +188,8 @@ public:
     Id makeBoolConstant(bool b, bool specConstant = false);
     Id makeIntConstant(int i, bool specConstant = false)         { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
     Id makeUintConstant(unsigned u, bool specConstant = false)   { return makeIntConstant(makeUintType(32),           u, specConstant); }
+    Id makeInt64Constant(long long i, bool specConstant = false)            { return makeInt64Constant(makeIntType(64),  (unsigned long long)i, specConstant); }
+    Id makeUint64Constant(unsigned long long u, bool specConstant = false)  { return makeInt64Constant(makeUintType(64),                     u, specConstant); }
     Id makeFloatConstant(float f, bool specConstant = false);
     Id makeDoubleConstant(double d, bool specConstant = false);
 
@@ -533,6 +535,7 @@ public:
 
  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) const;
     Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2) const;
     Id findCompositeConstant(Op typeClass, std::vector<Id>& comps) const;

diff --git a/Test/baseResults/spv.int64.frag.out b/Test/baseResults/spv.int64.frag.out
new file mode 100644 (file)
index 0000000..5088469
--- /dev/null
+++ b/Test/baseResults/spv.int64.frag.out
@@ -0,0 +1,629 @@
+spv.int64.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+Missing functionality: shader int64
+Missing functionality: shader int64
+Missing functionality: shader int64
+Missing functionality: shader int64
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 455
+
+                              Capability Shader
+                              Capability Float64
+                              Capability Int64
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main"
+                              ExecutionMode 4 OriginUpperLeft
+                              Source GLSL 450
+                              SourceExtension  "GL_ARB_gpu_shader_int64"
+                              Name 4  "main"
+                              Name 6  "literal("
+                              Name 8  "typeCast("
+                              Name 10  "operators("
+                              Name 12  "builtinFuncs("
+                              Name 16  "i64"
+                              Name 24  "Uniforms"
+                              MemberName 24(Uniforms) 0  "index"
+                              Name 26  ""
+                              Name 33  "indexable"
+                              Name 38  "u64"
+                              Name 47  "indexable"
+                              Name 52  "i64v"
+                              Name 56  "bv"
+                              Name 65  "u64v"
+                              Name 74  "iv"
+                              Name 81  "uv"
+                              Name 89  "fv"
+                              Name 95  "dv"
+                              Name 132  "u64v"
+                              Name 137  "i64"
+                              Name 157  "i"
+                              Name 164  "uv"
+                              Name 216  "b"
+                              Name 276  "i64v"
+                              Name 279  "i64"
+                              Name 289  "u64v"
+                              Name 291  "u64"
+                              Name 363  "dv"
+                              Name 382  "iv"
+                              Name 387  "uv"
+                              Name 391  "bv"
+                              Name 452  "Block"
+                              MemberName 452(Block) 0  "i64v"
+                              MemberName 452(Block) 1  "u64"
+                              Name 454  "block"
+                              MemberDecorate 24(Uniforms) 0 Offset 0
+                              Decorate 24(Uniforms) Block
+                              Decorate 26 DescriptorSet 0
+                              Decorate 26 Binding 0
+                              MemberDecorate 452(Block) 0 Offset 0
+                              MemberDecorate 452(Block) 1 Offset 24
+                              Decorate 452(Block) Block
+                              Decorate 454(block) DescriptorSet 0
+                              Decorate 454(block) Binding 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+              14:             TypeInt 64 1
+              15:             TypePointer Function 14(int)
+              17:             TypeInt 32 0
+              18:     17(int) Constant 3
+              19:             TypeArray 14(int) 18
+              20:     14(int) Constant 4008636143 4008636142
+              21:     14(int) Constant 4294967295 4294967295
+              22:     14(int) Constant 0 1
+              23:          19 ConstantComposite 20 21 22
+    24(Uniforms):             TypeStruct 17(int)
+              25:             TypePointer Uniform 24(Uniforms)
+              26:     25(ptr) Variable Uniform
+              27:             TypeInt 32 1
+              28:     27(int) Constant 0
+              29:             TypePointer Uniform 17(int)
+              32:             TypePointer Function 19
+              36:             TypeInt 64 0
+              37:             TypePointer Function 36(int)
+              39:             TypeArray 36(int) 18
+              40:     36(int) Constant 4294967295 4294967295
+              41:     36(int) Constant 0 1
+              42:     36(int) Constant 4294967295 1
+              43:          39 ConstantComposite 40 41 42
+              46:             TypePointer Function 39
+              50:             TypeVector 14(int) 2
+              51:             TypePointer Function 50(ivec2)
+              53:             TypeBool
+              54:             TypeVector 53(bool) 2
+              55:             TypePointer Function 54(bvec2)
+              58:     14(int) Constant 0 0
+              59:     14(int) Constant 1 0
+              60:   50(ivec2) ConstantComposite 58 58
+              61:   50(ivec2) ConstantComposite 59 59
+              63:             TypeVector 36(int) 2
+              64:             TypePointer Function 63(ivec2)
+              67:     36(int) Constant 0 0
+              68:     36(int) Constant 1 0
+              69:   63(ivec2) ConstantComposite 67 67
+              70:   63(ivec2) ConstantComposite 68 68
+              72:             TypeVector 27(int) 2
+              73:             TypePointer Function 72(ivec2)
+              79:             TypeVector 17(int) 2
+              80:             TypePointer Function 79(ivec2)
+              86:             TypeFloat 32
+              87:             TypeVector 86(float) 2
+              88:             TypePointer Function 87(fvec2)
+              92:             TypeFloat 64
+              93:             TypeVector 92(float) 2
+              94:             TypePointer Function 93(fvec2)
+             130:             TypeVector 36(int) 3
+             131:             TypePointer Function 130(ivec3)
+             134:             TypeVector 14(int) 3
+             156:             TypePointer Function 27(int)
+             162:             TypeVector 17(int) 3
+             163:             TypePointer Function 162(ivec3)
+             197:             TypeVector 27(int) 3
+             200:     17(int) Constant 1
+             201:             TypePointer Function 17(int)
+             207:     17(int) Constant 2
+             215:             TypePointer Function 53(bool)
+             217:     17(int) Constant 0
+             287:   50(ivec2) ConstantComposite 21 21
+             296:  130(ivec3) ConstantComposite 67 67 67
+             338:    53(bool) ConstantTrue
+             345:    53(bool) ConstantFalse
+             346:   54(bvec2) ConstantComposite 345 345
+             358:             TypeVector 53(bool) 3
+             359:  358(bvec3) ConstantComposite 345 345 345
+             361:             TypeVector 92(float) 3
+             362:             TypePointer Function 361(fvec3)
+             367:             TypePointer Function 92(float)
+             378:     27(int) Constant 1
+             379:     27(int) Constant 2
+             380:   72(ivec2) ConstantComposite 378 379
+             385:   79(ivec2) ConstantComposite 207 18
+             390:             TypePointer Function 358(bvec3)
+      452(Block):             TypeStruct 134(ivec3) 36(int)
+             453:             TypePointer Uniform 452(Block)
+      454(block):    453(ptr) Variable Uniform
+         4(main):           2 Function None 3
+               5:             Label
+                              Return
+                              FunctionEnd
+     6(literal():           2 Function None 3
+               7:             Label
+         16(i64):     15(ptr) Variable Function
+   33(indexable):     32(ptr) Variable Function
+         38(u64):     37(ptr) Variable Function
+   47(indexable):     46(ptr) Variable Function
+              30:     29(ptr) AccessChain 26 28
+              31:     17(int) Load 30
+                              Store 33(indexable) 23
+              34:     15(ptr) AccessChain 33(indexable) 31
+              35:     14(int) Load 34
+                              Store 16(i64) 35
+              44:     29(ptr) AccessChain 26 28
+              45:     17(int) Load 44
+                              Store 47(indexable) 43
+              48:     37(ptr) AccessChain 47(indexable) 45
+              49:     36(int) Load 48
+                              Store 38(u64) 49
+                              Return
+                              FunctionEnd
+    8(typeCast():           2 Function None 3
+               9:             Label
+        52(i64v):     51(ptr) Variable Function
+          56(bv):     55(ptr) Variable Function
+        65(u64v):     64(ptr) Variable Function
+          74(iv):     73(ptr) Variable Function
+          81(uv):     80(ptr) Variable Function
+          89(fv):     88(ptr) Variable Function
+          95(dv):     94(ptr) Variable Function
+              57:   54(bvec2) Load 56(bv)
+              62:   50(ivec2) Select 57 61 60
+                              Store 52(i64v) 62
+              66:   54(bvec2) Load 56(bv)
+              71:   63(ivec2) Select 66 70 69
+                              Store 65(u64v) 71
+              75:   72(ivec2) Load 74(iv)
+              76:   50(ivec2) SConvert 75
+                              Store 52(i64v) 76
+              77:   50(ivec2) Load 52(i64v)
+              78:   72(ivec2) SConvert 77
+                              Store 74(iv) 78
+              82:   79(ivec2) Load 81(uv)
+              83:   63(ivec2) UConvert 82
+                              Store 65(u64v) 83
+              84:   63(ivec2) Load 65(u64v)
+              85:   79(ivec2) UConvert 84
+                              Store 81(uv) 85
+              90:   50(ivec2) Load 52(i64v)
+              91:   87(fvec2) ConvertSToF 90
+                              Store 89(fv) 91
+              96:   50(ivec2) Load 52(i64v)
+              97:   93(fvec2) ConvertSToF 96
+                              Store 95(dv) 97
+              98:   63(ivec2) Load 65(u64v)
+              99:   87(fvec2) ConvertUToF 98
+                              Store 89(fv) 99
+             100:   63(ivec2) Load 65(u64v)
+             101:   93(fvec2) ConvertUToF 100
+                              Store 95(dv) 101
+             102:   87(fvec2) Load 89(fv)
+             103:   50(ivec2) ConvertFToS 102
+                              Store 52(i64v) 103
+             104:   93(fvec2) Load 95(dv)
+             105:   50(ivec2) ConvertFToS 104
+                              Store 52(i64v) 105
+             106:   87(fvec2) Load 89(fv)
+             107:   63(ivec2) ConvertFToU 106
+                              Store 65(u64v) 107
+             108:   93(fvec2) Load 95(dv)
+             109:   63(ivec2) ConvertFToU 108
+                              Store 65(u64v) 109
+             110:   50(ivec2) Load 52(i64v)
+             111:   54(bvec2) INotEqual 110 69
+                              Store 56(bv) 111
+             112:   63(ivec2) Load 65(u64v)
+             113:   54(bvec2) INotEqual 112 69
+                              Store 56(bv) 113
+             114:   50(ivec2) Load 52(i64v)
+             115:   63(ivec2) Bitcast 114
+                              Store 65(u64v) 115
+             116:   63(ivec2) Load 65(u64v)
+             117:   50(ivec2) Bitcast 116
+                              Store 52(i64v) 117
+             118:   50(ivec2) Load 52(i64v)
+             119:   72(ivec2) SConvert 118
+             120:   79(ivec2) Bitcast 119
+                              Store 81(uv) 120
+             121:   79(ivec2) Load 81(uv)
+             122:   63(ivec2) UConvert 121
+             123:   50(ivec2) Bitcast 122
+                              Store 52(i64v) 123
+             124:   63(ivec2) Load 65(u64v)
+             125:   79(ivec2) UConvert 124
+             126:   72(ivec2) Bitcast 125
+                              Store 74(iv) 126
+             127:   72(ivec2) Load 74(iv)
+             128:   50(ivec2) SConvert 127
+             129:   63(ivec2) Bitcast 128
+                              Store 65(u64v) 129
+                              Return
+                              FunctionEnd
+  10(operators():           2 Function None 3
+              11:             Label
+       132(u64v):    131(ptr) Variable Function
+        137(i64):     15(ptr) Variable Function
+          157(i):    156(ptr) Variable Function
+         164(uv):    163(ptr) Variable Function
+          216(b):    215(ptr) Variable Function
+             133:  130(ivec3) Load 132(u64v)
+             135:  134(ivec3) CompositeConstruct 59 59 59
+             136:  130(ivec3) IAdd 133 135
+                              Store 132(u64v) 136
+             138:     14(int) Load 137(i64)
+             139:     14(int) ISub 138 59
+                              Store 137(i64) 139
+             140:     14(int) Load 137(i64)
+             141:     14(int) IAdd 140 59
+                              Store 137(i64) 141
+             142:  130(ivec3) Load 132(u64v)
+             143:  134(ivec3) CompositeConstruct 59 59 59
+             144:  130(ivec3) ISub 142 143
+                              Store 132(u64v) 144
+             145:  130(ivec3) Load 132(u64v)
+             146:  130(ivec3) Not 145
+                              Store 132(u64v) 146
+             147:     14(int) Load 137(i64)
+                              Store 137(i64) 147
+             148:  130(ivec3) Load 132(u64v)
+             149:  130(ivec3) SNegate 148
+                              Store 132(u64v) 149
+             150:     14(int) Load 137(i64)
+             151:     14(int) Load 137(i64)
+             152:     14(int) IAdd 151 150
+                              Store 137(i64) 152
+             153:  130(ivec3) Load 132(u64v)
+             154:  130(ivec3) Load 132(u64v)
+             155:  130(ivec3) ISub 154 153
+                              Store 132(u64v) 155
+             158:     27(int) Load 157(i)
+             159:     14(int) SConvert 158
+             160:     14(int) Load 137(i64)
+             161:     14(int) IMul 160 159
+                              Store 137(i64) 161
+             165:  162(ivec3) Load 164(uv)
+             166:  130(ivec3) UConvert 165
+             167:  130(ivec3) Load 132(u64v)
+             168:  130(ivec3) UDiv 167 166
+                              Store 132(u64v) 168
+             169:     27(int) Load 157(i)
+             170:     14(int) SConvert 169
+             171:     36(int) Bitcast 170
+             172:  130(ivec3) Load 132(u64v)
+             173:  130(ivec3) CompositeConstruct 171 171 171
+             174:  130(ivec3) UMod 172 173
+                              Store 132(u64v) 174
+             175:  130(ivec3) Load 132(u64v)
+             176:  162(ivec3) Load 164(uv)
+             177:  130(ivec3) UConvert 176
+             178:  130(ivec3) IAdd 175 177
+                              Store 132(u64v) 178
+             179:     14(int) Load 137(i64)
+             180:     27(int) Load 157(i)
+             181:     14(int) SConvert 180
+             182:     14(int) ISub 179 181
+                              Store 137(i64) 182
+             183:  130(ivec3) Load 132(u64v)
+             184:  162(ivec3) Load 164(uv)
+             185:  130(ivec3) UConvert 184
+             186:  130(ivec3) IMul 183 185
+                              Store 132(u64v) 186
+             187:     14(int) Load 137(i64)
+             188:     27(int) Load 157(i)
+             189:     14(int) SConvert 188
+             190:     14(int) IMul 187 189
+                              Store 137(i64) 190
+             191:     14(int) Load 137(i64)
+             192:     27(int) Load 157(i)
+             193:     14(int) SConvert 192
+             194:     14(int) SMod 191 193
+                              Store 137(i64) 194
+             195:     27(int) Load 157(i)
+             196:  130(ivec3) Load 132(u64v)
+             198:  197(ivec3) CompositeConstruct 195 195 195
+             199:  130(ivec3) ShiftLeftLogical 196 198
+                              Store 132(u64v) 199
+             202:    201(ptr) AccessChain 164(uv) 200
+             203:     17(int) Load 202
+             204:     14(int) Load 137(i64)
+             205:     14(int) ShiftRightArithmetic 204 203
+                              Store 137(i64) 205
+             206:     14(int) Load 137(i64)
+             208:     37(ptr) AccessChain 132(u64v) 207
+             209:     36(int) Load 208
+             210:     14(int) ShiftLeftLogical 206 209
+                              Store 137(i64) 210
+             211:  130(ivec3) Load 132(u64v)
+             212:     14(int) Load 137(i64)
+             213:  134(ivec3) CompositeConstruct 212 212 212
+             214:  130(ivec3) ShiftLeftLogical 211 213
+                              Store 132(u64v) 214
+             218:     37(ptr) AccessChain 132(u64v) 217
+             219:     36(int) Load 218
+             220:     14(int) Load 137(i64)
+             221:     36(int) Bitcast 220
+             222:    53(bool) INotEqual 219 221
+                              Store 216(b) 222
+             223:     14(int) Load 137(i64)
+             224:     36(int) Bitcast 223
+             225:     37(ptr) AccessChain 132(u64v) 217
+             226:     36(int) Load 225
+             227:    53(bool) IEqual 224 226
+                              Store 216(b) 227
+             228:     37(ptr) AccessChain 132(u64v) 217
+             229:     36(int) Load 228
+             230:    201(ptr) AccessChain 164(uv) 200
+             231:     17(int) Load 230
+             232:     36(int) UConvert 231
+             233:    53(bool) UGreaterThan 229 232
+                              Store 216(b) 233
+             234:     14(int) Load 137(i64)
+             235:     27(int) Load 157(i)
+             236:     14(int) SConvert 235
+             237:    53(bool) SLessThan 234 236
+                              Store 216(b) 237
+             238:     37(ptr) AccessChain 132(u64v) 200
+             239:     36(int) Load 238
+             240:    201(ptr) AccessChain 164(uv) 217
+             241:     17(int) Load 240
+             242:     36(int) UConvert 241
+             243:    53(bool) UGreaterThanEqual 239 242
+                              Store 216(b) 243
+             244:     14(int) Load 137(i64)
+             245:     27(int) Load 157(i)
+             246:     14(int) SConvert 245
+             247:    53(bool) SLessThanEqual 244 246
+                              Store 216(b) 247
+             248:     27(int) Load 157(i)
+             249:     14(int) SConvert 248
+             250:     36(int) Bitcast 249
+             251:  130(ivec3) Load 132(u64v)
+             252:  130(ivec3) CompositeConstruct 250 250 250
+             253:  130(ivec3) BitwiseOr 251 252
+                              Store 132(u64v) 253
+             254:     14(int) Load 137(i64)
+             255:     27(int) Load 157(i)
+             256:     14(int) SConvert 255
+             257:     14(int) BitwiseOr 254 256
+                              Store 137(i64) 257
+             258:     27(int) Load 157(i)
+             259:     14(int) SConvert 258
+             260:     14(int) Load 137(i64)
+             261:     14(int) BitwiseAnd 260 259
+                              Store 137(i64) 261
+             262:  130(ivec3) Load 132(u64v)
+             263:  162(ivec3) Load 164(uv)
+             264:  130(ivec3) UConvert 263
+             265:  130(ivec3) BitwiseAnd 262 264
+                              Store 132(u64v) 265
+             266:     14(int) Load 137(i64)
+             267:     36(int) Bitcast 266
+             268:  130(ivec3) Load 132(u64v)
+             269:  130(ivec3) CompositeConstruct 267 267 267
+             270:  130(ivec3) BitwiseXor 268 269
+                              Store 132(u64v) 270
+             271:  130(ivec3) Load 132(u64v)
+             272:     14(int) Load 137(i64)
+             273:     36(int) Bitcast 272
+             274:  130(ivec3) CompositeConstruct 273 273 273
+             275:  130(ivec3) BitwiseXor 271 274
+                              Store 132(u64v) 275
+                              Return
+                              FunctionEnd
+12(builtinFuncs():           2 Function None 3
+              13:             Label
+       276(i64v):     51(ptr) Variable Function
+        279(i64):     15(ptr) Variable Function
+       289(u64v):    131(ptr) Variable Function
+        291(u64):     37(ptr) Variable Function
+         363(dv):    362(ptr) Variable Function
+         382(iv):     73(ptr) Variable Function
+         387(uv):     80(ptr) Variable Function
+         391(bv):    390(ptr) Variable Function
+             277:   50(ivec2) Load 276(i64v)
+             278:   50(ivec2) ExtInst 1(GLSL.std.450) 5(SAbs) 277
+                              Store 276(i64v) 278
+             280:     14(int) Load 279(i64)
+             281:     14(int) ExtInst 1(GLSL.std.450) 7(SSign) 280
+                              Store 279(i64) 281
+             282:   50(ivec2) Load 276(i64v)
+             283:     14(int) Load 279(i64)
+             284:   50(ivec2) CompositeConstruct 283 283
+             285:   50(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 282 284
+                              Store 276(i64v) 285
+             286:   50(ivec2) Load 276(i64v)
+             288:   50(ivec2) ExtInst 1(GLSL.std.450) 39(SMin) 286 287
+                              Store 276(i64v) 288
+             290:  130(ivec3) Load 289(u64v)
+             292:     36(int) Load 291(u64)
+             293:  130(ivec3) CompositeConstruct 292 292 292
+             294:  130(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 290 293
+                              Store 289(u64v) 294
+             295:  130(ivec3) Load 289(u64v)
+             297:  130(ivec3) ExtInst 1(GLSL.std.450) 38(UMin) 295 296
+                              Store 289(u64v) 297
+             298:   50(ivec2) Load 276(i64v)
+             299:     14(int) Load 279(i64)
+             300:   50(ivec2) CompositeConstruct 299 299
+             301:   50(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 298 300
+                              Store 276(i64v) 301
+             302:   50(ivec2) Load 276(i64v)
+             303:   50(ivec2) ExtInst 1(GLSL.std.450) 42(SMax) 302 287
+                              Store 276(i64v) 303
+             304:  130(ivec3) Load 289(u64v)
+             305:     36(int) Load 291(u64)
+             306:  130(ivec3) CompositeConstruct 305 305 305
+             307:  130(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 304 306
+                              Store 289(u64v) 307
+             308:  130(ivec3) Load 289(u64v)
+             309:  130(ivec3) ExtInst 1(GLSL.std.450) 41(UMax) 308 296
+                              Store 289(u64v) 309
+             310:   50(ivec2) Load 276(i64v)
+             311:     14(int) Load 279(i64)
+             312:     14(int) SNegate 311
+             313:     14(int) Load 279(i64)
+             314:   50(ivec2) CompositeConstruct 312 312
+             315:   50(ivec2) CompositeConstruct 313 313
+             316:   50(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 310 314 315
+                              Store 276(i64v) 316
+             317:   50(ivec2) Load 276(i64v)
+             318:   50(ivec2) Load 276(i64v)
+             319:   50(ivec2) SNegate 318
+             320:   50(ivec2) Load 276(i64v)
+             321:   50(ivec2) ExtInst 1(GLSL.std.450) 45(SClamp) 317 319 320
+                              Store 276(i64v) 321
+             322:  130(ivec3) Load 289(u64v)
+             323:     36(int) Load 291(u64)
+             324:     36(int) SNegate 323
+             325:     36(int) Load 291(u64)
+             326:  130(ivec3) CompositeConstruct 324 324 324
+             327:  130(ivec3) CompositeConstruct 325 325 325
+             328:  130(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 322 326 327
+                              Store 289(u64v) 328
+             329:  130(ivec3) Load 289(u64v)
+             330:  130(ivec3) Load 289(u64v)
+             331:  130(ivec3) SNegate 330
+             332:  130(ivec3) Load 289(u64v)
+             333:  130(ivec3) ExtInst 1(GLSL.std.450) 44(UClamp) 329 331 332
+                              Store 289(u64v) 333
+             334:     15(ptr) AccessChain 276(i64v) 217
+             335:     14(int) Load 334
+             336:     15(ptr) AccessChain 276(i64v) 200
+             337:     14(int) Load 336
+             339:     14(int) Select 338 337 335
+                              Store 279(i64) 339
+             340:     14(int) Load 279(i64)
+             341:   50(ivec2) CompositeConstruct 340 340
+             342:     14(int) Load 279(i64)
+             343:     14(int) SNegate 342
+             344:   50(ivec2) CompositeConstruct 343 343
+             347:   50(ivec2) Select 346 344 341
+                              Store 276(i64v) 347
+             348:     37(ptr) AccessChain 289(u64v) 217
+             349:     36(int) Load 348
+             350:     37(ptr) AccessChain 289(u64v) 200
+             351:     36(int) Load 350
+             352:     36(int) Select 338 351 349
+                              Store 291(u64) 352
+             353:     36(int) Load 291(u64)
+             354:  130(ivec3) CompositeConstruct 353 353 353
+             355:     36(int) Load 291(u64)
+             356:     36(int) SNegate 355
+             357:  130(ivec3) CompositeConstruct 356 356 356
+             360:  130(ivec3) Select 359 357 354
+                              Store 289(u64v) 360
+             364:  361(fvec3) Load 363(dv)
+             365:   93(fvec2) VectorShuffle 364 364 0 1
+             366:   50(ivec2) Bitcast 365
+                              Store 276(i64v) 366
+             368:    367(ptr) AccessChain 363(dv) 207
+             369:   92(float) Load 368
+             370:     36(int) Bitcast 369
+             371:     37(ptr) AccessChain 289(u64v) 217
+                              Store 371 370
+             372:   50(ivec2) Load 276(i64v)
+             373:   93(fvec2) Bitcast 372
+             374:  361(fvec3) Load 363(dv)
+             375:  361(fvec3) VectorShuffle 374 373 3 4 2
+                              Store 363(dv) 375
+             376:  130(ivec3) Load 289(u64v)
+             377:  361(fvec3) Bitcast 376
+                              Store 363(dv) 377
+             381:     14(int) ExtInst 1(GLSL.std.450) 0(Unknown) 380
+                              Store 279(i64) 381
+             383:     14(int) Load 279(i64)
+             384:   72(ivec2) ExtInst 1(GLSL.std.450) 0(Unknown) 383
+                              Store 382(iv) 384
+             386:     36(int) ExtInst 1(GLSL.std.450) 0(Unknown) 385
+                              Store 291(u64) 386
+             388:     36(int) Load 291(u64)
+             389:   79(ivec2) ExtInst 1(GLSL.std.450) 0(Unknown) 388
+                              Store 387(uv) 389
+             392:  130(ivec3) Load 289(u64v)
+             393:     36(int) Load 291(u64)
+             394:  130(ivec3) CompositeConstruct 393 393 393
+             395:  358(bvec3) ULessThan 392 394
+                              Store 391(bv) 395
+             396:   50(ivec2) Load 276(i64v)
+             397:     14(int) Load 279(i64)
+             398:   50(ivec2) CompositeConstruct 397 397
+             399:   54(bvec2) SLessThan 396 398
+             400:  358(bvec3) Load 391(bv)
+             401:  358(bvec3) VectorShuffle 400 399 3 4 2
+                              Store 391(bv) 401
+             402:  130(ivec3) Load 289(u64v)
+             403:     36(int) Load 291(u64)
+             404:  130(ivec3) CompositeConstruct 403 403 403
+             405:  358(bvec3) ULessThanEqual 402 404
+                              Store 391(bv) 405
+             406:   50(ivec2) Load 276(i64v)
+             407:     14(int) Load 279(i64)
+             408:   50(ivec2) CompositeConstruct 407 407
+             409:   54(bvec2) SLessThanEqual 406 408
+             410:  358(bvec3) Load 391(bv)
+             411:  358(bvec3) VectorShuffle 410 409 3 4 2
+                              Store 391(bv) 411
+             412:  130(ivec3) Load 289(u64v)
+             413:     36(int) Load 291(u64)
+             414:  130(ivec3) CompositeConstruct 413 413 413
+             415:  358(bvec3) UGreaterThan 412 414
+                              Store 391(bv) 415
+             416:   50(ivec2) Load 276(i64v)
+             417:     14(int) Load 279(i64)
+             418:   50(ivec2) CompositeConstruct 417 417
+             419:   54(bvec2) SGreaterThan 416 418
+             420:  358(bvec3) Load 391(bv)
+             421:  358(bvec3) VectorShuffle 420 419 3 4 2
+                              Store 391(bv) 421
+             422:  130(ivec3) Load 289(u64v)
+             423:     36(int) Load 291(u64)
+             424:  130(ivec3) CompositeConstruct 423 423 423
+             425:  358(bvec3) UGreaterThanEqual 422 424
+                              Store 391(bv) 425
+             426:   50(ivec2) Load 276(i64v)
+             427:     14(int) Load 279(i64)
+             428:   50(ivec2) CompositeConstruct 427 427
+             429:   54(bvec2) SGreaterThanEqual 426 428
+             430:  358(bvec3) Load 391(bv)
+             431:  358(bvec3) VectorShuffle 430 429 3 4 2
+                              Store 391(bv) 431
+             432:  130(ivec3) Load 289(u64v)
+             433:     36(int) Load 291(u64)
+             434:  130(ivec3) CompositeConstruct 433 433 433
+             435:  358(bvec3) IEqual 432 434
+                              Store 391(bv) 435
+             436:   50(ivec2) Load 276(i64v)
+             437:     14(int) Load 279(i64)
+             438:   50(ivec2) CompositeConstruct 437 437
+             439:   54(bvec2) IEqual 436 438
+             440:  358(bvec3) Load 391(bv)
+             441:  358(bvec3) VectorShuffle 440 439 3 4 2
+                              Store 391(bv) 441
+             442:  130(ivec3) Load 289(u64v)
+             443:     36(int) Load 291(u64)
+             444:  130(ivec3) CompositeConstruct 443 443 443
+             445:  358(bvec3) INotEqual 442 444
+                              Store 391(bv) 445
+             446:   50(ivec2) Load 276(i64v)
+             447:     14(int) Load 279(i64)
+             448:   50(ivec2) CompositeConstruct 447 447
+             449:   54(bvec2) INotEqual 446 448
+             450:  358(bvec3) Load 391(bv)
+             451:  358(bvec3) VectorShuffle 450 449 3 4 2
+                              Store 391(bv) 451
+                              Return
+                              FunctionEnd

diff --git a/Test/spv.int64.frag b/Test/spv.int64.frag
new file mode 100644 (file)
index 0000000..527bfef
--- /dev/null
+++ b/Test/spv.int64.frag
@@ -0,0 +1,228 @@
+#version 450\r
+\r
+#extension GL_ARB_gpu_shader_int64: enable\r
+\r
+layout(binding = 0) uniform Uniforms\r
+{\r
+    uint index;\r
+};\r
+\r
+layout(std140, binding = 1) uniform Block\r
+{\r
+    i64vec3  i64v;\r
+    uint64_t u64;\r
+} block;\r
+\r
+void main()\r
+{\r
+}\r
+\r
+void literal()\r
+{\r
+    const int64_t i64Const[3] =\r
+    {\r
+        -0x1111111111111111l,   // Hex\r
+        -1l,                    // Dec\r
+        040000000000l,          // Oct\r
+    };\r
+\r
+    int64_t i64 = i64Const[index];\r
+\r
+    const uint64_t u64Const[] =\r
+    {\r
+        0xFFFFFFFFFFFFFFFFul,   // Hex\r
+        4294967296UL,           // Dec\r
+        077777777777ul,         // Oct\r
+    };\r
+\r
+    uint64_t u64 = u64Const[index];\r
+}\r
+\r
+void typeCast()\r
+{\r
+    bvec2 bv;\r
+    ivec2 iv;\r
+    uvec2 uv;\r
+    vec2  fv;\r
+    dvec2 dv;\r
+\r
+    i64vec2 i64v;\r
+    u64vec2 u64v;\r
+\r
+    i64v = i64vec2(bv);   // bool -> int64\r
+    u64v = u64vec2(bv);   // bool -> uint64\r
+\r
+    i64v = iv;            // int   -> int64\r
+    iv = ivec2(i64v);     // int64 -> int\r
+\r
+    u64v = uv;            // uint   -> uint64\r
+    uv = uvec2(u64v);     // uint64 -> uint\r
+\r
+    fv = vec2(i64v);      // int64 -> float\r
+    dv = i64v;            // int64 -> double\r
+\r
+    fv = vec2(u64v);      // uint64 -> float\r
+    dv = u64v;            // uint64 -> double\r
+\r
+    i64v = i64vec2(fv);   // float  -> int64\r
+    i64v = i64vec2(dv);   // double -> int64\r
+\r
+    u64v = u64vec2(fv);   // float  -> uint64\r
+    u64v = u64vec2(dv);   // double -> uint64\r
+\r
+    bv = bvec2(i64v);     // int64  -> bool\r
+    bv = bvec2(u64v);     // uint64 -> bool\r
+\r
+    u64v = i64v;          // int64  -> uint64\r
+    i64v = i64vec2(u64v); // uint64 -> int64\r
+\r
+    uv = uvec2(i64v);     // int64 -> uint\r
+    i64v = i64vec2(uv);   // uint -> int64\r
+    iv = ivec2(u64v);     // uint64 -> int\r
+    u64v = iv;            // int -> uint64\r
+}\r
+\r
+void operators()\r
+{\r
+    u64vec3 u64v;\r
+    int64_t i64;\r
+    uvec3   uv;\r
+    int     i;\r
+    bool    b;\r
+\r
+    // Unary\r
+    u64v++;\r
+    i64--;\r
+    ++i64;\r
+    --u64v;\r
+\r
+    u64v = ~u64v;\r
+\r
+    i64 = +i64;\r
+    u64v = -u64v;\r
+\r
+    // Arithmetic\r
+    i64  += i64;\r
+    u64v -= u64v;\r
+    i64  *= i;\r
+    u64v /= uv;\r
+    u64v %= i;\r
+\r
+    u64v = u64v + uv;\r
+    i64  = i64 - i;\r
+    u64v = u64v * uv;\r
+    i64  = i64 * i;\r
+    i64  = i64 % i;\r
+\r
+    // Shift\r
+    u64v <<= i;\r
+    i64  >>= uv.y;\r
+\r
+    i64  = i64 << u64v.z;\r
+    u64v = u64v << i64;\r
+\r
+    // Relational\r
+    b = (u64v.x != i64);\r
+    b = (i64 == u64v.x);\r
+    b = (u64v.x > uv.y);\r
+    b = (i64 < i);\r
+    b = (u64v.y >= uv.x);\r
+    b = (i64 <= i);\r
+\r
+    // Bitwise\r
+    u64v |= i;\r
+    i64  = i64 | i;\r
+    i64  &= i;\r
+    u64v = u64v & uv;\r
+    u64v ^= i64;\r
+    u64v = u64v ^ i64;\r
+}\r
+\r
+void builtinFuncs()\r
+{\r
+    i64vec2  i64v;\r
+    u64vec3  u64v;\r
+    dvec3    dv;\r
+    bvec3    bv;\r
+\r
+    int64_t  i64;\r
+    uint64_t u64;\r
+\r
+    // abs()\r
+    i64v = abs(i64v);\r
+\r
+    // sign()\r
+    i64  = sign(i64);\r
+\r
+    // min()\r
+    i64v = min(i64v, i64);\r
+    i64v = min(i64v, i64vec2(-1));\r
+    u64v = min(u64v, u64);\r
+    u64v = min(u64v, u64vec3(0));\r
+\r
+    // max()\r
+    i64v = max(i64v, i64);\r
+    i64v = max(i64v, i64vec2(-1));\r
+    u64v = max(u64v, u64);\r
+    u64v = max(u64v, u64vec3(0));\r
+\r
+    // clamp()\r
+    i64v = clamp(i64v, -i64, i64);\r
+    i64v = clamp(i64v, -i64v, i64v);\r
+    u64v = clamp(u64v, -u64, u64);\r
+    u64v = clamp(u64v, -u64v, u64v);\r
+\r
+    // mix()\r
+    i64  = mix(i64v.x, i64v.y, true);\r
+    i64v = mix(i64vec2(i64), i64vec2(-i64), bvec2(false));\r
+    u64  = mix(u64v.x, u64v.y, true);\r
+    u64v = mix(u64vec3(u64), u64vec3(-u64), bvec3(false));\r
+\r
+    // doubleBitsToInt64()\r
+    i64v = doubleBitsToInt64(dv.xy);\r
+\r
+    // doubleBitsToUint64()\r
+    u64v.x = doubleBitsToUint64(dv.z);\r
+\r
+    // int64BitsToDouble()\r
+    dv.xy = int64BitsToDouble(i64v);\r
+\r
+    // uint64BitsToDouble()\r
+    dv = uint64BitsToDouble(u64v);\r
+\r
+    // packInt2x32()\r
+    i64 = packInt2x32(ivec2(1, 2));\r
+\r
+    // unpackInt2x32()\r
+    ivec2 iv = unpackInt2x32(i64);\r
+\r
+    // packUint2x32()\r
+    u64 = packUint2x32(uvec2(2, 3));\r
+\r
+    // unpackUint2x32()\r
+    uvec2 uv = unpackUint2x32(u64);\r
+\r
+    // lessThan()\r
+    bv    = lessThan(u64v, u64vec3(u64));\r
+    bv.xy = lessThan(i64v, i64vec2(i64));\r
+\r
+    // lessThanEqual()\r
+    bv    = lessThanEqual(u64v, u64vec3(u64));\r
+    bv.xy = lessThanEqual(i64v, i64vec2(i64));\r
+\r
+    // greaterThan()\r
+    bv    = greaterThan(u64v, u64vec3(u64));\r
+    bv.xy = greaterThan(i64v, i64vec2(i64));\r
+\r
+    // greaterThanEqual()\r
+    bv    = greaterThanEqual(u64v, u64vec3(u64));\r
+    bv.xy = greaterThanEqual(i64v, i64vec2(i64));\r
+\r
+    // equal()\r
+    bv    = equal(u64v, u64vec3(u64));\r
+    bv.xy = equal(i64v, i64vec2(i64));\r
+\r
+    // notEqual()\r
+    bv    = notEqual(u64v, u64vec3(u64));\r
+    bv.xy = notEqual(i64v, i64vec2(i64));\r
+}
\ No newline at end of file

diff --git a/Test/test-spirv-list b/Test/test-spirv-list
index b7dfd53..dfc6db7 100644 (file)
--- a/Test/test-spirv-list
+++ b/Test/test-spirv-list
@@ -53,6 +53,7 @@ spv.forwardFun.frag
 spv.functionCall.frag
 spv.functionSemantics.frag
 spv.interpOps.frag
+spv.int64.frag
 spv.layoutNested.vert
 spv.length.frag
 spv.localAggregates.frag

diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h
index 5a57664..ff4b560 100644 (file)
--- a/glslang/Include/BaseTypes.h
+++ b/glslang/Include/BaseTypes.h
@@ -48,6 +48,8 @@ enum TBasicType {
     EbtDouble,
     EbtInt,
     EbtUint,
+    EbtInt64,
+    EbtUint64,
     EbtBool,
     EbtAtomicUint,
     EbtSampler,

diff --git a/glslang/Include/ConstantUnion.h b/glslang/Include/ConstantUnion.h
index c53870d..8ee2c84 100644 (file)
--- a/glslang/Include/ConstantUnion.h
+++ b/glslang/Include/ConstantUnion.h
@@ -57,6 +57,18 @@ public:
         type = EbtUint;
     }
 
+    void setI64Const(long long i64)
+    {
+        i64Const = i64;
+        type = EbtInt64;
+    }
+
+    void setU64Const(unsigned long long u64)
+    {
+        u64Const = u64;
+        type = EbtUint64;
+    }
+
     void setDConst(double d)
     {
         dConst = d; 
@@ -69,10 +81,12 @@ public:
         type = EbtBool;
     }
 
-    int getIConst() const          { return iConst; }
-    unsigned int getUConst() const { return uConst; }
-    double getDConst() const       { return dConst; }
-    bool getBConst() const         { return bConst; }
+    int                getIConst() const   { return iConst; }
+    unsigned int       getUConst() const   { return uConst; }
+    long long          getI64Const() const { return i64Const; }
+    unsigned long long getU64Const() const { return u64Const; }
+    double             getDConst() const   { return dConst; }
+    bool               getBConst() const   { return bConst; }
 
     bool operator==(const int i) const
     {
@@ -82,7 +96,7 @@ public:
         return false;
     }
 
-    bool operator==(unsigned const int u) const
+    bool operator==(const unsigned int u) const
     {
         if (u == uConst)
             return true;
@@ -90,6 +104,22 @@ public:
         return false;
     }
 
+    bool operator==(const long long i64) const
+    {
+        if (i64 == i64Const)
+            return true;
+
+        return false;
+    }
+
+    bool operator==(const unsigned long long u64) const
+    {
+        if (u64 == u64Const)
+            return true;
+
+        return false;
+    }
+
     bool operator==(const double d) const
     {
         if (d == dConst)
@@ -122,6 +152,16 @@ public:
                 return true;
 
             break;
+        case EbtInt64:
+            if (constant.i64Const == i64Const)
+                return true;
+
+            break;
+        case EbtUint64:
+            if (constant.u64Const == u64Const)
+                return true;
+
+            break;
         case EbtDouble:
             if (constant.dConst == dConst)
                 return true;
@@ -149,6 +189,16 @@ public:
         return !operator==(u);
     }
 
+    bool operator!=(const long long i) const
+    {
+        return !operator==(i);
+    }
+
+    bool operator!=(const unsigned long long u) const
+    {
+        return !operator==(u);
+    }
+
     bool operator!=(const float f) const
     {
         return !operator==(f);
@@ -178,6 +228,16 @@ public:
                 return true;
 
             return false;
+        case EbtInt64:
+            if (i64Const > constant.i64Const)
+                return true;
+
+            return false;
+        case EbtUint64:
+            if (u64Const > constant.u64Const)
+                return true;
+
+            return false;
         case EbtDouble:
             if (dConst > constant.dConst)
                 return true;
@@ -203,6 +263,16 @@ public:
                 return true;
 
             return false;
+        case EbtInt64:
+            if (i64Const < constant.i64Const)
+                return true;
+
+            return false;
+        case EbtUint64:
+            if (u64Const < constant.u64Const)
+                return true;
+
+            return false;
         case EbtDouble:
             if (dConst < constant.dConst)
                 return true;
@@ -220,7 +290,9 @@ public:
         assert(type == constant.type);
         switch (type) {
         case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
+        case EbtInt64: returnValue.setI64Const(i64Const + constant.i64Const); break;
         case EbtUint: returnValue.setUConst(uConst + constant.uConst); break;
+        case EbtUint64: returnValue.setU64Const(u64Const + constant.u64Const); break;
         case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break;
         default: assert(false && "Default missing");
         }
@@ -234,7 +306,9 @@ public:
         assert(type == constant.type);
         switch (type) {
         case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
+        case EbtInt64: returnValue.setI64Const(i64Const - constant.i64Const); break;
         case EbtUint: returnValue.setUConst(uConst - constant.uConst); break;
+        case EbtUint64: returnValue.setU64Const(u64Const - constant.u64Const); break;
         case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break;
         default: assert(false && "Default missing");
         }
@@ -248,7 +322,9 @@ public:
         assert(type == constant.type);
         switch (type) {
         case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
+        case EbtInt64: returnValue.setI64Const(i64Const * constant.i64Const); break;
         case EbtUint: returnValue.setUConst(uConst * constant.uConst); break;
+        case EbtUint64: returnValue.setU64Const(u64Const * constant.u64Const); break;
         case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break; 
         default: assert(false && "Default missing");
         }
@@ -261,8 +337,10 @@ public:
         TConstUnion returnValue;
         assert(type == constant.type);
         switch (type) {
-        case EbtInt:  returnValue.setIConst(iConst % constant.iConst); break;
+        case EbtInt: returnValue.setIConst(iConst % constant.iConst); break;
+        case EbtInt64: returnValue.setI64Const(i64Const % constant.i64Const); break;
         case EbtUint: returnValue.setUConst(uConst % constant.uConst); break;
+        case EbtUint64: returnValue.setU64Const(u64Const % constant.u64Const); break;
         default:     assert(false && "Default missing");
         }
 
@@ -275,16 +353,38 @@ public:
         switch (type) {
         case EbtInt:
             switch (constant.type) {
-            case EbtInt:   returnValue.setIConst(iConst >> constant.iConst); break;
-            case EbtUint:  returnValue.setIConst(iConst >> constant.uConst); break;
-            default:       assert(false && "Default missing");           
+            case EbtInt:    returnValue.setIConst(iConst >> constant.iConst);   break;
+            case EbtUint:   returnValue.setIConst(iConst >> constant.uConst);   break;
+            case EbtInt64:  returnValue.setIConst(iConst >> constant.i64Const); break;
+            case EbtUint64: returnValue.setIConst(iConst >> constant.u64Const); break;
+            default:       assert(false && "Default missing");
             }
             break;
         case EbtUint:
             switch (constant.type) {
-            case EbtInt:   returnValue.setUConst(uConst >> constant.iConst); break;
-            case EbtUint:  returnValue.setUConst(uConst >> constant.uConst); break;
-            default:       assert(false && "Default missing");           
+            case EbtInt:    returnValue.setUConst(uConst >> constant.iConst);   break;
+            case EbtUint:   returnValue.setUConst(uConst >> constant.uConst);   break;
+            case EbtInt64:  returnValue.setUConst(uConst >> constant.i64Const); break;
+            case EbtUint64: returnValue.setUConst(uConst >> constant.u64Const); break;
+            default:       assert(false && "Default missing");
+            }
+            break;
+         case EbtInt64:
+            switch (constant.type) {
+            case EbtInt:    returnValue.setI64Const(i64Const >> constant.iConst);   break;
+            case EbtUint:   returnValue.setI64Const(i64Const >> constant.uConst);   break;
+            case EbtInt64:  returnValue.setI64Const(i64Const >> constant.i64Const); break;
+            case EbtUint64: returnValue.setI64Const(i64Const >> constant.u64Const); break;
+            default:       assert(false && "Default missing");
+            }
+            break;
+        case EbtUint64:
+            switch (constant.type) {
+            case EbtInt:    returnValue.setU64Const(u64Const >> constant.iConst);   break;
+            case EbtUint:   returnValue.setU64Const(u64Const >> constant.uConst);   break;
+            case EbtInt64:  returnValue.setU64Const(u64Const >> constant.i64Const); break;
+            case EbtUint64: returnValue.setU64Const(u64Const >> constant.u64Const); break;
+            default:       assert(false && "Default missing");
             }
             break;
         default:     assert(false && "Default missing");
@@ -299,16 +399,38 @@ public:
         switch (type) {
         case EbtInt:
             switch (constant.type) {
-            case EbtInt:   returnValue.setIConst(iConst << constant.iConst); break;
-            case EbtUint:  returnValue.setIConst(iConst << constant.uConst); break;
-            default:       assert(false && "Default missing");           
+            case EbtInt:    returnValue.setIConst(iConst << constant.iConst);   break;
+            case EbtUint:   returnValue.setIConst(iConst << constant.uConst);   break;
+            case EbtInt64:  returnValue.setIConst(iConst << constant.i64Const); break;
+            case EbtUint64: returnValue.setIConst(iConst << constant.u64Const); break;
+            default:       assert(false && "Default missing");
             }
             break;
         case EbtUint:
             switch (constant.type) {
-            case EbtInt:   returnValue.setUConst(uConst << constant.iConst); break;
-            case EbtUint:  returnValue.setUConst(uConst << constant.uConst); break;
-            default:       assert(false && "Default missing");           
+            case EbtInt:    returnValue.setUConst(uConst << constant.iConst);   break;
+            case EbtUint:   returnValue.setUConst(uConst << constant.uConst);   break;
+            case EbtInt64:  returnValue.setUConst(uConst << constant.i64Const); break;
+            case EbtUint64: returnValue.setUConst(uConst << constant.u64Const); break;
+            default:       assert(false && "Default missing");
+            }
+            break;
+        case EbtInt64:
+            switch (constant.type) {
+            case EbtInt:    returnValue.setI64Const(i64Const << constant.iConst);   break;
+            case EbtUint:   returnValue.setI64Const(i64Const << constant.uConst);   break;
+            case EbtInt64:  returnValue.setI64Const(i64Const << constant.i64Const); break;
+            case EbtUint64: returnValue.setI64Const(i64Const << constant.u64Const); break;
+            default:       assert(false && "Default missing");
+            }
+            break;
+        case EbtUint64:
+            switch (constant.type) {
+            case EbtInt:    returnValue.setU64Const(u64Const << constant.iConst);   break;
+            case EbtUint:   returnValue.setU64Const(u64Const << constant.uConst);   break;
+            case EbtInt64:  returnValue.setU64Const(u64Const << constant.i64Const); break;
+            case EbtUint64: returnValue.setU64Const(u64Const << constant.u64Const); break;
+            default:       assert(false && "Default missing");
             }
             break;
         default:     assert(false && "Default missing");
@@ -324,6 +446,8 @@ public:
         switch (type) {
         case EbtInt:  returnValue.setIConst(iConst & constant.iConst); break;
         case EbtUint: returnValue.setUConst(uConst & constant.uConst); break;
+        case EbtInt64:  returnValue.setI64Const(i64Const & constant.i64Const); break;
+        case EbtUint64: returnValue.setU64Const(u64Const & constant.u64Const); break;
         default:     assert(false && "Default missing");
         }
 
@@ -337,6 +461,8 @@ public:
         switch (type) {
         case EbtInt:  returnValue.setIConst(iConst | constant.iConst); break;
         case EbtUint: returnValue.setUConst(uConst | constant.uConst); break;
+        case EbtInt64:  returnValue.setI64Const(i64Const | constant.i64Const); break;
+        case EbtUint64: returnValue.setU64Const(u64Const | constant.u64Const); break;
         default:     assert(false && "Default missing");
         }
 
@@ -350,6 +476,8 @@ public:
         switch (type) {
         case EbtInt:  returnValue.setIConst(iConst ^ constant.iConst); break;
         case EbtUint: returnValue.setUConst(uConst ^ constant.uConst); break;
+        case EbtInt64:  returnValue.setI64Const(i64Const ^ constant.i64Const); break;
+        case EbtUint64: returnValue.setU64Const(u64Const ^ constant.u64Const); break;
         default:     assert(false && "Default missing");
         }
 
@@ -362,6 +490,8 @@ public:
         switch (type) {
         case EbtInt:  returnValue.setIConst(~iConst); break;
         case EbtUint: returnValue.setUConst(~uConst); break;
+        case EbtInt64:  returnValue.setI64Const(~i64Const); break;
+        case EbtUint64: returnValue.setU64Const(~u64Const); break;
         default:     assert(false && "Default missing");
         }
 
@@ -396,10 +526,12 @@ public:
 
 private:
     union  {
-        int iConst;          // used for ivec, scalar ints
-        unsigned int uConst; // used for uvec, scalar uints
-        bool bConst;         // used for bvec, scalar bools
-        double dConst;       // used for vec, dvec, mat, dmat, scalar floats and doubles
+        int                iConst;      // used for ivec, scalar ints
+        unsigned int       uConst;      // used for uvec, scalar uints
+        long long          i64Const;    // used for i64vec, scalar int64s
+        unsigned long long u64Const;    // used for u64vec, scalar uint64s
+        bool               bConst;      // used for bvec, scalar bools
+        double             dConst;      // used for vec, dvec, mat, dmat, scalar floats and doubles
     };
 
     TBasicType type;

diff --git a/glslang/Include/Types.h b/glslang/Include/Types.h
index e28e5b2..38a27d4 100644 (file)
--- a/glslang/Include/Types.h
+++ b/glslang/Include/Types.h
@@ -182,6 +182,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
         case EbtFloat:               break;
         case EbtInt:  s.append("i"); break;
         case EbtUint: s.append("u"); break;
+        case EbtInt64:  s.append("i64"); break;
+        case EbtUint64: s.append("u64"); break;
         default:  break;  // some compilers want this
         }
         if (image) {
@@ -1319,6 +1321,8 @@ public:
         case EbtDouble:
         case EbtInt:
         case EbtUint:
+        case EbtInt64:
+        case EbtUint64:
         case EbtBool:
             return true;
         default:
@@ -1409,6 +1413,8 @@ public:
         case EbtDouble:            return "double";
         case EbtInt:               return "int";
         case EbtUint:              return "uint";
+        case EbtInt64:             return "int64_t";
+        case EbtUint64:            return "uint64_t";
         case EbtBool:              return "bool";
         case EbtAtomicUint:        return "atomic_uint";
         case EbtSampler:           return "sampler/image";

diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
index ab17701..1dd55a7 100644 (file)
--- a/glslang/Include/intermediate.h
+++ b/glslang/Include/intermediate.h
@@ -81,22 +81,44 @@ enum TOperator {
     EOpConvUintToBool,
     EOpConvFloatToBool,
     EOpConvDoubleToBool,
+    EOpConvInt64ToBool,
+    EOpConvUint64ToBool,
     EOpConvBoolToFloat,
     EOpConvIntToFloat,
     EOpConvUintToFloat,
     EOpConvDoubleToFloat,
+    EOpConvInt64ToFloat,
+    EOpConvUint64ToFloat,
     EOpConvUintToInt,
     EOpConvFloatToInt,
     EOpConvBoolToInt,
     EOpConvDoubleToInt,
+    EOpConvInt64ToInt,
+    EOpConvUint64ToInt,
     EOpConvIntToUint,
     EOpConvFloatToUint,
     EOpConvBoolToUint,
     EOpConvDoubleToUint,
+    EOpConvInt64ToUint,
+    EOpConvUint64ToUint,
     EOpConvIntToDouble,
     EOpConvUintToDouble,
     EOpConvFloatToDouble,
     EOpConvBoolToDouble,
+    EOpConvInt64ToDouble,
+    EOpConvUint64ToDouble,
+    EOpConvBoolToInt64,
+    EOpConvIntToInt64,
+    EOpConvUintToInt64,
+    EOpConvFloatToInt64,
+    EOpConvDoubleToInt64,
+    EOpConvUint64ToInt64,
+    EOpConvBoolToUint64,
+    EOpConvIntToUint64,
+    EOpConvUintToUint64,
+    EOpConvFloatToUint64,
+    EOpConvDoubleToUint64,
+    EOpConvInt64ToUint64,
 
     //
     // binary operations
@@ -194,6 +216,10 @@ enum TOperator {
     EOpFloatBitsToUint,
     EOpIntBitsToFloat,
     EOpUintBitsToFloat,
+    EOpDoubleBitsToInt64,
+    EOpDoubleBitsToUint64,
+    EOpInt64BitsToDouble,
+    EOpUint64BitsToDouble,
     EOpPackSnorm2x16,
     EOpUnpackSnorm2x16,
     EOpPackUnorm2x16,
@@ -206,6 +232,10 @@ enum TOperator {
     EOpUnpackHalf2x16,
     EOpPackDouble2x32,
     EOpUnpackDouble2x32,
+    EOpPackInt2x32,
+    EOpUnpackInt2x32,
+    EOpPackUint2x32,
+    EOpUnpackUint2x32,
 
     EOpLength,
     EOpDistance,
@@ -287,6 +317,8 @@ enum TOperator {
     EOpConstructGuardStart,
     EOpConstructInt,          // these first scalar forms also identify what implicit conversion is needed
     EOpConstructUint,
+    EOpConstructInt64,
+    EOpConstructUint64,
     EOpConstructBool,
     EOpConstructFloat,
     EOpConstructDouble,
@@ -305,6 +337,12 @@ enum TOperator {
     EOpConstructUVec2,
     EOpConstructUVec3,
     EOpConstructUVec4,
+    EOpConstructI64Vec2,
+    EOpConstructI64Vec3,
+    EOpConstructI64Vec4,
+    EOpConstructU64Vec2,
+    EOpConstructU64Vec3,
+    EOpConstructU64Vec4,
     EOpConstructMat2x2,
     EOpConstructMat2x3,
     EOpConstructMat2x4,

diff --git a/glslang/MachineIndependent/Constant.cpp b/glslang/MachineIndependent/Constant.cpp
index db2f70d..03033bc 100644 (file)
--- a/glslang/MachineIndependent/Constant.cpp
+++ b/glslang/MachineIndependent/Constant.cpp
@@ -194,6 +194,22 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right
                 } else
                     newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst());
                 break;
+
+            case EbtInt64:
+                if (rightUnionArray[i] == 0)
+                    newConstArray[i].setI64Const(0x7FFFFFFFFFFFFFFFll);
+                else if (rightUnionArray[i].getI64Const() == -1 && leftUnionArray[i].getI64Const() == (long long)0x8000000000000000)
+                    newConstArray[i].setI64Const(0x8000000000000000);
+                else
+                    newConstArray[i].setI64Const(leftUnionArray[i].getI64Const() / rightUnionArray[i].getI64Const());
+                break;
+
+            case EbtUint64:
+                if (rightUnionArray[i] == 0) {
+                    newConstArray[i].setU64Const(0xFFFFFFFFFFFFFFFFull);
+                } else
+                    newConstArray[i].setU64Const(leftUnionArray[i].getU64Const() / rightUnionArray[i].getU64Const());
+                break;
             default:
                 return 0;
             }
@@ -419,6 +435,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
             case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break;
             case EbtInt:   newConstArray[i].setIConst(-unionArray[i].getIConst()); break;
             case EbtUint:  newConstArray[i].setUConst(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getUConst())));  break;
+            case EbtInt64: newConstArray[i].setI64Const(-unionArray[i].getI64Const()); break;
+            case EbtUint64: newConstArray[i].setU64Const(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getU64Const())));  break;
             default:
                 return 0;
             }
@@ -566,6 +584,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
         case EOpFloatBitsToUint:
         case EOpIntBitsToFloat:
         case EOpUintBitsToFloat:
+        case EOpDoubleBitsToInt64:
+        case EOpDoubleBitsToUint64:
 
         default:
             return 0;
@@ -651,7 +671,10 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
 
     bool isFloatingPoint = children[0]->getAsTyped()->getBasicType() == EbtFloat ||
                            children[0]->getAsTyped()->getBasicType() == EbtDouble;
-    bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt;
+    bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt ||
+                    children[0]->getAsTyped()->getBasicType() == EbtInt64;
+    bool isInt64 = children[0]->getAsTyped()->getBasicType() == EbtInt64 ||
+                   children[0]->getAsTyped()->getBasicType() == EbtUint64;
     if (componentwise) {
         for (int comp = 0; comp < objectSize; comp++) {
 
@@ -674,29 +697,52 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             case EOpMin:
                 if (isFloatingPoint)
                     newConstArray[comp].setDConst(std::min(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
-                else if (isSigned)
-                    newConstArray[comp].setIConst(std::min(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()));
-                else
-                    newConstArray[comp].setUConst(std::min(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()));
+                else if (isSigned) {
+                    if (isInt64)
+                        newConstArray[comp].setI64Const(std::min(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const()));
+                    else
+                        newConstArray[comp].setIConst(std::min(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()));
+                } else {
+                    if (isInt64)
+                        newConstArray[comp].setU64Const(std::min(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const()));
+                    else
+                        newConstArray[comp].setUConst(std::min(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()));
+                }
                 break;
             case EOpMax:
                 if (isFloatingPoint)
                     newConstArray[comp].setDConst(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
-                else if (isSigned)
-                    newConstArray[comp].setIConst(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()));
-                else
-                    newConstArray[comp].setUConst(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()));
+                else if (isSigned) {
+                    if (isInt64)
+                        newConstArray[comp].setI64Const(std::max(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const()));
+                    else
+                        newConstArray[comp].setIConst(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()));
+                } else {
+                    if (isInt64)
+                        newConstArray[comp].setU64Const(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const()));
+                    else
+                        newConstArray[comp].setUConst(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()));
+                }
                 break;
             case EOpClamp:
                 if (isFloatingPoint)
-                    newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()), 
+                    newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()),
                                                                                                                childConstUnions[2][arg2comp].getDConst()));
-                else if (isSigned)
-                    newConstArray[comp].setIConst(std::min(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()), 
-                                                                                                               childConstUnions[2][arg2comp].getIConst()));
-                else
-                    newConstArray[comp].setUConst(std::min(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()), 
-                                                                                                               childConstUnions[2][arg2comp].getUConst()));
+                else if (isSigned) {
+                    if (isInt64)
+                        newConstArray[comp].setI64Const(std::min(std::max(childConstUnions[0][arg0comp].getI64Const(), childConstUnions[1][arg1comp].getI64Const()),
+                                                                                                                       childConstUnions[2][arg2comp].getI64Const()));
+                    else
+                        newConstArray[comp].setIConst(std::min(std::max(childConstUnions[0][arg0comp].getIConst(), childConstUnions[1][arg1comp].getIConst()),
+                                                                                                                   childConstUnions[2][arg2comp].getIConst()));
+                } else {
+                    if (isInt64)
+                        newConstArray[comp].setU64Const(std::min(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const()),
+                                                                                                                       childConstUnions[2][arg2comp].getU64Const()));
+                    else
+                        newConstArray[comp].setUConst(std::min(std::max(childConstUnions[0][arg0comp].getUConst(), childConstUnions[1][arg1comp].getUConst()),
+                                                                                                                   childConstUnions[2][arg2comp].getUConst()));
+                }
                 break;
             case EOpLessThan:
                 newConstArray[comp].setBConst(childConstUnions[0][arg0comp] < childConstUnions[1][arg1comp]);

diff --git a/glslang/MachineIndependent/Initialize.cpp b/glslang/MachineIndependent/Initialize.cpp
index 446c51c..e2bd453 100644 (file)
--- a/glslang/MachineIndependent/Initialize.cpp
+++ b/glslang/MachineIndependent/Initialize.cpp
@@ -75,6 +75,8 @@ TBuiltIns::TBuiltIns()
     prefixes[EbtFloat] =  "";
     prefixes[EbtInt]   = "i";
     prefixes[EbtUint]  = "u";
+    prefixes[EbtInt64]  = "i64";
+    prefixes[EbtUint64] = "u64";
     postfixes[2] = "2";
     postfixes[3] = "3";
     postfixes[4] = "4";
@@ -626,6 +628,145 @@ void TBuiltIns::initialize(int version, EProfile profile, int spv, int vulkan)
             "dmat2 inverse(dmat2);"
             "dmat3 inverse(dmat3);"
             "dmat4 inverse(dmat4);"
+
+            "\n");
+    }
+
+    if (profile != EEsProfile && version >= 450) {
+        commonBuiltins.append(
+
+            "int64_t abs(int64_t);"
+            "i64vec2 abs(i64vec2);"
+            "i64vec3 abs(i64vec3);"
+            "i64vec4 abs(i64vec4);"
+
+            "int64_t sign(int64_t);"
+            "i64vec2 sign(i64vec2);"
+            "i64vec3 sign(i64vec3);"
+            "i64vec4 sign(i64vec4);"
+
+            "int64_t  min(int64_t,  int64_t);"
+            "i64vec2  min(i64vec2,  int64_t);"
+            "i64vec3  min(i64vec3,  int64_t);"
+            "i64vec4  min(i64vec4,  int64_t);"
+            "i64vec2  min(i64vec2,  i64vec2);"
+            "i64vec3  min(i64vec3,  i64vec3);"
+            "i64vec4  min(i64vec4,  i64vec4);"
+            "uint64_t min(uint64_t, uint64_t);"
+            "u64vec2  min(u64vec2,  uint64_t);"
+            "u64vec3  min(u64vec3,  uint64_t);"
+            "u64vec4  min(u64vec4,  uint64_t);"
+            "u64vec2  min(u64vec2,  u64vec2);"
+            "u64vec3  min(u64vec3,  u64vec3);"
+            "u64vec4  min(u64vec4,  u64vec4);"
+
+            "int64_t  max(int64_t,  int64_t);"
+            "i64vec2  max(i64vec2,  int64_t);"
+            "i64vec3  max(i64vec3,  int64_t);"
+            "i64vec4  max(i64vec4,  int64_t);"
+            "i64vec2  max(i64vec2,  i64vec2);"
+            "i64vec3  max(i64vec3,  i64vec3);"
+            "i64vec4  max(i64vec4,  i64vec4);"
+            "uint64_t max(uint64_t, uint64_t);"
+            "u64vec2  max(u64vec2,  uint64_t);"
+            "u64vec3  max(u64vec3,  uint64_t);"
+            "u64vec4  max(u64vec4,  uint64_t);"
+            "u64vec2  max(u64vec2,  u64vec2);"
+            "u64vec3  max(u64vec3,  u64vec3);"
+            "u64vec4  max(u64vec4,  u64vec4);"
+
+            "int64_t  clamp(int64_t,  int64_t,  int64_t);"
+            "i64vec2  clamp(i64vec2,  int64_t,  int64_t);"
+            "i64vec3  clamp(i64vec3,  int64_t,  int64_t);"
+            "i64vec4  clamp(i64vec4,  int64_t,  int64_t);"
+            "i64vec2  clamp(i64vec2,  i64vec2,  i64vec2);"
+            "i64vec3  clamp(i64vec3,  i64vec3,  i64vec3);"
+            "i64vec4  clamp(i64vec4,  i64vec4,  i64vec4);"
+            "uint64_t clamp(uint64_t, uint64_t, uint64_t);"
+            "u64vec2  clamp(u64vec2,  uint64_t, uint64_t);"
+            "u64vec3  clamp(u64vec3,  uint64_t, uint64_t);"
+            "u64vec4  clamp(u64vec4,  uint64_t, uint64_t);"
+            "u64vec2  clamp(u64vec2,  u64vec2,  u64vec2);"
+            "u64vec3  clamp(u64vec3,  u64vec3,  u64vec3);"
+            "u64vec4  clamp(u64vec4,  u64vec4,  u64vec4);"
+
+            "int64_t  mix(int64_t,  int64_t,  bool);"
+            "i64vec2  mix(i64vec2,  i64vec2,  bvec2);"
+            "i64vec3  mix(i64vec3,  i64vec3,  bvec3);"
+            "i64vec4  mix(i64vec4,  i64vec4,  bvec4);"
+            "uint64_t mix(uint64_t, uint64_t, bool);"
+            "u64vec2  mix(u64vec2,  u64vec2,  bvec2);"
+            "u64vec3  mix(u64vec3,  u64vec3,  bvec3);"
+            "u64vec4  mix(u64vec4,  u64vec4,  bvec4);"
+
+            "int64_t doubleBitsToInt64(double);"
+            "i64vec2 doubleBitsToInt64(dvec2);"
+            "i64vec3 doubleBitsToInt64(dvec3);"
+            "i64vec4 doubleBitsToInt64(dvec4);"
+
+            "uint64_t doubleBitsToUint64(double);"
+            "u64vec2  doubleBitsToUint64(dvec2);"
+            "u64vec3  doubleBitsToUint64(dvec3);"
+            "u64vec4  doubleBitsToUint64(dvec4);"
+
+            "double int64BitsToDouble(int64_t);"
+            "dvec2  int64BitsToDouble(i64vec2);"
+            "dvec3  int64BitsToDouble(i64vec3);"
+            "dvec4  int64BitsToDouble(i64vec4);"
+
+            "double uint64BitsToDouble(uint64_t);"
+            "dvec2  uint64BitsToDouble(u64vec2);"
+            "dvec3  uint64BitsToDouble(u64vec3);"
+            "dvec4  uint64BitsToDouble(u64vec4);"
+
+            "int64_t  packInt2x32(ivec2);"
+            "uint64_t packUint2x32(uvec2);"
+            "ivec2    unpackInt2x32(int64_t);"
+            "uvec2    unpackUint2x32(uint64_t);"
+
+            "bvec2 lessThan(i64vec2, i64vec2);"
+            "bvec3 lessThan(i64vec3, i64vec3);"
+            "bvec4 lessThan(i64vec4, i64vec4);"
+            "bvec2 lessThan(u64vec2, u64vec2);"
+            "bvec3 lessThan(u64vec3, u64vec3);"
+            "bvec4 lessThan(u64vec4, u64vec4);"
+
+            "bvec2 lessThanEqual(i64vec2, i64vec2);"
+            "bvec3 lessThanEqual(i64vec3, i64vec3);"
+            "bvec4 lessThanEqual(i64vec4, i64vec4);"
+            "bvec2 lessThanEqual(u64vec2, u64vec2);"
+            "bvec3 lessThanEqual(u64vec3, u64vec3);"
+            "bvec4 lessThanEqual(u64vec4, u64vec4);"
+
+            "bvec2 greaterThan(i64vec2, i64vec2);"
+            "bvec3 greaterThan(i64vec3, i64vec3);"
+            "bvec4 greaterThan(i64vec4, i64vec4);"
+            "bvec2 greaterThan(u64vec2, u64vec2);"
+            "bvec3 greaterThan(u64vec3, u64vec3);"
+            "bvec4 greaterThan(u64vec4, u64vec4);"
+
+            "bvec2 greaterThanEqual(i64vec2, i64vec2);"
+            "bvec3 greaterThanEqual(i64vec3, i64vec3);"
+            "bvec4 greaterThanEqual(i64vec4, i64vec4);"
+            "bvec2 greaterThanEqual(u64vec2, u64vec2);"
+            "bvec3 greaterThanEqual(u64vec3, u64vec3);"
+            "bvec4 greaterThanEqual(u64vec4, u64vec4);"
+
+            "bvec2 equal(i64vec2, i64vec2);"
+            "bvec3 equal(i64vec3, i64vec3);"
+            "bvec4 equal(i64vec4, i64vec4);"
+            "bvec2 equal(u64vec2, u64vec2);"
+            "bvec3 equal(u64vec3, u64vec3);"
+            "bvec4 equal(u64vec4, u64vec4);"
+
+            "bvec2 notEqual(i64vec2, i64vec2);"
+            "bvec3 notEqual(i64vec3, i64vec3);"
+            "bvec4 notEqual(i64vec4, i64vec4);"
+            "bvec2 notEqual(u64vec2, u64vec2);"
+            "bvec3 notEqual(u64vec3, u64vec3);"
+            "bvec4 notEqual(u64vec4, u64vec4);"
+
+            "\n"
         );
     }
 
@@ -3650,6 +3791,10 @@ void IdentifyBuiltIns(int version, EProfile profile, int spv, int vulkan, EShLan
     symbolTable.relateToOperator("floatBitsToUint", EOpFloatBitsToUint);
     symbolTable.relateToOperator("intBitsToFloat",  EOpIntBitsToFloat);
     symbolTable.relateToOperator("uintBitsToFloat", EOpUintBitsToFloat);
+    symbolTable.relateToOperator("doubleBitsToInt64",  EOpDoubleBitsToInt64);
+    symbolTable.relateToOperator("doubleBitsToUint64", EOpDoubleBitsToUint64);
+    symbolTable.relateToOperator("int64BitsToDouble",  EOpInt64BitsToDouble);
+    symbolTable.relateToOperator("uint64BitsToDouble", EOpUint64BitsToDouble);
 
     symbolTable.relateToOperator("packSnorm2x16",   EOpPackSnorm2x16);
     symbolTable.relateToOperator("unpackSnorm2x16", EOpUnpackSnorm2x16);
@@ -3667,6 +3812,11 @@ void IdentifyBuiltIns(int version, EProfile profile, int spv, int vulkan, EShLan
     symbolTable.relateToOperator("packHalf2x16",    EOpPackHalf2x16);
     symbolTable.relateToOperator("unpackHalf2x16",  EOpUnpackHalf2x16);
 
+    symbolTable.relateToOperator("packInt2x32",     EOpPackInt2x32);
+    symbolTable.relateToOperator("unpackInt2x32",   EOpUnpackInt2x32);
+    symbolTable.relateToOperator("packUint2x32",    EOpPackUint2x32);
+    symbolTable.relateToOperator("unpackUint2x32",  EOpUnpackUint2x32);
+
     symbolTable.relateToOperator("length",       EOpLength);
     symbolTable.relateToOperator("distance",     EOpDistance);
     symbolTable.relateToOperator("dot",          EOpDot);

diff --git a/glslang/MachineIndependent/Intermediate.cpp b/glslang/MachineIndependent/Intermediate.cpp
index d0fa74e..47a9367 100644 (file)
--- a/glslang/MachineIndependent/Intermediate.cpp
+++ b/glslang/MachineIndependent/Intermediate.cpp
@@ -247,6 +247,8 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo
     switch (op) {
     case EOpConstructInt:    newType = EbtInt;    break;
     case EOpConstructUint:   newType = EbtUint;   break;
+    case EOpConstructInt64:  newType = EbtInt64;  break;
+    case EOpConstructUint64: newType = EbtUint64; break;
     case EOpConstructBool:   newType = EbtBool;   break;
     case EOpConstructFloat:  newType = EbtFloat;  break;
     case EOpConstructDouble: newType = EbtDouble; break;
@@ -269,6 +271,8 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo
     switch (op) {
     case EOpConstructInt:
     case EOpConstructUint:
+    case EOpConstructInt64:
+    case EOpConstructUint64:
     case EOpConstructBool:
     case EOpConstructFloat:
     case EOpConstructDouble:
@@ -472,6 +476,12 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpConstructUint:
         promoteTo = EbtUint;
         break;
+    case EOpConstructInt64:
+        promoteTo = EbtInt64;
+        break;
+    case EOpConstructUint64:
+        promoteTo = EbtUint64;
+        break;
 
     //
     // List all the binary ops that can implicitly convert one operand to the other's type;
@@ -498,6 +508,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpAnd:
     case EOpInclusiveOr:
     case EOpExclusiveOr:
+    case EOpAndAssign:
+    case EOpInclusiveOrAssign:
+    case EOpExclusiveOrAssign:
 
     case EOpFunctionCall:
     case EOpReturn:
@@ -531,9 +544,13 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpLeftShiftAssign:
     case EOpRightShiftAssign:
         if ((type.getBasicType() == EbtInt ||
-             type.getBasicType() == EbtUint) &&
+             type.getBasicType() == EbtUint ||
+             type.getBasicType() == EbtInt64 ||
+             type.getBasicType() == EbtUint64) &&
             (node->getType().getBasicType() == EbtInt ||
-             node->getType().getBasicType() == EbtUint))
+             node->getType().getBasicType() == EbtUint ||
+             node->getType().getBasicType() == EbtInt64 ||
+             node->getType().getBasicType() == EbtUint64))
 
             return node;
         else
@@ -567,6 +584,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EbtUint:  newOp = EOpConvUintToDouble;  break;
         case EbtBool:  newOp = EOpConvBoolToDouble;  break;
         case EbtFloat: newOp = EOpConvFloatToDouble; break;
+        case EbtInt64: newOp = EOpConvInt64ToDouble; break;
+        case EbtUint64: newOp = EOpConvUint64ToDouble; break;
         default:
             return 0;
         }
@@ -577,6 +596,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EbtUint:   newOp = EOpConvUintToFloat;   break;
         case EbtBool:   newOp = EOpConvBoolToFloat;   break;
         case EbtDouble: newOp = EOpConvDoubleToFloat; break;
+        case EbtInt64:  newOp = EOpConvInt64ToFloat;  break;
+        case EbtUint64: newOp = EOpConvUint64ToFloat; break;
         default:
             return 0;
         }
@@ -587,6 +608,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EbtUint:   newOp = EOpConvUintToBool;   break;
         case EbtFloat:  newOp = EOpConvFloatToBool;  break;
         case EbtDouble: newOp = EOpConvDoubleToBool; break;
+        case EbtInt64:  newOp = EOpConvInt64ToBool;  break;
+        case EbtUint64: newOp = EOpConvUint64ToBool; break;
         default:
             return 0;
         }
@@ -597,6 +620,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EbtBool:   newOp = EOpConvBoolToInt;   break;
         case EbtFloat:  newOp = EOpConvFloatToInt;  break;
         case EbtDouble: newOp = EOpConvDoubleToInt; break;
+        case EbtInt64:  newOp = EOpConvInt64ToInt;  break;
+        case EbtUint64: newOp = EOpConvUint64ToInt; break;
         default:
             return 0;
         }
@@ -607,6 +632,32 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EbtBool:   newOp = EOpConvBoolToUint;   break;
         case EbtFloat:  newOp = EOpConvFloatToUint;  break;
         case EbtDouble: newOp = EOpConvDoubleToUint; break;
+        case EbtInt64:  newOp = EOpConvInt64ToUint;  break;
+        case EbtUint64: newOp = EOpConvUint64ToUint; break;
+        default:
+            return 0;
+        }
+        break;
+    case EbtInt64:
+        switch (node->getBasicType()) {
+        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 EbtUint64: newOp = EOpConvUint64ToInt64; break;
+        default:
+            return 0;
+        }
+        break;
+    case EbtUint64:
+        switch (node->getBasicType()) {
+        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 EbtInt64:  newOp = EOpConvInt64ToUint64;  break;
         default:
             return 0;
         }
@@ -643,6 +694,8 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to) const
         switch (from) {
         case EbtInt:
         case EbtUint:
+        case EbtInt64:
+        case EbtUint64:
         case EbtFloat:
         case EbtDouble:
             return true;
@@ -674,6 +727,24 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to) const
         default:
             return false;
         }
+    case EbtUint64:
+        switch (from) {
+        case EbtInt:
+        case EbtUint:
+        case EbtInt64:
+        case EbtUint64:
+            return true;
+        default:
+            return false;
+        }
+    case EbtInt64:
+        switch (from) {
+        case EbtInt:
+        case EbtInt64:
+            return true;
+        default:
+            return false;
+        }
     default:
         return false;
     }
@@ -873,6 +944,22 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned int u, const TSou
     return addConstantUnion(unionArray, TType(EbtUint, EvqConst), loc, literal);
 }
 
+TIntermConstantUnion* TIntermediate::addConstantUnion(long long i64, const TSourceLoc& loc, bool literal) const
+{
+    TConstUnionArray unionArray(1);
+    unionArray[0].setI64Const(i64);
+
+    return addConstantUnion(unionArray, TType(EbtInt64, EvqConst), loc, literal);
+}
+
+TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned long long u64, const TSourceLoc& loc, bool literal) const
+{
+    TConstUnionArray unionArray(1);
+    unionArray[0].setU64Const(u64);
+
+    return addConstantUnion(unionArray, TType(EbtUint64, EvqConst), loc, literal);
+}
+
 TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& loc, bool literal) const
 {
     TConstUnionArray unionArray(1);
@@ -1212,7 +1299,9 @@ bool TIntermUnary::promote()
         break;
     case EOpBitwiseNot:
         if (operand->getBasicType() != EbtInt &&
-            operand->getBasicType() != EbtUint)
+            operand->getBasicType() != EbtUint &&
+            operand->getBasicType() != EbtInt64 &&
+            operand->getBasicType() != EbtUint64)
 
             return false;
         break;
@@ -1223,6 +1312,8 @@ bool TIntermUnary::promote()
     case EOpPreDecrement:
         if (operand->getBasicType() != EbtInt &&
             operand->getBasicType() != EbtUint &&
+            operand->getBasicType() != EbtInt64 &&
+            operand->getBasicType() != EbtUint64 &&
             operand->getBasicType() != EbtFloat &&
             operand->getBasicType() != EbtDouble)
 
@@ -1340,8 +1431,10 @@ bool TIntermBinary::promote()
     case EOpInclusiveOrAssign:
     case EOpExclusiveOrAssign:
         // Check for integer-only operands.
-        if (( left->getBasicType() != EbtInt &&  left->getBasicType() != EbtUint) ||
-            (right->getBasicType() != EbtInt && right->getBasicType() != EbtUint))
+        if ((left->getBasicType() != EbtInt &&  left->getBasicType() != EbtUint &&
+             left->getBasicType() != EbtInt64 &&  left->getBasicType() != EbtUint64) ||
+            (right->getBasicType() != EbtInt && right->getBasicType() != EbtUint &&
+             right->getBasicType() != EbtInt64 && right->getBasicType() != EbtUint64))
             return false;
         if (left->isMatrix() || right->isMatrix())
             return false;
@@ -1643,6 +1736,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
             case EbtUint:
                 leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getUConst()));
                 break;
+            case EbtInt64:
+                leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getI64Const()));
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getU64Const()));
+                break;
             case EbtBool:
                 leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getBConst()));
                 break;
@@ -1664,6 +1763,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
             case EbtUint:
                 leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getUConst()));
                 break;
+            case EbtInt64:
+                leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getI64Const()));
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getU64Const()));
+                break;
             case EbtBool:
                 leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getBConst()));
                 break;
@@ -1683,6 +1788,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
             case EbtUint:
                 leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getUConst()));
                 break;
+            case EbtInt64:
+                leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getI64Const()));
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getU64Const()));
+                break;
             case EbtBool:
                 leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
                 break;
@@ -1702,6 +1813,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
             case EbtUint:
                 leftUnionArray[i] = rightUnionArray[i];
                 break;
+            case EbtInt64:
+                leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getI64Const()));
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getU64Const()));
+                break;
             case EbtBool:
                 leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getBConst()));
                 break;
@@ -1721,6 +1838,12 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
             case EbtUint:
                 leftUnionArray[i].setBConst(rightUnionArray[i].getUConst() != 0);
                 break;
+            case EbtInt64:
+                leftUnionArray[i].setBConst(rightUnionArray[i].getI64Const() != 0);
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setBConst(rightUnionArray[i].getU64Const() != 0);
+                break;
             case EbtBool:
                 leftUnionArray[i] = rightUnionArray[i];
                 break;
@@ -1732,6 +1855,56 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
                 return node;
             }
             break;
+        case EbtInt64:
+            switch (node->getType().getBasicType()) {
+            case EbtInt:
+                leftUnionArray[i].setI64Const(static_cast<long long>(rightUnionArray[i].getIConst()));
+                break;
+            case EbtUint:
+                leftUnionArray[i].setI64Const(static_cast<long long>(rightUnionArray[i].getUConst()));
+                break;
+            case EbtInt64:
+                leftUnionArray[i] = rightUnionArray[i];
+                break;
+            case EbtUint64:
+                leftUnionArray[i].setI64Const(static_cast<long long>(rightUnionArray[i].getU64Const()));
+                break;
+            case EbtBool:
+                leftUnionArray[i].setI64Const(static_cast<long long>(rightUnionArray[i].getBConst()));
+                break;
+            case EbtFloat:
+            case EbtDouble:
+                leftUnionArray[i].setI64Const(static_cast<long long>(rightUnionArray[i].getDConst()));
+                break;
+            default:
+                return node;
+            }
+            break;
+        case EbtUint64:
+            switch (node->getType().getBasicType()) {
+            case EbtInt:
+                leftUnionArray[i].setU64Const(static_cast<unsigned long long>(rightUnionArray[i].getIConst()));
+                break;
+            case EbtUint:
+                leftUnionArray[i].setU64Const(static_cast<unsigned long long>(rightUnionArray[i].getUConst()));
+                break;
+            case EbtInt64:
+                leftUnionArray[i].setU64Const(static_cast<unsigned long long>(rightUnionArray[i].getI64Const()));
+                break;
+            case EbtUint64:
+                leftUnionArray[i] = rightUnionArray[i];
+                break;
+            case EbtBool:
+                leftUnionArray[i].setU64Const(static_cast<unsigned long long>(rightUnionArray[i].getBConst()));
+                break;
+            case EbtFloat:
+            case EbtDouble:
+                leftUnionArray[i].setU64Const(static_cast<unsigned long long>(rightUnionArray[i].getDConst()));
+                break;
+            default:
+                return node;
+            }
+            break;
         default:
             return node;
         }

diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
index 4c1b7a0..c9ca5d3 100644 (file)
--- a/glslang/MachineIndependent/ParseHelper.cpp
+++ b/glslang/MachineIndependent/ParseHelper.cpp
@@ -1812,6 +1812,24 @@ TOperator TParseContext::mapTypeToConstructorOp(const TType& type) const
         default: break; // some compilers want this
         }
         break;
+    case EbtInt64:
+        switch(type.getVectorSize()) {
+        case 1: op = EOpConstructInt64;   break;
+        case 2: op = EOpConstructI64Vec2; break;
+        case 3: op = EOpConstructI64Vec3; break;
+        case 4: op = EOpConstructI64Vec4; break;
+        default: break; // some compilers want this
+        }
+        break;
+    case EbtUint64:
+        switch(type.getVectorSize()) {
+        case 1: op = EOpConstructUint64;  break;
+        case 2: op = EOpConstructU64Vec2; break;
+        case 3: op = EOpConstructU64Vec3; break;
+        case 4: op = EOpConstructU64Vec4; break;
+        default: break; // some compilers want this
+        }
+        break;
     case EbtBool:
         switch(type.getVectorSize()) {
         case 1:  op = EOpConstructBool;  break;
@@ -2534,13 +2552,19 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali
         return;
     }
 
-    if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || publicType.basicType == EbtDouble)
+    if (publicType.basicType == EbtInt   || publicType.basicType == EbtUint   ||
+        publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 ||
+        publicType.basicType == EbtDouble)
         profileRequires(loc, EEsProfile, 300, nullptr, "shader input/output");
 
     if (! qualifier.flat) {
-        if (publicType.basicType == EbtInt || publicType.basicType == EbtUint || publicType.basicType == EbtDouble ||
-            (publicType.userDef && (publicType.userDef->containsBasicType(EbtInt) ||
-                                    publicType.userDef->containsBasicType(EbtUint) || 
+        if (publicType.basicType == EbtInt    || publicType.basicType == EbtUint   ||
+            publicType.basicType == EbtInt64  || publicType.basicType == EbtUint64 ||
+            publicType.basicType == EbtDouble ||
+            (publicType.userDef && (publicType.userDef->containsBasicType(EbtInt)    ||
+                                    publicType.userDef->containsBasicType(EbtUint)   ||
+                                    publicType.userDef->containsBasicType(EbtInt64)  ||
+                                    publicType.userDef->containsBasicType(EbtUint64) ||
                                     publicType.userDef->containsBasicType(EbtDouble)))) {
             if (qualifier.storage == EvqVaryingIn && language == EShLangFragment)
                 error(loc, "must be qualified as flat", TType::getBasicString(publicType.basicType), GetStorageQualifierString(qualifier.storage));
@@ -4415,6 +4439,8 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
         {
         case EbtInt:
         case EbtUint:
+        case EbtInt64:
+        case EbtUint64:
         case EbtBool:
         case EbtFloat:
         case EbtDouble:
@@ -5226,6 +5252,20 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
         basicOp = EOpConstructUint;
         break;
 
+    case EOpConstructI64Vec2:
+    case EOpConstructI64Vec3:
+    case EOpConstructI64Vec4:
+    case EOpConstructInt64:
+        basicOp = EOpConstructInt64;
+        break;
+
+    case EOpConstructU64Vec2:
+    case EOpConstructU64Vec3:
+    case EOpConstructU64Vec4:
+    case EOpConstructUint64:
+        basicOp = EOpConstructUint64;
+        break;
+
     case EOpConstructBVec2:
     case EOpConstructBVec3:
     case EOpConstructBVec4:

diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
index 098f0bd..762fb86 100644 (file)
--- a/glslang/MachineIndependent/Scan.cpp
+++ b/glslang/MachineIndependent/Scan.cpp
@@ -454,6 +454,15 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["uvec3"] =                   UVEC3;
     (*KeywordMap)["uvec4"] =                   UVEC4;
 
+    (*KeywordMap)["int64_t"] =                 INT64_T;
+    (*KeywordMap)["uint64_t"] =                UINT64_T;
+    (*KeywordMap)["i64vec2"] =                 I64VEC2;
+    (*KeywordMap)["i64vec3"] =                 I64VEC3;
+    (*KeywordMap)["i64vec4"] =                 I64VEC4;
+    (*KeywordMap)["u64vec2"] =                 U64VEC2;
+    (*KeywordMap)["u64vec3"] =                 U64VEC3;
+    (*KeywordMap)["u64vec4"] =                 U64VEC4;
+
     (*KeywordMap)["sampler2D"] =               SAMPLER2D;
     (*KeywordMap)["samplerCube"] =             SAMPLERCUBE;
     (*KeywordMap)["samplerCubeArray"] =        SAMPLERCUBEARRAY;
@@ -667,10 +676,12 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
         case PpAtomDecrement:          return DEC_OP;
         case PpAtomIncrement:          return INC_OP;
                                    
-        case PpAtomConstInt:           parserToken->sType.lex.i = ppToken.ival;       return INTCONSTANT;
-        case PpAtomConstUint:          parserToken->sType.lex.i = ppToken.ival;       return UINTCONSTANT;
-        case PpAtomConstFloat:         parserToken->sType.lex.d = ppToken.dval;       return FLOATCONSTANT;
-        case PpAtomConstDouble:        parserToken->sType.lex.d = ppToken.dval;       return DOUBLECONSTANT;
+        case PpAtomConstInt:           parserToken->sType.lex.i   = ppToken.ival;       return INTCONSTANT;
+        case PpAtomConstUint:          parserToken->sType.lex.i   = ppToken.ival;       return UINTCONSTANT;
+        case PpAtomConstInt64:         parserToken->sType.lex.i64 = ppToken.i64val;     return INT64CONSTANT;
+        case PpAtomConstUint64:        parserToken->sType.lex.i64 = ppToken.i64val;     return UINT64CONSTANT;
+        case PpAtomConstFloat:         parserToken->sType.lex.d   = ppToken.dval;       return FLOATCONSTANT;
+        case PpAtomConstDouble:        parserToken->sType.lex.d   = ppToken.dval;       return DOUBLECONSTANT;
         case PpAtomIdentifier:
         {
             int token = tokenizeIdentifier();
@@ -914,6 +925,18 @@ int TScanContext::tokenizeIdentifier()
             reservedWord();
         return keyword;
 
+    case INT64_T:
+    case UINT64_T:
+    case I64VEC2:
+    case I64VEC3:
+    case I64VEC4:
+    case U64VEC2:
+    case U64VEC3:
+    case U64VEC4:
+        if (parseContext.profile != EEsProfile && parseContext.version >= 450)
+            return keyword;
+        return identifierOrType();
+
     case SAMPLERCUBEARRAY:
     case SAMPLERCUBEARRAYSHADOW:
     case ISAMPLERCUBEARRAY:

diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp
index 75f5040..4c9b0e2 100644 (file)
--- a/glslang/MachineIndependent/SymbolTable.cpp
+++ b/glslang/MachineIndependent/SymbolTable.cpp
@@ -62,6 +62,8 @@ void TType::buildMangledName(TString& mangledName)
     case EbtDouble:             mangledName += 'd';      break;
     case EbtInt:                mangledName += 'i';      break;
     case EbtUint:               mangledName += 'u';      break;
+    case EbtInt64:              mangledName += "i64";    break;
+    case EbtUint64:             mangledName += "u64";    break;
     case EbtBool:               mangledName += 'b';      break;
     case EbtAtomicUint:         mangledName += "au";     break;
     case EbtSampler:

diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
index af2f7f2..019caf9 100644 (file)
--- a/glslang/MachineIndependent/Versions.cpp
+++ b/glslang/MachineIndependent/Versions.cpp
@@ -174,6 +174,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_ARB_derivative_control]           = EBhDisable;
     extensionBehavior[E_GL_ARB_shader_texture_image_samples] = EBhDisable;
     extensionBehavior[E_GL_ARB_viewport_array]               = EBhDisable;
+    extensionBehavior[E_GL_ARB_gpu_shader_int64]             = EBhDisable;
     extensionBehavior[E_GL_ARB_gl_spirv]                     = EBhDisable;
     extensionBehavior[E_GL_ARB_sparse_texture2]              = EBhDisable;
     extensionBehavior[E_GL_ARB_sparse_texture_clamp]         = EBhDisable;
@@ -278,6 +279,7 @@ const char* TParseVersions::getPreamble()
             "#define GL_ARB_derivative_control 1\n"
             "#define GL_ARB_shader_texture_image_samples 1\n"
             "#define GL_ARB_viewport_array 1\n"
+            "#define GL_ARB_gpu_shader_int64 1\n"
             "#define GL_ARB_gl_spirv 1\n"
             "#define GL_ARB_sparse_texture2 1\n"
             "#define GL_ARB_sparse_texture_clamp 1\n"
@@ -627,6 +629,17 @@ void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op)
     profileRequires(loc, ECompatibilityProfile, 400, nullptr, op);
 }
 
+// Call for any operation needing GLSL 64-bit integer data-type support.
+void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (! builtIn) {
+        requireExtensions(loc, 1, &E_GL_ARB_gpu_shader_int64, "shader int64");
+        requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
+        profileRequires(loc, ECoreProfile, 450, nullptr, op);
+        profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);
+    }
+}
+
 // Call for any operation removed because SPIR-V is in use.
 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
 {

diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
index d022d87..779ba9f 100644 (file)
--- a/glslang/MachineIndependent/Versions.h
+++ b/glslang/MachineIndependent/Versions.h
@@ -111,6 +111,7 @@ const char* const E_GL_ARB_shader_draw_parameters       = "GL_ARB_shader_draw_pa
 const char* const E_GL_ARB_derivative_control           = "GL_ARB_derivative_control";
 const char* const E_GL_ARB_shader_texture_image_samples = "GL_ARB_shader_texture_image_samples";
 const char* const E_GL_ARB_viewport_array               = "GL_ARB_viewport_array";
+const char* const E_GL_ARB_gpu_shader_int64             = "GL_ARB_gpu_shader_int64";
 const char* const E_GL_ARB_gl_spirv                     = "GL_ARB_gl_spirv";
 const char* const E_GL_ARB_sparse_texture2              = "GL_ARB_sparse_texture2";
 const char* const E_GL_ARB_sparse_texture_clamp         = "GL_ARB_sparse_texture_clamp";

diff --git a/glslang/MachineIndependent/gl_types.h b/glslang/MachineIndependent/gl_types.h
index 91603b5..9e877d3 100644 (file)
--- a/glslang/MachineIndependent/gl_types.h
+++ b/glslang/MachineIndependent/gl_types.h
@@ -41,6 +41,16 @@
 #define GL_UNSIGNED_INT_VEC3              0x8DC7
 #define GL_UNSIGNED_INT_VEC4              0x8DC8
 
+#define GL_INT64_ARB                      0x140E
+#define GL_INT64_VEC2_ARB                 0x8FE9
+#define GL_INT64_VEC3_ARB                 0x8FEA
+#define GL_INT64_VEC4_ARB                 0x8FEB
+
+#define GL_UNSIGNED_INT64_ARB             0x140F
+#define GL_UNSIGNED_INT64_VEC2_ARB        0x8FE5
+#define GL_UNSIGNED_INT64_VEC3_ARB        0x8FE6
+#define GL_UNSIGNED_INT64_VEC4_ARB        0x8FE7
+
 #define GL_BOOL                           0x8B56
 #define GL_BOOL_VEC2                      0x8B57
 #define GL_BOOL_VEC3                      0x8B58

diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
index 847bcc9..976c995 100644 (file)
--- a/glslang/MachineIndependent/glslang.y
+++ b/glslang/MachineIndependent/glslang.y
@@ -70,6 +70,8 @@ using namespace glslang;
             glslang::TString *string;
             int i;
             unsigned int u;
+            long long i64;
+            unsigned long long u64;
             bool b;
             double d;
         };
@@ -117,9 +119,9 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %expect 1     // One shift reduce conflict because of if | else
 
 %token <lex> ATTRIBUTE VARYING
-%token <lex> CONST BOOL FLOAT DOUBLE INT UINT
+%token <lex> CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T
 %token <lex> BREAK CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT SUBROUTINE
-%token <lex> BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 UVEC2 UVEC3 UVEC4 VEC2 VEC3 VEC4
+%token <lex> BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 I64VEC2 I64VEC3 I64VEC4 UVEC2 UVEC3 UVEC4 U64VEC2 U64VEC3 U64VEC4 VEC2 VEC3 VEC4
 %token <lex> MAT2 MAT3 MAT4 CENTROID IN OUT INOUT
 %token <lex> UNIFORM PATCH SAMPLE BUFFER SHARED
 %token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY
@@ -180,7 +182,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> STRUCT VOID WHILE
 
 %token <lex> IDENTIFIER TYPE_NAME
-%token <lex> FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT BOOLCONSTANT
+%token <lex> FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT BOOLCONSTANT
 %token <lex> LEFT_OP RIGHT_OP
 %token <lex> INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP
 %token <lex> AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN
@@ -257,6 +259,14 @@ primary_expression
         parseContext.fullIntegerCheck($1.loc, "unsigned literal");
         $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
     }
+    | INT64CONSTANT {
+        parseContext.int64Check($1.loc, "64-bit integer literal");
+        $$ = parseContext.intermediate.addConstantUnion($1.i64, $1.loc, true);
+    }
+    | UINT64CONSTANT {
+        parseContext.int64Check($1.loc, "64-bit unsigned integer literal");
+        $$ = parseContext.intermediate.addConstantUnion($1.u64, $1.loc, true);
+    }
     | FLOATCONSTANT {
         $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
     }
@@ -1309,6 +1319,16 @@ type_specifier_nonarray
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtUint;
     }
+    | INT64_T {
+        parseContext.int64Check($1.loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt64;
+    }
+    | UINT64_T {
+        parseContext.int64Check($1.loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtUint64;
+    }
     | BOOL {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtBool;
@@ -1376,6 +1396,24 @@ type_specifier_nonarray
         $$.basicType = EbtInt;
         $$.setVector(4);
     }
+    | I64VEC2 {
+        parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt64;
+        $$.setVector(2);
+    }
+    | I64VEC3 {
+        parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt64;
+        $$.setVector(3);
+    }
+    | I64VEC4 {
+        parseContext.int64Check($1.loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtInt64;
+        $$.setVector(4);
+    }
     | UVEC2 {
         parseContext.fullIntegerCheck($1.loc, "unsigned integer vector");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
@@ -1394,6 +1432,24 @@ type_specifier_nonarray
         $$.basicType = EbtUint;
         $$.setVector(4);
     }
+    | U64VEC2 {
+        parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtUint64;
+        $$.setVector(2);
+    }
+    | U64VEC3 {
+        parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtUint64;
+        $$.setVector(3);
+    }
+    | U64VEC4 {
+        parseContext.int64Check($1.loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtUint64;
+        $$.setVector(4);
+    }
     | MAT2 {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtFloat;

diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
index d435aa8..18c1a2f 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp
+++ b/glslang/MachineIndependent/glslang_tab.cpp
@@ -63,7 +63,7 @@
 
 /* Copy the first part of user declarations.  */
 /* Line 371 of yacc.c  */
-#line 41 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 41 "glslang.y"
 
 
 /* Based on:
@@ -89,7 +89,7 @@ using namespace glslang;
 
 
 /* Line 371 of yacc.c  */
-#line 93 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp"
+#line 93 "glslang_tab.cpp"
 
 # ifndef YY_NULL
 #  if defined __cplusplus && 201103L <= __cplusplus
@@ -109,8 +109,8 @@ using namespace glslang;
 
 /* In a future release of Bison, this section will be replaced
    by #include "glslang_tab.cpp.h".  */
-#ifndef YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -133,255 +133,265 @@ extern int yydebug;
      DOUBLE = 263,
      INT = 264,
      UINT = 265,
-     BREAK = 266,
-     CONTINUE = 267,
-     DO = 268,
-     ELSE = 269,
-     FOR = 270,
-     IF = 271,
-     DISCARD = 272,
-     RETURN = 273,
-     SWITCH = 274,
-     CASE = 275,
-     DEFAULT = 276,
-     SUBROUTINE = 277,
-     BVEC2 = 278,
-     BVEC3 = 279,
-     BVEC4 = 280,
-     IVEC2 = 281,
-     IVEC3 = 282,
-     IVEC4 = 283,
-     UVEC2 = 284,
-     UVEC3 = 285,
-     UVEC4 = 286,
-     VEC2 = 287,
-     VEC3 = 288,
-     VEC4 = 289,
-     MAT2 = 290,
-     MAT3 = 291,
-     MAT4 = 292,
-     CENTROID = 293,
-     IN = 294,
-     OUT = 295,
-     INOUT = 296,
-     UNIFORM = 297,
-     PATCH = 298,
-     SAMPLE = 299,
-     BUFFER = 300,
-     SHARED = 301,
-     COHERENT = 302,
-     VOLATILE = 303,
-     RESTRICT = 304,
-     READONLY = 305,
-     WRITEONLY = 306,
-     DVEC2 = 307,
-     DVEC3 = 308,
-     DVEC4 = 309,
-     DMAT2 = 310,
-     DMAT3 = 311,
-     DMAT4 = 312,
-     NOPERSPECTIVE = 313,
-     FLAT = 314,
-     SMOOTH = 315,
-     LAYOUT = 316,
-     MAT2X2 = 317,
-     MAT2X3 = 318,
-     MAT2X4 = 319,
-     MAT3X2 = 320,
-     MAT3X3 = 321,
-     MAT3X4 = 322,
-     MAT4X2 = 323,
-     MAT4X3 = 324,
-     MAT4X4 = 325,
-     DMAT2X2 = 326,
-     DMAT2X3 = 327,
-     DMAT2X4 = 328,
-     DMAT3X2 = 329,
-     DMAT3X3 = 330,
-     DMAT3X4 = 331,
-     DMAT4X2 = 332,
-     DMAT4X3 = 333,
-     DMAT4X4 = 334,
-     ATOMIC_UINT = 335,
-     SAMPLER1D = 336,
-     SAMPLER2D = 337,
-     SAMPLER3D = 338,
-     SAMPLERCUBE = 339,
-     SAMPLER1DSHADOW = 340,
-     SAMPLER2DSHADOW = 341,
-     SAMPLERCUBESHADOW = 342,
-     SAMPLER1DARRAY = 343,
-     SAMPLER2DARRAY = 344,
-     SAMPLER1DARRAYSHADOW = 345,
-     SAMPLER2DARRAYSHADOW = 346,
-     ISAMPLER1D = 347,
-     ISAMPLER2D = 348,
-     ISAMPLER3D = 349,
-     ISAMPLERCUBE = 350,
-     ISAMPLER1DARRAY = 351,
-     ISAMPLER2DARRAY = 352,
-     USAMPLER1D = 353,
-     USAMPLER2D = 354,
-     USAMPLER3D = 355,
-     USAMPLERCUBE = 356,
-     USAMPLER1DARRAY = 357,
-     USAMPLER2DARRAY = 358,
-     SAMPLER2DRECT = 359,
-     SAMPLER2DRECTSHADOW = 360,
-     ISAMPLER2DRECT = 361,
-     USAMPLER2DRECT = 362,
-     SAMPLERBUFFER = 363,
-     ISAMPLERBUFFER = 364,
-     USAMPLERBUFFER = 365,
-     SAMPLERCUBEARRAY = 366,
-     SAMPLERCUBEARRAYSHADOW = 367,
-     ISAMPLERCUBEARRAY = 368,
-     USAMPLERCUBEARRAY = 369,
-     SAMPLER2DMS = 370,
-     ISAMPLER2DMS = 371,
-     USAMPLER2DMS = 372,
-     SAMPLER2DMSARRAY = 373,
-     ISAMPLER2DMSARRAY = 374,
-     USAMPLER2DMSARRAY = 375,
-     SAMPLEREXTERNALOES = 376,
-     SAMPLER = 377,
-     SAMPLERSHADOW = 378,
-     TEXTURE1D = 379,
-     TEXTURE2D = 380,
-     TEXTURE3D = 381,
-     TEXTURECUBE = 382,
-     TEXTURE1DARRAY = 383,
-     TEXTURE2DARRAY = 384,
-     ITEXTURE1D = 385,
-     ITEXTURE2D = 386,
-     ITEXTURE3D = 387,
-     ITEXTURECUBE = 388,
-     ITEXTURE1DARRAY = 389,
-     ITEXTURE2DARRAY = 390,
-     UTEXTURE1D = 391,
-     UTEXTURE2D = 392,
-     UTEXTURE3D = 393,
-     UTEXTURECUBE = 394,
-     UTEXTURE1DARRAY = 395,
-     UTEXTURE2DARRAY = 396,
-     TEXTURE2DRECT = 397,
-     ITEXTURE2DRECT = 398,
-     UTEXTURE2DRECT = 399,
-     TEXTUREBUFFER = 400,
-     ITEXTUREBUFFER = 401,
-     UTEXTUREBUFFER = 402,
-     TEXTURECUBEARRAY = 403,
-     ITEXTURECUBEARRAY = 404,
-     UTEXTURECUBEARRAY = 405,
-     TEXTURE2DMS = 406,
-     ITEXTURE2DMS = 407,
-     UTEXTURE2DMS = 408,
-     TEXTURE2DMSARRAY = 409,
-     ITEXTURE2DMSARRAY = 410,
-     UTEXTURE2DMSARRAY = 411,
-     SUBPASSINPUT = 412,
-     SUBPASSINPUTMS = 413,
-     ISUBPASSINPUT = 414,
-     ISUBPASSINPUTMS = 415,
-     USUBPASSINPUT = 416,
-     USUBPASSINPUTMS = 417,
-     IMAGE1D = 418,
-     IIMAGE1D = 419,
-     UIMAGE1D = 420,
-     IMAGE2D = 421,
-     IIMAGE2D = 422,
-     UIMAGE2D = 423,
-     IMAGE3D = 424,
-     IIMAGE3D = 425,
-     UIMAGE3D = 426,
-     IMAGE2DRECT = 427,
-     IIMAGE2DRECT = 428,
-     UIMAGE2DRECT = 429,
-     IMAGECUBE = 430,
-     IIMAGECUBE = 431,
-     UIMAGECUBE = 432,
-     IMAGEBUFFER = 433,
-     IIMAGEBUFFER = 434,
-     UIMAGEBUFFER = 435,
-     IMAGE1DARRAY = 436,
-     IIMAGE1DARRAY = 437,
-     UIMAGE1DARRAY = 438,
-     IMAGE2DARRAY = 439,
-     IIMAGE2DARRAY = 440,
-     UIMAGE2DARRAY = 441,
-     IMAGECUBEARRAY = 442,
-     IIMAGECUBEARRAY = 443,
-     UIMAGECUBEARRAY = 444,
-     IMAGE2DMS = 445,
-     IIMAGE2DMS = 446,
-     UIMAGE2DMS = 447,
-     IMAGE2DMSARRAY = 448,
-     IIMAGE2DMSARRAY = 449,
-     UIMAGE2DMSARRAY = 450,
-     STRUCT = 451,
-     VOID = 452,
-     WHILE = 453,
-     IDENTIFIER = 454,
-     TYPE_NAME = 455,
-     FLOATCONSTANT = 456,
-     DOUBLECONSTANT = 457,
-     INTCONSTANT = 458,
-     UINTCONSTANT = 459,
-     BOOLCONSTANT = 460,
-     LEFT_OP = 461,
-     RIGHT_OP = 462,
-     INC_OP = 463,
-     DEC_OP = 464,
-     LE_OP = 465,
-     GE_OP = 466,
-     EQ_OP = 467,
-     NE_OP = 468,
-     AND_OP = 469,
-     OR_OP = 470,
-     XOR_OP = 471,
-     MUL_ASSIGN = 472,
-     DIV_ASSIGN = 473,
-     ADD_ASSIGN = 474,
-     MOD_ASSIGN = 475,
-     LEFT_ASSIGN = 476,
-     RIGHT_ASSIGN = 477,
-     AND_ASSIGN = 478,
-     XOR_ASSIGN = 479,
-     OR_ASSIGN = 480,
-     SUB_ASSIGN = 481,
-     LEFT_PAREN = 482,
-     RIGHT_PAREN = 483,
-     LEFT_BRACKET = 484,
-     RIGHT_BRACKET = 485,
-     LEFT_BRACE = 486,
-     RIGHT_BRACE = 487,
-     DOT = 488,
-     COMMA = 489,
-     COLON = 490,
-     EQUAL = 491,
-     SEMICOLON = 492,
-     BANG = 493,
-     DASH = 494,
-     TILDE = 495,
-     PLUS = 496,
-     STAR = 497,
-     SLASH = 498,
-     PERCENT = 499,
-     LEFT_ANGLE = 500,
-     RIGHT_ANGLE = 501,
-     VERTICAL_BAR = 502,
-     CARET = 503,
-     AMPERSAND = 504,
-     QUESTION = 505,
-     INVARIANT = 506,
-     PRECISE = 507,
-     HIGH_PRECISION = 508,
-     MEDIUM_PRECISION = 509,
-     LOW_PRECISION = 510,
-     PRECISION = 511,
-     PACKED = 512,
-     RESOURCE = 513,
-     SUPERP = 514
+     INT64_T = 266,
+     UINT64_T = 267,
+     BREAK = 268,
+     CONTINUE = 269,
+     DO = 270,
+     ELSE = 271,
+     FOR = 272,
+     IF = 273,
+     DISCARD = 274,
+     RETURN = 275,
+     SWITCH = 276,
+     CASE = 277,
+     DEFAULT = 278,
+     SUBROUTINE = 279,
+     BVEC2 = 280,
+     BVEC3 = 281,
+     BVEC4 = 282,
+     IVEC2 = 283,
+     IVEC3 = 284,
+     IVEC4 = 285,
+     I64VEC2 = 286,
+     I64VEC3 = 287,
+     I64VEC4 = 288,
+     UVEC2 = 289,
+     UVEC3 = 290,
+     UVEC4 = 291,
+     U64VEC2 = 292,
+     U64VEC3 = 293,
+     U64VEC4 = 294,
+     VEC2 = 295,
+     VEC3 = 296,
+     VEC4 = 297,
+     MAT2 = 298,
+     MAT3 = 299,
+     MAT4 = 300,
+     CENTROID = 301,
+     IN = 302,
+     OUT = 303,
+     INOUT = 304,
+     UNIFORM = 305,
+     PATCH = 306,
+     SAMPLE = 307,
+     BUFFER = 308,
+     SHARED = 309,
+     COHERENT = 310,
+     VOLATILE = 311,
+     RESTRICT = 312,
+     READONLY = 313,
+     WRITEONLY = 314,
+     DVEC2 = 315,
+     DVEC3 = 316,
+     DVEC4 = 317,
+     DMAT2 = 318,
+     DMAT3 = 319,
+     DMAT4 = 320,
+     NOPERSPECTIVE = 321,
+     FLAT = 322,
+     SMOOTH = 323,
+     LAYOUT = 324,
+     MAT2X2 = 325,
+     MAT2X3 = 326,
+     MAT2X4 = 327,
+     MAT3X2 = 328,
+     MAT3X3 = 329,
+     MAT3X4 = 330,
+     MAT4X2 = 331,
+     MAT4X3 = 332,
+     MAT4X4 = 333,
+     DMAT2X2 = 334,
+     DMAT2X3 = 335,
+     DMAT2X4 = 336,
+     DMAT3X2 = 337,
+     DMAT3X3 = 338,
+     DMAT3X4 = 339,
+     DMAT4X2 = 340,
+     DMAT4X3 = 341,
+     DMAT4X4 = 342,
+     ATOMIC_UINT = 343,
+     SAMPLER1D = 344,
+     SAMPLER2D = 345,
+     SAMPLER3D = 346,
+     SAMPLERCUBE = 347,
+     SAMPLER1DSHADOW = 348,
+     SAMPLER2DSHADOW = 349,
+     SAMPLERCUBESHADOW = 350,
+     SAMPLER1DARRAY = 351,
+     SAMPLER2DARRAY = 352,
+     SAMPLER1DARRAYSHADOW = 353,
+     SAMPLER2DARRAYSHADOW = 354,
+     ISAMPLER1D = 355,
+     ISAMPLER2D = 356,
+     ISAMPLER3D = 357,
+     ISAMPLERCUBE = 358,
+     ISAMPLER1DARRAY = 359,
+     ISAMPLER2DARRAY = 360,
+     USAMPLER1D = 361,
+     USAMPLER2D = 362,
+     USAMPLER3D = 363,
+     USAMPLERCUBE = 364,
+     USAMPLER1DARRAY = 365,
+     USAMPLER2DARRAY = 366,
+     SAMPLER2DRECT = 367,
+     SAMPLER2DRECTSHADOW = 368,
+     ISAMPLER2DRECT = 369,
+     USAMPLER2DRECT = 370,
+     SAMPLERBUFFER = 371,
+     ISAMPLERBUFFER = 372,
+     USAMPLERBUFFER = 373,
+     SAMPLERCUBEARRAY = 374,
+     SAMPLERCUBEARRAYSHADOW = 375,
+     ISAMPLERCUBEARRAY = 376,
+     USAMPLERCUBEARRAY = 377,
+     SAMPLER2DMS = 378,
+     ISAMPLER2DMS = 379,
+     USAMPLER2DMS = 380,
+     SAMPLER2DMSARRAY = 381,
+     ISAMPLER2DMSARRAY = 382,
+     USAMPLER2DMSARRAY = 383,
+     SAMPLEREXTERNALOES = 384,
+     SAMPLER = 385,
+     SAMPLERSHADOW = 386,
+     TEXTURE1D = 387,
+     TEXTURE2D = 388,
+     TEXTURE3D = 389,
+     TEXTURECUBE = 390,
+     TEXTURE1DARRAY = 391,
+     TEXTURE2DARRAY = 392,
+     ITEXTURE1D = 393,
+     ITEXTURE2D = 394,
+     ITEXTURE3D = 395,
+     ITEXTURECUBE = 396,
+     ITEXTURE1DARRAY = 397,
+     ITEXTURE2DARRAY = 398,
+     UTEXTURE1D = 399,
+     UTEXTURE2D = 400,
+     UTEXTURE3D = 401,
+     UTEXTURECUBE = 402,
+     UTEXTURE1DARRAY = 403,
+     UTEXTURE2DARRAY = 404,
+     TEXTURE2DRECT = 405,
+     ITEXTURE2DRECT = 406,
+     UTEXTURE2DRECT = 407,
+     TEXTUREBUFFER = 408,
+     ITEXTUREBUFFER = 409,
+     UTEXTUREBUFFER = 410,
+     TEXTURECUBEARRAY = 411,
+     ITEXTURECUBEARRAY = 412,
+     UTEXTURECUBEARRAY = 413,
+     TEXTURE2DMS = 414,
+     ITEXTURE2DMS = 415,
+     UTEXTURE2DMS = 416,
+     TEXTURE2DMSARRAY = 417,
+     ITEXTURE2DMSARRAY = 418,
+     UTEXTURE2DMSARRAY = 419,
+     SUBPASSINPUT = 420,
+     SUBPASSINPUTMS = 421,
+     ISUBPASSINPUT = 422,
+     ISUBPASSINPUTMS = 423,
+     USUBPASSINPUT = 424,
+     USUBPASSINPUTMS = 425,
+     IMAGE1D = 426,
+     IIMAGE1D = 427,
+     UIMAGE1D = 428,
+     IMAGE2D = 429,
+     IIMAGE2D = 430,
+     UIMAGE2D = 431,
+     IMAGE3D = 432,
+     IIMAGE3D = 433,
+     UIMAGE3D = 434,
+     IMAGE2DRECT = 435,
+     IIMAGE2DRECT = 436,
+     UIMAGE2DRECT = 437,
+     IMAGECUBE = 438,
+     IIMAGECUBE = 439,
+     UIMAGECUBE = 440,
+     IMAGEBUFFER = 441,
+     IIMAGEBUFFER = 442,
+     UIMAGEBUFFER = 443,
+     IMAGE1DARRAY = 444,
+     IIMAGE1DARRAY = 445,
+     UIMAGE1DARRAY = 446,
+     IMAGE2DARRAY = 447,
+     IIMAGE2DARRAY = 448,
+     UIMAGE2DARRAY = 449,
+     IMAGECUBEARRAY = 450,
+     IIMAGECUBEARRAY = 451,
+     UIMAGECUBEARRAY = 452,
+     IMAGE2DMS = 453,
+     IIMAGE2DMS = 454,
+     UIMAGE2DMS = 455,
+     IMAGE2DMSARRAY = 456,
+     IIMAGE2DMSARRAY = 457,
+     UIMAGE2DMSARRAY = 458,
+     STRUCT = 459,
+     VOID = 460,
+     WHILE = 461,
+     IDENTIFIER = 462,
+     TYPE_NAME = 463,
+     FLOATCONSTANT = 464,
+     DOUBLECONSTANT = 465,
+     INTCONSTANT = 466,
+     UINTCONSTANT = 467,
+     INT64CONSTANT = 468,
+     UINT64CONSTANT = 469,
+     BOOLCONSTANT = 470,
+     LEFT_OP = 471,
+     RIGHT_OP = 472,
+     INC_OP = 473,
+     DEC_OP = 474,
+     LE_OP = 475,
+     GE_OP = 476,
+     EQ_OP = 477,
+     NE_OP = 478,
+     AND_OP = 479,
+     OR_OP = 480,
+     XOR_OP = 481,
+     MUL_ASSIGN = 482,
+     DIV_ASSIGN = 483,
+     ADD_ASSIGN = 484,
+     MOD_ASSIGN = 485,
+     LEFT_ASSIGN = 486,
+     RIGHT_ASSIGN = 487,
+     AND_ASSIGN = 488,
+     XOR_ASSIGN = 489,
+     OR_ASSIGN = 490,
+     SUB_ASSIGN = 491,
+     LEFT_PAREN = 492,
+     RIGHT_PAREN = 493,
+     LEFT_BRACKET = 494,
+     RIGHT_BRACKET = 495,
+     LEFT_BRACE = 496,
+     RIGHT_BRACE = 497,
+     DOT = 498,
+     COMMA = 499,
+     COLON = 500,
+     EQUAL = 501,
+     SEMICOLON = 502,
+     BANG = 503,
+     DASH = 504,
+     TILDE = 505,
+     PLUS = 506,
+     STAR = 507,
+     SLASH = 508,
+     PERCENT = 509,
+     LEFT_ANGLE = 510,
+     RIGHT_ANGLE = 511,
+     VERTICAL_BAR = 512,
+     CARET = 513,
+     AMPERSAND = 514,
+     QUESTION = 515,
+     INVARIANT = 516,
+     PRECISE = 517,
+     HIGH_PRECISION = 518,
+     MEDIUM_PRECISION = 519,
+     LOW_PRECISION = 520,
+     PRECISION = 521,
+     PACKED = 522,
+     RESOURCE = 523,
+     SUPERP = 524
    };
 #endif
 
@@ -390,7 +400,7 @@ extern int yydebug;
 typedef union YYSTYPE
 {
 /* Line 387 of yacc.c  */
-#line 66 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 66 "glslang.y"
 
     struct {
         glslang::TSourceLoc loc;
@@ -398,6 +408,8 @@ typedef union YYSTYPE
             glslang::TString *string;
             int i;
             unsigned int u;
+            long long i64;
+            unsigned long long u64;
             bool b;
             double d;
         };
@@ -424,7 +436,7 @@ typedef union YYSTYPE
 
 
 /* Line 387 of yacc.c  */
-#line 428 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp"
+#line 440 "glslang_tab.cpp"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -446,11 +458,11 @@ int yyparse ();
 #endif
 #endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */
 
 /* Copy the second part of user declarations.  */
 /* Line 390 of yacc.c  */
-#line 98 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 100 "glslang.y"
 
 
 /* windows only pragma */
@@ -467,7 +479,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 
 
 /* Line 390 of yacc.c  */
-#line 471 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp"
+#line 483 "glslang_tab.cpp"
 
 #ifdef short
 # undef short
@@ -685,22 +697,22 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  240
+#define YYFINAL  248
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   5659
+#define YYLAST   5943
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  260
+#define YYNTOKENS  270
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  100
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  411
+#define YYNRULES  421
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  543
+#define YYNSTATES  553
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   514
+#define YYMAXUTOK   524
 
 #define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -759,7 +771,8 @@ static const yytype_uint16 yytranslate[] =
      225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
      235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
      245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
-     255,   256,   257,   258,   259
+     255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269
 };
 
 #if YYDEBUG
@@ -768,23 +781,23 @@ static const yytype_uint16 yytranslate[] =
 static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
-      21,    23,    28,    30,    34,    37,    40,    42,    44,    46,
-      49,    52,    55,    57,    60,    64,    67,    69,    71,    73,
-      76,    79,    82,    84,    86,    88,    90,    92,    96,   100,
-     104,   106,   110,   114,   116,   120,   124,   126,   130,   134,
-     138,   142,   144,   148,   152,   154,   158,   160,   164,   166,
-     170,   172,   176,   178,   182,   184,   188,   190,   191,   198,
-     200,   204,   206,   208,   210,   212,   214,   216,   218,   220,
-     222,   224,   226,   228,   232,   234,   237,   240,   245,   248,
-     252,   257,   260,   264,   269,   270,   277,   280,   284,   287,
-     289,   291,   294,   298,   302,   305,   309,   312,   314,   317,
-     319,   321,   323,   327,   332,   339,   345,   347,   350,   354,
-     360,   365,   367,   370,   372,   374,   376,   378,   383,   385,
-     389,   391,   395,   397,   399,   401,   404,   406,   408,   410,
+      19,    21,    25,    27,    32,    34,    38,    41,    44,    46,
+      48,    50,    53,    56,    59,    61,    64,    68,    71,    73,
+      75,    77,    80,    83,    86,    88,    90,    92,    94,    96,
+     100,   104,   108,   110,   114,   118,   120,   124,   128,   130,
+     134,   138,   142,   146,   148,   152,   156,   158,   162,   164,
+     168,   170,   174,   176,   180,   182,   186,   188,   192,   194,
+     195,   202,   204,   208,   210,   212,   214,   216,   218,   220,
+     222,   224,   226,   228,   230,   232,   236,   238,   241,   244,
+     249,   252,   256,   261,   264,   268,   273,   274,   281,   284,
+     288,   291,   293,   295,   298,   302,   306,   309,   313,   316,
+     318,   321,   323,   325,   327,   331,   336,   343,   349,   351,
+     354,   358,   364,   369,   371,   374,   376,   378,   380,   382,
+     387,   389,   393,   395,   399,   401,   403,   405,   408,   410,
      412,   414,   416,   418,   420,   422,   424,   426,   428,   430,
      432,   434,   436,   438,   440,   442,   444,   446,   448,   450,
-     452,   457,   459,   463,   465,   468,   471,   475,   479,   484,
-     486,   488,   490,   492,   494,   496,   498,   500,   502,   504,
+     452,   454,   456,   461,   463,   467,   469,   472,   475,   479,
+     483,   488,   490,   492,   494,   496,   498,   500,   502,   504,
      506,   508,   510,   512,   514,   516,   518,   520,   522,   524,
      526,   528,   530,   532,   534,   536,   538,   540,   542,   544,
      546,   548,   550,   552,   554,   556,   558,   560,   562,   564,
@@ -800,172 +813,176 @@ static const yytype_uint16 yyprhs[] =
      746,   748,   750,   752,   754,   756,   758,   760,   762,   764,
      766,   768,   770,   772,   774,   776,   778,   780,   782,   784,
      786,   788,   790,   792,   794,   796,   798,   800,   802,   804,
-     806,   808,   810,   812,   814,   816,   817,   824,   825,   831,
-     833,   836,   840,   845,   847,   851,   853,   856,   858,   862,
-     867,   869,   873,   875,   877,   879,   881,   883,   885,   887,
-     889,   891,   893,   896,   897,   898,   904,   906,   908,   909,
-     912,   913,   916,   919,   923,   925,   928,   930,   933,   939,
-     943,   945,   947,   952,   953,   962,   963,   965,   969,   972,
-     973,   980,   981,   990,   991,   999,  1001,  1003,  1005,  1006,
-    1009,  1013,  1016,  1019,  1022,  1026,  1029,  1031,  1034,  1036,
-    1038,  1039
+     806,   808,   810,   812,   814,   816,   818,   820,   822,   824,
+     826,   828,   830,   832,   834,   836,   837,   844,   845,   851,
+     853,   856,   860,   865,   867,   871,   873,   876,   878,   882,
+     887,   889,   893,   895,   897,   899,   901,   903,   905,   907,
+     909,   911,   913,   916,   917,   918,   924,   926,   928,   929,
+     932,   933,   936,   939,   943,   945,   948,   950,   953,   959,
+     963,   965,   967,   972,   973,   982,   983,   985,   989,   992,
+     993,  1000,  1001,  1010,  1011,  1019,  1021,  1023,  1025,  1026,
+    1029,  1033,  1036,  1039,  1042,  1046,  1049,  1051,  1054,  1056,
+    1058,  1059
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
-     356,     0,    -1,   199,    -1,   261,    -1,   203,    -1,   204,
-      -1,   201,    -1,   202,    -1,   205,    -1,   227,   289,   228,
-      -1,   262,    -1,   263,   229,   264,   230,    -1,   265,    -1,
-     263,   233,   199,    -1,   263,   208,    -1,   263,   209,    -1,
-     289,    -1,   266,    -1,   267,    -1,   269,   228,    -1,   268,
-     228,    -1,   270,   197,    -1,   270,    -1,   270,   287,    -1,
-     269,   234,   287,    -1,   271,   227,    -1,   315,    -1,   263,
-      -1,   263,    -1,   208,   272,    -1,   209,   272,    -1,   273,
-     272,    -1,   241,    -1,   239,    -1,   238,    -1,   240,    -1,
-     272,    -1,   274,   242,   272,    -1,   274,   243,   272,    -1,
-     274,   244,   272,    -1,   274,    -1,   275,   241,   274,    -1,
-     275,   239,   274,    -1,   275,    -1,   276,   206,   275,    -1,
-     276,   207,   275,    -1,   276,    -1,   277,   245,   276,    -1,
-     277,   246,   276,    -1,   277,   210,   276,    -1,   277,   211,
-     276,    -1,   277,    -1,   278,   212,   277,    -1,   278,   213,
-     277,    -1,   278,    -1,   279,   249,   278,    -1,   279,    -1,
-     280,   248,   279,    -1,   280,    -1,   281,   247,   280,    -1,
-     281,    -1,   282,   214,   281,    -1,   282,    -1,   283,   216,
-     282,    -1,   283,    -1,   284,   215,   283,    -1,   284,    -1,
-      -1,   284,   250,   286,   289,   235,   287,    -1,   285,    -1,
-     272,   288,   287,    -1,   236,    -1,   217,    -1,   218,    -1,
-     220,    -1,   219,    -1,   226,    -1,   221,    -1,   222,    -1,
-     223,    -1,   224,    -1,   225,    -1,   287,    -1,   289,   234,
-     287,    -1,   285,    -1,   295,   237,    -1,   302,   237,    -1,
-     256,   318,   315,   237,    -1,   292,   237,    -1,   292,   199,
-     237,    -1,   292,   199,   316,   237,    -1,   311,   237,    -1,
-     311,   199,   237,    -1,   311,   199,   294,   237,    -1,    -1,
-     311,   199,   231,   293,   322,   232,    -1,   234,   199,    -1,
-     294,   234,   199,    -1,   296,   228,    -1,   298,    -1,   297,
-      -1,   298,   300,    -1,   297,   234,   300,    -1,   304,   199,
-     227,    -1,   315,   199,    -1,   315,   199,   316,    -1,   311,
-     299,    -1,   299,    -1,   311,   301,    -1,   301,    -1,   315,
-      -1,   303,    -1,   302,   234,   199,    -1,   302,   234,   199,
-     316,    -1,   302,   234,   199,   316,   236,   326,    -1,   302,
-     234,   199,   236,   326,    -1,   304,    -1,   304,   199,    -1,
-     304,   199,   316,    -1,   304,   199,   316,   236,   326,    -1,
-     304,   199,   236,   326,    -1,   315,    -1,   311,   315,    -1,
-     251,    -1,    60,    -1,    59,    -1,    58,    -1,    61,   227,
-     308,   228,    -1,   309,    -1,   308,   234,   309,    -1,   199,
-      -1,   199,   236,   290,    -1,    46,    -1,   252,    -1,   312,
-      -1,   311,   312,    -1,   313,    -1,   307,    -1,   318,    -1,
-     306,    -1,   305,    -1,   310,    -1,     5,    -1,     3,    -1,
-       4,    -1,    41,    -1,    39,    -1,    40,    -1,    38,    -1,
-      43,    -1,    44,    -1,    42,    -1,    45,    -1,    46,    -1,
-      47,    -1,    48,    -1,    49,    -1,    50,    -1,    51,    -1,
-      22,    -1,    22,   227,   314,   228,    -1,   200,    -1,   314,
-     234,   200,    -1,   317,    -1,   317,   316,    -1,   229,   230,
-      -1,   229,   285,   230,    -1,   316,   229,   230,    -1,   316,
-     229,   285,   230,    -1,   197,    -1,     7,    -1,     8,    -1,
-       9,    -1,    10,    -1,     6,    -1,    32,    -1,    33,    -1,
-      34,    -1,    52,    -1,    53,    -1,    54,    -1,    23,    -1,
-      24,    -1,    25,    -1,    26,    -1,    27,    -1,    28,    -1,
-      29,    -1,    30,    -1,    31,    -1,    35,    -1,    36,    -1,
-      37,    -1,    62,    -1,    63,    -1,    64,    -1,    65,    -1,
-      66,    -1,    67,    -1,    68,    -1,    69,    -1,    70,    -1,
-      55,    -1,    56,    -1,    57,    -1,    71,    -1,    72,    -1,
-      73,    -1,    74,    -1,    75,    -1,    76,    -1,    77,    -1,
-      78,    -1,    79,    -1,    80,    -1,    81,    -1,    82,    -1,
-      83,    -1,    84,    -1,    85,    -1,    86,    -1,    87,    -1,
-      88,    -1,    89,    -1,    90,    -1,    91,    -1,   111,    -1,
-     112,    -1,    92,    -1,    93,    -1,    94,    -1,    95,    -1,
-      96,    -1,    97,    -1,   113,    -1,    98,    -1,    99,    -1,
-     100,    -1,   101,    -1,   102,    -1,   103,    -1,   114,    -1,
-     104,    -1,   105,    -1,   106,    -1,   107,    -1,   108,    -1,
-     109,    -1,   110,    -1,   115,    -1,   116,    -1,   117,    -1,
-     118,    -1,   119,    -1,   120,    -1,   122,    -1,   123,    -1,
-     124,    -1,   125,    -1,   126,    -1,   127,    -1,   128,    -1,
-     129,    -1,   148,    -1,   130,    -1,   131,    -1,   132,    -1,
-     133,    -1,   134,    -1,   135,    -1,   149,    -1,   136,    -1,
-     137,    -1,   138,    -1,   139,    -1,   140,    -1,   141,    -1,
-     150,    -1,   142,    -1,   143,    -1,   144,    -1,   145,    -1,
-     146,    -1,   147,    -1,   151,    -1,   152,    -1,   153,    -1,
-     154,    -1,   155,    -1,   156,    -1,   163,    -1,   164,    -1,
-     165,    -1,   166,    -1,   167,    -1,   168,    -1,   169,    -1,
-     170,    -1,   171,    -1,   172,    -1,   173,    -1,   174,    -1,
-     175,    -1,   176,    -1,   177,    -1,   178,    -1,   179,    -1,
-     180,    -1,   181,    -1,   182,    -1,   183,    -1,   184,    -1,
-     185,    -1,   186,    -1,   187,    -1,   188,    -1,   189,    -1,
-     190,    -1,   191,    -1,   192,    -1,   193,    -1,   194,    -1,
-     195,    -1,   121,    -1,   157,    -1,   158,    -1,   159,    -1,
-     160,    -1,   161,    -1,   162,    -1,   319,    -1,   200,    -1,
-     253,    -1,   254,    -1,   255,    -1,    -1,   196,   199,   231,
-     320,   322,   232,    -1,    -1,   196,   231,   321,   322,   232,
-      -1,   323,    -1,   322,   323,    -1,   315,   324,   237,    -1,
-     311,   315,   324,   237,    -1,   325,    -1,   324,   234,   325,
-      -1,   199,    -1,   199,   316,    -1,   287,    -1,   231,   327,
-     232,    -1,   231,   327,   234,   232,    -1,   326,    -1,   327,
-     234,   326,    -1,   291,    -1,   331,    -1,   330,    -1,   328,
-      -1,   340,    -1,   341,    -1,   344,    -1,   347,    -1,   348,
-      -1,   355,    -1,   231,   232,    -1,    -1,    -1,   231,   332,
-     339,   333,   232,    -1,   338,    -1,   330,    -1,    -1,   336,
-     331,    -1,    -1,   337,   330,    -1,   231,   232,    -1,   231,
-     339,   232,    -1,   329,    -1,   339,   329,    -1,   237,    -1,
-     289,   237,    -1,    16,   227,   289,   228,   342,    -1,   335,
-      14,   335,    -1,   335,    -1,   289,    -1,   304,   199,   236,
-     326,    -1,    -1,    19,   227,   289,   228,   345,   231,   346,
-     232,    -1,    -1,   339,    -1,    20,   289,   235,    -1,    21,
-     235,    -1,    -1,   198,   227,   349,   343,   228,   334,    -1,
-      -1,    13,   350,   329,   198,   227,   289,   228,   237,    -1,
-      -1,    15,   227,   351,   352,   354,   228,   334,    -1,   340,
-      -1,   328,    -1,   343,    -1,    -1,   353,   237,    -1,   353,
-     237,   289,    -1,    12,   237,    -1,    11,   237,    -1,    18,
-     237,    -1,    18,   289,   237,    -1,    17,   237,    -1,   357,
-      -1,   356,   357,    -1,   358,    -1,   291,    -1,    -1,   295,
-     359,   338,    -1
+     366,     0,    -1,   207,    -1,   271,    -1,   211,    -1,   212,
+      -1,   213,    -1,   214,    -1,   209,    -1,   210,    -1,   215,
+      -1,   237,   299,   238,    -1,   272,    -1,   273,   239,   274,
+     240,    -1,   275,    -1,   273,   243,   207,    -1,   273,   218,
+      -1,   273,   219,    -1,   299,    -1,   276,    -1,   277,    -1,
+     279,   238,    -1,   278,   238,    -1,   280,   205,    -1,   280,
+      -1,   280,   297,    -1,   279,   244,   297,    -1,   281,   237,
+      -1,   325,    -1,   273,    -1,   273,    -1,   218,   282,    -1,
+     219,   282,    -1,   283,   282,    -1,   251,    -1,   249,    -1,
+     248,    -1,   250,    -1,   282,    -1,   284,   252,   282,    -1,
+     284,   253,   282,    -1,   284,   254,   282,    -1,   284,    -1,
+     285,   251,   284,    -1,   285,   249,   284,    -1,   285,    -1,
+     286,   216,   285,    -1,   286,   217,   285,    -1,   286,    -1,
+     287,   255,   286,    -1,   287,   256,   286,    -1,   287,   220,
+     286,    -1,   287,   221,   286,    -1,   287,    -1,   288,   222,
+     287,    -1,   288,   223,   287,    -1,   288,    -1,   289,   259,
+     288,    -1,   289,    -1,   290,   258,   289,    -1,   290,    -1,
+     291,   257,   290,    -1,   291,    -1,   292,   224,   291,    -1,
+     292,    -1,   293,   226,   292,    -1,   293,    -1,   294,   225,
+     293,    -1,   294,    -1,    -1,   294,   260,   296,   299,   245,
+     297,    -1,   295,    -1,   282,   298,   297,    -1,   246,    -1,
+     227,    -1,   228,    -1,   230,    -1,   229,    -1,   236,    -1,
+     231,    -1,   232,    -1,   233,    -1,   234,    -1,   235,    -1,
+     297,    -1,   299,   244,   297,    -1,   295,    -1,   305,   247,
+      -1,   312,   247,    -1,   266,   328,   325,   247,    -1,   302,
+     247,    -1,   302,   207,   247,    -1,   302,   207,   326,   247,
+      -1,   321,   247,    -1,   321,   207,   247,    -1,   321,   207,
+     304,   247,    -1,    -1,   321,   207,   241,   303,   332,   242,
+      -1,   244,   207,    -1,   304,   244,   207,    -1,   306,   238,
+      -1,   308,    -1,   307,    -1,   308,   310,    -1,   307,   244,
+     310,    -1,   314,   207,   237,    -1,   325,   207,    -1,   325,
+     207,   326,    -1,   321,   309,    -1,   309,    -1,   321,   311,
+      -1,   311,    -1,   325,    -1,   313,    -1,   312,   244,   207,
+      -1,   312,   244,   207,   326,    -1,   312,   244,   207,   326,
+     246,   336,    -1,   312,   244,   207,   246,   336,    -1,   314,
+      -1,   314,   207,    -1,   314,   207,   326,    -1,   314,   207,
+     326,   246,   336,    -1,   314,   207,   246,   336,    -1,   325,
+      -1,   321,   325,    -1,   261,    -1,    68,    -1,    67,    -1,
+      66,    -1,    69,   237,   318,   238,    -1,   319,    -1,   318,
+     244,   319,    -1,   207,    -1,   207,   246,   300,    -1,    54,
+      -1,   262,    -1,   322,    -1,   321,   322,    -1,   323,    -1,
+     317,    -1,   328,    -1,   316,    -1,   315,    -1,   320,    -1,
+       5,    -1,     3,    -1,     4,    -1,    49,    -1,    47,    -1,
+      48,    -1,    46,    -1,    51,    -1,    52,    -1,    50,    -1,
+      53,    -1,    54,    -1,    55,    -1,    56,    -1,    57,    -1,
+      58,    -1,    59,    -1,    24,    -1,    24,   237,   324,   238,
+      -1,   208,    -1,   324,   244,   208,    -1,   327,    -1,   327,
+     326,    -1,   239,   240,    -1,   239,   295,   240,    -1,   326,
+     239,   240,    -1,   326,   239,   295,   240,    -1,   205,    -1,
+       7,    -1,     8,    -1,     9,    -1,    10,    -1,    11,    -1,
+      12,    -1,     6,    -1,    40,    -1,    41,    -1,    42,    -1,
+      60,    -1,    61,    -1,    62,    -1,    25,    -1,    26,    -1,
+      27,    -1,    28,    -1,    29,    -1,    30,    -1,    31,    -1,
+      32,    -1,    33,    -1,    34,    -1,    35,    -1,    36,    -1,
+      37,    -1,    38,    -1,    39,    -1,    43,    -1,    44,    -1,
+      45,    -1,    70,    -1,    71,    -1,    72,    -1,    73,    -1,
+      74,    -1,    75,    -1,    76,    -1,    77,    -1,    78,    -1,
+      63,    -1,    64,    -1,    65,    -1,    79,    -1,    80,    -1,
+      81,    -1,    82,    -1,    83,    -1,    84,    -1,    85,    -1,
+      86,    -1,    87,    -1,    88,    -1,    89,    -1,    90,    -1,
+      91,    -1,    92,    -1,    93,    -1,    94,    -1,    95,    -1,
+      96,    -1,    97,    -1,    98,    -1,    99,    -1,   119,    -1,
+     120,    -1,   100,    -1,   101,    -1,   102,    -1,   103,    -1,
+     104,    -1,   105,    -1,   121,    -1,   106,    -1,   107,    -1,
+     108,    -1,   109,    -1,   110,    -1,   111,    -1,   122,    -1,
+     112,    -1,   113,    -1,   114,    -1,   115,    -1,   116,    -1,
+     117,    -1,   118,    -1,   123,    -1,   124,    -1,   125,    -1,
+     126,    -1,   127,    -1,   128,    -1,   130,    -1,   131,    -1,
+     132,    -1,   133,    -1,   134,    -1,   135,    -1,   136,    -1,
+     137,    -1,   156,    -1,   138,    -1,   139,    -1,   140,    -1,
+     141,    -1,   142,    -1,   143,    -1,   157,    -1,   144,    -1,
+     145,    -1,   146,    -1,   147,    -1,   148,    -1,   149,    -1,
+     158,    -1,   150,    -1,   151,    -1,   152,    -1,   153,    -1,
+     154,    -1,   155,    -1,   159,    -1,   160,    -1,   161,    -1,
+     162,    -1,   163,    -1,   164,    -1,   171,    -1,   172,    -1,
+     173,    -1,   174,    -1,   175,    -1,   176,    -1,   177,    -1,
+     178,    -1,   179,    -1,   180,    -1,   181,    -1,   182,    -1,
+     183,    -1,   184,    -1,   185,    -1,   186,    -1,   187,    -1,
+     188,    -1,   189,    -1,   190,    -1,   191,    -1,   192,    -1,
+     193,    -1,   194,    -1,   195,    -1,   196,    -1,   197,    -1,
+     198,    -1,   199,    -1,   200,    -1,   201,    -1,   202,    -1,
+     203,    -1,   129,    -1,   165,    -1,   166,    -1,   167,    -1,
+     168,    -1,   169,    -1,   170,    -1,   329,    -1,   208,    -1,
+     263,    -1,   264,    -1,   265,    -1,    -1,   204,   207,   241,
+     330,   332,   242,    -1,    -1,   204,   241,   331,   332,   242,
+      -1,   333,    -1,   332,   333,    -1,   325,   334,   247,    -1,
+     321,   325,   334,   247,    -1,   335,    -1,   334,   244,   335,
+      -1,   207,    -1,   207,   326,    -1,   297,    -1,   241,   337,
+     242,    -1,   241,   337,   244,   242,    -1,   336,    -1,   337,
+     244,   336,    -1,   301,    -1,   341,    -1,   340,    -1,   338,
+      -1,   350,    -1,   351,    -1,   354,    -1,   357,    -1,   358,
+      -1,   365,    -1,   241,   242,    -1,    -1,    -1,   241,   342,
+     349,   343,   242,    -1,   348,    -1,   340,    -1,    -1,   346,
+     341,    -1,    -1,   347,   340,    -1,   241,   242,    -1,   241,
+     349,   242,    -1,   339,    -1,   349,   339,    -1,   247,    -1,
+     299,   247,    -1,    18,   237,   299,   238,   352,    -1,   345,
+      16,   345,    -1,   345,    -1,   299,    -1,   314,   207,   246,
+     336,    -1,    -1,    21,   237,   299,   238,   355,   241,   356,
+     242,    -1,    -1,   349,    -1,    22,   299,   245,    -1,    23,
+     245,    -1,    -1,   206,   237,   359,   353,   238,   344,    -1,
+      -1,    15,   360,   339,   206,   237,   299,   238,   247,    -1,
+      -1,    17,   237,   361,   362,   364,   238,   344,    -1,   350,
+      -1,   338,    -1,   353,    -1,    -1,   363,   247,    -1,   363,
+     247,   299,    -1,    14,   247,    -1,    13,   247,    -1,    20,
+     247,    -1,    20,   299,   247,    -1,    19,   247,    -1,   367,
+      -1,   366,   367,    -1,   368,    -1,   301,    -1,    -1,   305,
+     369,   348,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   244,   244,   250,   253,   256,   260,   263,   267,   270,
-     278,   281,   284,   287,   290,   295,   303,   310,   317,   323,
-     327,   334,   337,   343,   350,   360,   368,   373,   403,   409,
-     413,   417,   437,   438,   439,   440,   446,   447,   452,   457,
-     466,   467,   472,   480,   481,   487,   496,   497,   502,   507,
-     512,   520,   521,   529,   540,   541,   550,   551,   560,   561,
-     570,   571,   579,   580,   588,   589,   597,   598,   598,   616,
-     617,   632,   636,   640,   644,   649,   653,   657,   661,   665,
-     669,   673,   680,   683,   693,   700,   705,   710,   718,   722,
-     726,   730,   735,   740,   749,   749,   760,   764,   771,   778,
-     781,   788,   796,   816,   834,   849,   872,   883,   893,   903,
-     913,   922,   925,   929,   933,   938,   946,   951,   956,   961,
-     966,   975,   986,  1013,  1022,  1029,  1036,  1046,  1052,  1055,
-    1062,  1066,  1070,  1078,  1084,  1087,  1098,  1101,  1104,  1107,
-    1111,  1115,  1122,  1126,  1138,  1152,  1157,  1163,  1169,  1176,
-    1182,  1187,  1192,  1197,  1204,  1208,  1212,  1216,  1220,  1224,
-    1230,  1242,  1245,  1250,  1254,  1263,  1268,  1276,  1280,  1290,
-    1294,  1298,  1303,  1307,  1312,  1316,  1321,  1326,  1331,  1337,
-    1343,  1349,  1354,  1359,  1364,  1369,  1374,  1379,  1385,  1391,
-    1397,  1402,  1407,  1412,  1417,  1422,  1427,  1432,  1437,  1442,
-    1447,  1452,  1457,  1463,  1469,  1475,  1481,  1487,  1493,  1499,
-    1505,  1511,  1517,  1523,  1529,  1534,  1539,  1544,  1549,  1554,
-    1559,  1564,  1569,  1574,  1579,  1584,  1589,  1594,  1599,  1604,
-    1609,  1614,  1619,  1624,  1629,  1634,  1639,  1644,  1649,  1654,
-    1659,  1664,  1669,  1674,  1679,  1684,  1689,  1694,  1699,  1704,
-    1709,  1714,  1719,  1724,  1729,  1734,  1739,  1744,  1749,  1754,
-    1759,  1764,  1769,  1774,  1779,  1784,  1789,  1794,  1799,  1804,
-    1809,  1814,  1819,  1824,  1829,  1834,  1839,  1844,  1849,  1854,
-    1859,  1864,  1869,  1874,  1879,  1884,  1889,  1894,  1899,  1904,
-    1909,  1914,  1919,  1924,  1929,  1934,  1939,  1944,  1949,  1954,
-    1959,  1964,  1969,  1974,  1979,  1984,  1989,  1994,  1999,  2004,
-    2009,  2014,  2019,  2024,  2029,  2034,  2039,  2044,  2049,  2054,
-    2059,  2064,  2069,  2074,  2080,  2086,  2092,  2098,  2104,  2110,
-    2116,  2121,  2137,  2143,  2149,  2158,  2158,  2169,  2169,  2179,
-    2182,  2195,  2213,  2237,  2241,  2247,  2252,  2263,  2266,  2272,
-    2281,  2284,  2290,  2294,  2295,  2301,  2302,  2303,  2304,  2305,
-    2306,  2307,  2311,  2312,  2316,  2312,  2328,  2329,  2333,  2333,
-    2340,  2340,  2354,  2357,  2365,  2373,  2384,  2385,  2389,  2396,
-    2400,  2408,  2412,  2425,  2425,  2445,  2448,  2454,  2466,  2478,
-    2478,  2493,  2493,  2509,  2509,  2530,  2533,  2539,  2542,  2548,
-    2552,  2559,  2564,  2569,  2576,  2594,  2603,  2607,  2614,  2617,
-    2623,  2623
+       0,   246,   246,   252,   255,   258,   262,   266,   270,   273,
+     277,   280,   288,   291,   294,   297,   300,   305,   313,   320,
+     327,   333,   337,   344,   347,   353,   360,   370,   378,   383,
+     413,   419,   423,   427,   447,   448,   449,   450,   456,   457,
+     462,   467,   476,   477,   482,   490,   491,   497,   506,   507,
+     512,   517,   522,   530,   531,   539,   550,   551,   560,   561,
+     570,   571,   580,   581,   589,   590,   598,   599,   607,   608,
+     608,   626,   627,   642,   646,   650,   654,   659,   663,   667,
+     671,   675,   679,   683,   690,   693,   703,   710,   715,   720,
+     728,   732,   736,   740,   745,   750,   759,   759,   770,   774,
+     781,   788,   791,   798,   806,   826,   844,   859,   882,   893,
+     903,   913,   923,   932,   935,   939,   943,   948,   956,   961,
+     966,   971,   976,   985,   996,  1023,  1032,  1039,  1046,  1056,
+    1062,  1065,  1072,  1076,  1080,  1088,  1094,  1097,  1108,  1111,
+    1114,  1117,  1121,  1125,  1132,  1136,  1148,  1162,  1167,  1173,
+    1179,  1186,  1192,  1197,  1202,  1207,  1214,  1218,  1222,  1226,
+    1230,  1234,  1240,  1252,  1255,  1260,  1264,  1273,  1278,  1286,
+    1290,  1300,  1304,  1308,  1313,  1317,  1322,  1327,  1332,  1336,
+    1341,  1346,  1351,  1357,  1363,  1369,  1374,  1379,  1384,  1389,
+    1394,  1399,  1405,  1411,  1417,  1423,  1429,  1435,  1441,  1447,
+    1453,  1458,  1463,  1468,  1473,  1478,  1483,  1488,  1493,  1498,
+    1503,  1508,  1513,  1519,  1525,  1531,  1537,  1543,  1549,  1555,
+    1561,  1567,  1573,  1579,  1585,  1590,  1595,  1600,  1605,  1610,
+    1615,  1620,  1625,  1630,  1635,  1640,  1645,  1650,  1655,  1660,
+    1665,  1670,  1675,  1680,  1685,  1690,  1695,  1700,  1705,  1710,
+    1715,  1720,  1725,  1730,  1735,  1740,  1745,  1750,  1755,  1760,
+    1765,  1770,  1775,  1780,  1785,  1790,  1795,  1800,  1805,  1810,
+    1815,  1820,  1825,  1830,  1835,  1840,  1845,  1850,  1855,  1860,
+    1865,  1870,  1875,  1880,  1885,  1890,  1895,  1900,  1905,  1910,
+    1915,  1920,  1925,  1930,  1935,  1940,  1945,  1950,  1955,  1960,
+    1965,  1970,  1975,  1980,  1985,  1990,  1995,  2000,  2005,  2010,
+    2015,  2020,  2025,  2030,  2035,  2040,  2045,  2050,  2055,  2060,
+    2065,  2070,  2075,  2080,  2085,  2090,  2095,  2100,  2105,  2110,
+    2115,  2120,  2125,  2130,  2136,  2142,  2148,  2154,  2160,  2166,
+    2172,  2177,  2193,  2199,  2205,  2214,  2214,  2225,  2225,  2235,
+    2238,  2251,  2269,  2293,  2297,  2303,  2308,  2319,  2322,  2328,
+    2337,  2340,  2346,  2350,  2351,  2357,  2358,  2359,  2360,  2361,
+    2362,  2363,  2367,  2368,  2372,  2368,  2384,  2385,  2389,  2389,
+    2396,  2396,  2410,  2413,  2421,  2429,  2440,  2441,  2445,  2452,
+    2456,  2464,  2468,  2481,  2481,  2501,  2504,  2510,  2522,  2534,
+    2534,  2549,  2549,  2565,  2565,  2586,  2589,  2595,  2598,  2604,
+    2608,  2615,  2620,  2625,  2632,  2650,  2659,  2663,  2670,  2673,
+    2679,  2679
 };
 #endif
 
@@ -975,14 +992,15 @@ static const yytype_uint16 yyrline[] =
 static const char *const yytname[] =
 {
   "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "CONST", "BOOL",
-  "FLOAT", "DOUBLE", "INT", "UINT", "BREAK", "CONTINUE", "DO", "ELSE",
-  "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT",
-  "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4",
-  "UVEC2", "UVEC3", "UVEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3",
-  "MAT4", "CENTROID", "IN", "OUT", "INOUT", "UNIFORM", "PATCH", "SAMPLE",
-  "BUFFER", "SHARED", "COHERENT", "VOLATILE", "RESTRICT", "READONLY",
-  "WRITEONLY", "DVEC2", "DVEC3", "DVEC4", "DMAT2", "DMAT3", "DMAT4",
-  "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", "MAT2X2", "MAT2X3",
+  "FLOAT", "DOUBLE", "INT", "UINT", "INT64_T", "UINT64_T", "BREAK",
+  "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN", "SWITCH",
+  "CASE", "DEFAULT", "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", "IVEC2",
+  "IVEC3", "IVEC4", "I64VEC2", "I64VEC3", "I64VEC4", "UVEC2", "UVEC3",
+  "UVEC4", "U64VEC2", "U64VEC3", "U64VEC4", "VEC2", "VEC3", "VEC4", "MAT2",
+  "MAT3", "MAT4", "CENTROID", "IN", "OUT", "INOUT", "UNIFORM", "PATCH",
+  "SAMPLE", "BUFFER", "SHARED", "COHERENT", "VOLATILE", "RESTRICT",
+  "READONLY", "WRITEONLY", "DVEC2", "DVEC3", "DVEC4", "DMAT2", "DMAT3",
+  "DMAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH", "LAYOUT", "MAT2X2", "MAT2X3",
   "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4",
   "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4",
   "DMAT4X2", "DMAT4X3", "DMAT4X4", "ATOMIC_UINT", "SAMPLER1D", "SAMPLER2D",
@@ -1016,20 +1034,20 @@ static const char *const yytname[] =
   "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS",
   "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "STRUCT", "VOID",
   "WHILE", "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT",
-  "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT", "LEFT_OP", "RIGHT_OP",
-  "INC_OP", "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP",
-  "OR_OP", "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN",
-  "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN",
-  "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET",
-  "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "DOT", "COMMA", "COLON",
-  "EQUAL", "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS", "STAR", "SLASH",
-  "PERCENT", "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR", "CARET",
-  "AMPERSAND", "QUESTION", "INVARIANT", "PRECISE", "HIGH_PRECISION",
-  "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE",
-  "SUPERP", "$accept", "variable_identifier", "primary_expression",
-  "postfix_expression", "integer_expression", "function_call",
-  "function_call_or_method", "function_call_generic",
-  "function_call_header_no_parameters",
+  "INTCONSTANT", "UINTCONSTANT", "INT64CONSTANT", "UINT64CONSTANT",
+  "BOOLCONSTANT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP",
+  "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN",
+  "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
+  "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN",
+  "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE",
+  "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG",
+  "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE",
+  "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION",
+  "INVARIANT", "PRECISE", "HIGH_PRECISION", "MEDIUM_PRECISION",
+  "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", "$accept",
+  "variable_identifier", "primary_expression", "postfix_expression",
+  "integer_expression", "function_call", "function_call_or_method",
+  "function_call_generic", "function_call_header_no_parameters",
   "function_call_header_with_parameters", "function_call_header",
   "function_identifier", "unary_expression", "unary_operator",
   "multiplicative_expression", "additive_expression", "shift_expression",
@@ -1093,77 +1111,80 @@ static const yytype_uint16 yytoknum[] =
      475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
      485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
      495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
-     505,   506,   507,   508,   509,   510,   511,   512,   513,   514
+     505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
+     515,   516,   517,   518,   519,   520,   521,   522,   523,   524
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint16 yyr1[] =
 {
-       0,   260,   261,   262,   262,   262,   262,   262,   262,   262,
-     263,   263,   263,   263,   263,   263,   264,   265,   266,   267,
-     267,   268,   268,   269,   269,   270,   271,   271,   272,   272,
-     272,   272,   273,   273,   273,   273,   274,   274,   274,   274,
-     275,   275,   275,   276,   276,   276,   277,   277,   277,   277,
-     277,   278,   278,   278,   279,   279,   280,   280,   281,   281,
-     282,   282,   283,   283,   284,   284,   285,   286,   285,   287,
-     287,   288,   288,   288,   288,   288,   288,   288,   288,   288,
-     288,   288,   289,   289,   290,   291,   291,   291,   291,   291,
-     291,   291,   291,   291,   293,   292,   294,   294,   295,   296,
-     296,   297,   297,   298,   299,   299,   300,   300,   300,   300,
-     301,   302,   302,   302,   302,   302,   303,   303,   303,   303,
-     303,   304,   304,   305,   306,   306,   306,   307,   308,   308,
-     309,   309,   309,   310,   311,   311,   312,   312,   312,   312,
-     312,   312,   313,   313,   313,   313,   313,   313,   313,   313,
-     313,   313,   313,   313,   313,   313,   313,   313,   313,   313,
-     313,   314,   314,   315,   315,   316,   316,   316,   316,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   317,   317,   317,   317,   317,   317,   317,   317,
-     317,   317,   318,   318,   318,   320,   319,   321,   319,   322,
-     322,   323,   323,   324,   324,   325,   325,   326,   326,   326,
-     327,   327,   328,   329,   329,   330,   330,   330,   330,   330,
-     330,   330,   331,   332,   333,   331,   334,   334,   336,   335,
-     337,   335,   338,   338,   339,   339,   340,   340,   341,   342,
-     342,   343,   343,   345,   344,   346,   346,   347,   347,   349,
-     348,   350,   348,   351,   348,   352,   352,   353,   353,   354,
-     354,   355,   355,   355,   355,   355,   356,   356,   357,   357,
-     359,   358
+       0,   270,   271,   272,   272,   272,   272,   272,   272,   272,
+     272,   272,   273,   273,   273,   273,   273,   273,   274,   275,
+     276,   277,   277,   278,   278,   279,   279,   280,   281,   281,
+     282,   282,   282,   282,   283,   283,   283,   283,   284,   284,
+     284,   284,   285,   285,   285,   286,   286,   286,   287,   287,
+     287,   287,   287,   288,   288,   288,   289,   289,   290,   290,
+     291,   291,   292,   292,   293,   293,   294,   294,   295,   296,
+     295,   297,   297,   298,   298,   298,   298,   298,   298,   298,
+     298,   298,   298,   298,   299,   299,   300,   301,   301,   301,
+     301,   301,   301,   301,   301,   301,   303,   302,   304,   304,
+     305,   306,   306,   307,   307,   308,   309,   309,   310,   310,
+     310,   310,   311,   312,   312,   312,   312,   312,   313,   313,
+     313,   313,   313,   314,   314,   315,   316,   316,   316,   317,
+     318,   318,   319,   319,   319,   320,   321,   321,   322,   322,
+     322,   322,   322,   322,   323,   323,   323,   323,   323,   323,
+     323,   323,   323,   323,   323,   323,   323,   323,   323,   323,
+     323,   323,   323,   324,   324,   325,   325,   326,   326,   326,
+     326,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   327,   327,   327,   327,   327,   327,   327,   327,
+     327,   327,   328,   328,   328,   330,   329,   331,   329,   332,
+     332,   333,   333,   334,   334,   335,   335,   336,   336,   336,
+     337,   337,   338,   339,   339,   340,   340,   340,   340,   340,
+     340,   340,   341,   342,   343,   341,   344,   344,   346,   345,
+     347,   345,   348,   348,   349,   349,   350,   350,   351,   352,
+     352,   353,   353,   355,   354,   356,   356,   357,   357,   359,
+     358,   360,   358,   361,   358,   362,   362,   363,   363,   364,
+     364,   365,   365,   365,   365,   365,   366,   366,   367,   367,
+     369,   368
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 static const yytype_uint8 yyr2[] =
 {
-       0,     2,     1,     1,     1,     1,     1,     1,     1,     3,
-       1,     4,     1,     3,     2,     2,     1,     1,     1,     2,
-       2,     2,     1,     2,     3,     2,     1,     1,     1,     2,
-       2,     2,     1,     1,     1,     1,     1,     3,     3,     3,
-       1,     3,     3,     1,     3,     3,     1,     3,     3,     3,
-       3,     1,     3,     3,     1,     3,     1,     3,     1,     3,
-       1,     3,     1,     3,     1,     3,     1,     0,     6,     1,
-       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     3,     1,     2,     2,     4,     2,     3,
-       4,     2,     3,     4,     0,     6,     2,     3,     2,     1,
-       1,     2,     3,     3,     2,     3,     2,     1,     2,     1,
-       1,     1,     3,     4,     6,     5,     1,     2,     3,     5,
-       4,     1,     2,     1,     1,     1,     1,     4,     1,     3,
-       1,     3,     1,     1,     1,     2,     1,     1,     1,     1,
+       0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     3,     1,     4,     1,     3,     2,     2,     1,     1,
+       1,     2,     2,     2,     1,     2,     3,     2,     1,     1,
+       1,     2,     2,     2,     1,     1,     1,     1,     1,     3,
+       3,     3,     1,     3,     3,     1,     3,     3,     1,     3,
+       3,     3,     3,     1,     3,     3,     1,     3,     1,     3,
+       1,     3,     1,     3,     1,     3,     1,     3,     1,     0,
+       6,     1,     3,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     3,     1,     2,     2,     4,
+       2,     3,     4,     2,     3,     4,     0,     6,     2,     3,
+       2,     1,     1,     2,     3,     3,     2,     3,     2,     1,
+       2,     1,     1,     1,     3,     4,     6,     5,     1,     2,
+       3,     5,     4,     1,     2,     1,     1,     1,     1,     4,
+       1,     3,     1,     3,     1,     1,     1,     2,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       4,     1,     3,     1,     2,     2,     3,     3,     4,     1,
+       1,     1,     4,     1,     3,     1,     2,     2,     3,     3,
+       4,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
@@ -1196,367 +1217,220 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-       0,   143,   144,   142,   174,   170,   171,   172,   173,   159,
-     181,   182,   183,   184,   185,   186,   187,   188,   189,   175,
-     176,   177,   190,   191,   192,   148,   146,   147,   145,   151,
-     149,   150,   152,   153,   154,   155,   156,   157,   158,   178,
-     179,   180,   202,   203,   204,   126,   125,   124,     0,   193,
-     194,   195,   196,   197,   198,   199,   200,   201,   205,   206,
-     207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
-     217,   218,   219,   220,   221,   222,   223,   224,   225,   228,
-     229,   230,   231,   232,   233,   235,   236,   237,   238,   239,
-     240,   242,   243,   244,   245,   246,   247,   248,   226,   227,
-     234,   241,   249,   250,   251,   252,   253,   254,   323,   255,
-     256,   257,   258,   259,   260,   261,   262,   264,   265,   266,
-     267,   268,   269,   271,   272,   273,   274,   275,   276,   278,
-     279,   280,   281,   282,   283,   263,   270,   277,   284,   285,
-     286,   287,   288,   289,   324,   325,   326,   327,   328,   329,
-     290,   291,   292,   293,   294,   295,   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,     0,   169,   331,   123,   133,   332,   333,
-     334,     0,   409,     0,   410,     0,   100,    99,     0,   111,
-     116,   140,   139,   137,   141,     0,   134,   136,   121,   163,
-     138,   330,     0,   406,   408,     0,     0,     0,   337,     0,
-       0,    88,    85,     0,    98,     0,   107,   101,   109,     0,
-     110,     0,    86,   117,     0,    91,   135,   122,     0,   164,
-       1,   407,   161,     0,   132,   130,     0,   128,   335,     0,
-       0,    89,     0,     0,   411,   102,   106,   108,   104,   112,
-     103,     0,   118,    94,     0,    92,     0,     2,     6,     7,
-       4,     5,     8,     0,     0,     0,   165,    34,    33,    35,
-      32,     3,    10,    28,    12,    17,    18,     0,     0,    22,
-       0,    36,     0,    40,    43,    46,    51,    54,    56,    58,
-      60,    62,    64,    66,     0,    26,     0,   160,     0,     0,
-     127,     0,     0,     0,     0,     0,   339,    87,    90,     0,
-       0,   391,     0,     0,     0,     0,     0,     0,     0,     0,
-     363,   372,   376,    36,    69,    82,     0,   352,     0,   121,
-     355,   374,   354,   353,     0,   356,   357,   358,   359,   360,
-     361,   105,     0,   113,     0,   347,   120,     0,     0,    96,
-       0,    93,    29,    30,     0,    14,    15,     0,     0,    20,
-      19,     0,   169,    23,    25,    31,     0,     0,     0,     0,
+       0,   145,   146,   144,   178,   172,   173,   174,   175,   176,
+     177,   161,   185,   186,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,   199,   179,   180,   181,
+     200,   201,   202,   150,   148,   149,   147,   153,   151,   152,
+     154,   155,   156,   157,   158,   159,   160,   182,   183,   184,
+     212,   213,   214,   128,   127,   126,     0,   203,   204,   205,
+     206,   207,   208,   209,   210,   211,   215,   216,   217,   218,
+     219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   232,   233,   234,   235,   238,   239,   240,
+     241,   242,   243,   245,   246,   247,   248,   249,   250,   252,
+     253,   254,   255,   256,   257,   258,   236,   237,   244,   251,
+     259,   260,   261,   262,   263,   264,   333,   265,   266,   267,
+     268,   269,   270,   271,   272,   274,   275,   276,   277,   278,
+     279,   281,   282,   283,   284,   285,   286,   288,   289,   290,
+     291,   292,   293,   273,   280,   287,   294,   295,   296,   297,
+     298,   299,   334,   335,   336,   337,   338,   339,   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,   171,   341,   125,   135,   342,   343,   344,     0,
+     419,     0,   420,     0,   102,   101,     0,   113,   118,   142,
+     141,   139,   143,     0,   136,   138,   123,   165,   140,   340,
+       0,   416,   418,     0,     0,     0,   347,     0,     0,    90,
+      87,     0,   100,     0,   109,   103,   111,     0,   112,     0,
+      88,   119,     0,    93,   137,   124,     0,   166,     1,   417,
+     163,     0,   134,   132,     0,   130,   345,     0,     0,    91,
+       0,     0,   421,   104,   108,   110,   106,   114,   105,     0,
+     120,    96,     0,    94,     0,     2,     8,     9,     4,     5,
+       6,     7,    10,     0,     0,     0,   167,    36,    35,    37,
+      34,     3,    12,    30,    14,    19,    20,     0,     0,    24,
+       0,    38,     0,    42,    45,    48,    53,    56,    58,    60,
+      62,    64,    66,    68,     0,    28,     0,   162,     0,     0,
+     129,     0,     0,     0,     0,     0,   349,    89,    92,     0,
+       0,   401,     0,     0,     0,     0,     0,     0,     0,     0,
+     373,   382,   386,    38,    71,    84,     0,   362,     0,   123,
+     365,   384,   364,   363,     0,   366,   367,   368,   369,   370,
+     371,   107,     0,   115,     0,   357,   122,     0,     0,    98,
+       0,    95,    31,    32,     0,    16,    17,     0,     0,    22,
+      21,     0,   171,    25,    27,    33,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    67,   166,   167,     0,   162,
-      84,   131,   129,     0,     0,   345,     0,   343,   338,   340,
-     402,   401,     0,   393,     0,   405,   403,     0,     0,     0,
-     388,   389,   362,     0,    72,    73,    75,    74,    77,    78,
-      79,    80,    81,    76,    71,     0,     0,   377,   373,   375,
-     115,     0,   350,     0,   119,     0,    97,     9,     0,    16,
-      13,    24,    37,    38,    39,    42,    41,    44,    45,    49,
-      50,    47,    48,    52,    53,    55,    57,    59,    61,    63,
-      65,     0,   168,   336,     0,   346,     0,   341,     0,     0,
-       0,   404,     0,   387,     0,   364,    70,    83,   114,   348,
-       0,    95,    11,     0,   342,   344,     0,   396,   395,   398,
-     370,   383,   381,     0,     0,     0,     0,   349,   351,     0,
-       0,   397,     0,     0,   380,     0,     0,   378,     0,     0,
-       0,   365,    68,     0,   399,     0,   370,   369,   371,   385,
-       0,   367,   390,   366,     0,   400,   394,   379,   386,     0,
-     382,   392,   384
+       0,     0,     0,     0,     0,    69,   168,   169,     0,   164,
+      86,   133,   131,     0,     0,   355,     0,   353,   348,   350,
+     412,   411,     0,   403,     0,   415,   413,     0,     0,     0,
+     398,   399,   372,     0,    74,    75,    77,    76,    79,    80,
+      81,    82,    83,    78,    73,     0,     0,   387,   383,   385,
+     117,     0,   360,     0,   121,     0,    99,    11,     0,    18,
+      15,    26,    39,    40,    41,    44,    43,    46,    47,    51,
+      52,    49,    50,    54,    55,    57,    59,    61,    63,    65,
+      67,     0,   170,   346,     0,   356,     0,   351,     0,     0,
+       0,   414,     0,   397,     0,   374,    72,    85,   116,   358,
+       0,    97,    13,     0,   352,   354,     0,   406,   405,   408,
+     380,   393,   391,     0,     0,     0,     0,   359,   361,     0,
+       0,   407,     0,     0,   390,     0,     0,   388,     0,     0,
+       0,   375,    70,     0,   409,     0,   380,   379,   381,   395,
+       0,   377,   400,   376,     0,   410,   404,   389,   396,     0,
+     392,   402,   394
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,   281,   282,   283,   448,   284,   285,   286,   287,   288,
-     289,   290,   333,   292,   293,   294,   295,   296,   297,   298,
-     299,   300,   301,   302,   303,   334,   471,   335,   435,   336,
-     401,   337,   193,   358,   266,   338,   195,   196,   197,   226,
-     227,   228,   198,   199,   200,   201,   202,   203,   246,   247,
-     204,   205,   206,   207,   243,   305,   239,   209,   210,   211,
-     312,   249,   315,   316,   406,   407,   356,   443,   340,   341,
-     342,   343,   423,   506,   532,   514,   515,   516,   533,   344,
-     345,   346,   517,   505,   347,   518,   539,   348,   349,   484,
-     412,   479,   499,   512,   513,   350,   212,   213,   214,   223
+      -1,   291,   292,   293,   458,   294,   295,   296,   297,   298,
+     299,   300,   343,   302,   303,   304,   305,   306,   307,   308,
+     309,   310,   311,   312,   313,   344,   481,   345,   445,   346,
+     411,   347,   201,   368,   274,   348,   203,   204,   205,   234,
+     235,   236,   206,   207,   208,   209,   210,   211,   254,   255,
+     212,   213,   214,   215,   251,   315,   247,   217,   218,   219,
+     322,   257,   325,   326,   416,   417,   366,   453,   350,   351,
+     352,   353,   433,   516,   542,   524,   525,   526,   543,   354,
+     355,   356,   527,   515,   357,   528,   549,   358,   359,   494,
+     422,   489,   509,   522,   523,   360,   220,   221,   222,   231
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -466
+#define YYPACT_NINF -496
 static const yytype_int16 yypact[] =
 {
-    2275,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -205,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -192,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -179,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -122,  -466,  -186,  -198,  -173,  -175,  3686,  -194,  -466,
-    -121,  -466,  -466,  -466,  -466,  2749,  -466,  -466,  -466,  -141,
-    -466,  -466,   527,  -466,  -466,   -97,   -37,  -117,  -466,  5459,
-    -200,  -466,  -466,  -112,  -466,  3686,  -466,  -466,  -466,  3686,
-     -71,   -44,  -466,  -191,  -142,  -466,  -466,  -466,  4117,   -82,
-    -466,  -466,  -466,  -202,  -466,   -76,  -137,  -466,  -466,  3686,
-     -73,  -466,  -196,   781,  -466,  -466,  -466,  -466,  -141,  -155,
-    -466,  4342,  -152,  -466,   -38,  -466,  -177,  -466,  -466,  -466,
-    -466,  -466,  -466,  5015,  5015,  5015,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -185,  -466,  -466,  -466,   -63,  -128,  5237,
-     -61,  -466,  5015,  -106,  -100,  -157,  -183,   -78,   -81,   -79,
-     -80,   -43,   -46,  -197,   -58,  -466,  4568,  -466,   -27,  5015,
-    -466,   -37,  3686,  3686,   -25,  2984,  -466,  -466,  -466,   -62,
-     -57,  -466,   -51,   -48,   -56,  4793,   -45,  5015,   -50,   -40,
-     -41,  -466,  -466,  -153,  -466,  -466,  -147,  -466,  -198,   -39,
-    -466,  -466,  -466,  -466,  1035,  -466,  -466,  -466,  -466,  -466,
-    -466,   -82,  4342,  -143,  4342,  -466,  -466,  4342,  3686,  -466,
-     -15,  -466,  -466,  -466,  -126,  -466,  -466,  5015,   -10,  -466,
-    -466,  5015,   -36,  -466,  -466,  -466,  5015,  5015,  5015,  5015,
-    5015,  5015,  5015,  5015,  5015,  5015,  5015,  5015,  5015,  5015,
-    5015,  5015,  5015,  5015,  5015,  -466,  -466,  -466,   -35,  -466,
-    -466,  -466,  -466,  3218,   -25,  -141,  -127,  -466,  -466,  -466,
-    -466,  -466,  1289,  -466,  5015,  -466,  -466,  -108,  5015,   -91,
-    -466,  -466,  -466,  1289,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  5015,  5015,  -466,  -466,  -466,
-    -466,  4342,  -466,   -92,  -466,  3452,  -466,  -466,   -34,   -31,
-    -466,  -466,  -466,  -466,  -466,  -106,  -106,  -100,  -100,  -157,
-    -157,  -157,  -157,  -183,  -183,   -78,   -81,   -79,   -80,   -43,
-     -46,  5015,  -466,  -466,  -107,   -82,   -25,  -466,    -4,  2036,
-    -123,  -466,  -116,  -466,  2510,  1289,  -466,  -466,  -466,  -466,
-    3890,  -466,  -466,   -83,  -466,  -466,   -29,  -466,  -466,  2510,
-     -32,  -466,   -31,     1,  3686,   -24,   -26,  -466,  -466,  5015,
-    5015,  -466,   -30,   -19,   196,   -20,  1797,  -466,   -18,   -22,
-    1543,  -466,  -466,  -113,  5015,  1543,   -32,  -466,  -466,  1289,
-    4342,  -466,  -466,  -466,   -17,   -31,  -466,  -466,  1289,   -14,
-    -466,  -466,  -466
+    2394,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -199,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -187,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -180,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -134,
+    -496,  -191,  -181,  -155,  -131,  3871,  -133,  -496,   -69,  -496,
+    -496,  -496,  -496,  2900,  -496,  -496,  -496,   -92,  -496,  -496,
+     546,  -496,  -496,   -68,   -45,   -91,  -496,  5735,  -200,  -496,
+    -496,   -85,  -496,  3871,  -496,  -496,  -496,  3871,   -50,   -49,
+    -496,  -209,  -193,  -496,  -496,  -496,  4323,   -80,  -496,  -496,
+    -496,  -202,  -496,   -86,  -171,  -496,  -496,  3871,   -84,  -496,
+    -198,   810,  -496,  -496,  -496,  -496,   -92,  -214,  -496,  4558,
+    -176,  -496,   -46,  -496,  -127,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  5271,  5271,  5271,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -175,  -496,  -496,  -496,   -73,  -169,  5503,
+     -71,  -496,  5271,  -118,  -170,  -195,  -197,   -90,   -89,   -87,
+     -88,   -57,   -58,  -208,   -67,  -496,  4804,  -496,   -36,  5271,
+    -496,   -45,  3871,  3871,   -33,  3145,  -496,  -496,  -496,   -72,
+     -70,  -496,   -61,   -59,   -66,  5039,   -55,  5271,   -62,   -51,
+     -54,  -496,  -496,  -141,  -496,  -496,  -125,  -496,  -181,   -48,
+    -496,  -496,  -496,  -496,  1074,  -496,  -496,  -496,  -496,  -496,
+    -496,   -80,  4558,  -174,  4558,  -496,  -496,  4558,  3871,  -496,
+     -23,  -496,  -496,  -496,  -167,  -496,  -496,  5271,   -20,  -496,
+    -496,  5271,   -43,  -496,  -496,  -496,  5271,  5271,  5271,  5271,
+    5271,  5271,  5271,  5271,  5271,  5271,  5271,  5271,  5271,  5271,
+    5271,  5271,  5271,  5271,  5271,  -496,  -496,  -496,   -44,  -496,
+    -496,  -496,  -496,  3387,   -33,   -92,  -121,  -496,  -496,  -496,
+    -496,  -496,  1338,  -496,  5271,  -496,  -496,  -120,  5271,  -102,
+    -496,  -496,  -496,  1338,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  5271,  5271,  -496,  -496,  -496,
+    -496,  4558,  -496,  -105,  -496,  3629,  -496,  -496,   -42,   -52,
+    -496,  -496,  -496,  -496,  -496,  -118,  -118,  -170,  -170,  -195,
+    -195,  -195,  -195,  -197,  -197,   -90,   -89,   -87,   -88,   -57,
+     -58,  5271,  -496,  -496,  -119,   -80,   -33,  -496,   -16,  2130,
+    -164,  -496,  -160,  -496,  2637,  1338,  -496,  -496,  -496,  -496,
+    4077,  -496,  -496,   -99,  -496,  -496,   -40,  -496,  -496,  2637,
+     -41,  -496,   -52,    -8,  3871,   -35,   -38,  -496,  -496,  5271,
+    5271,  -496,   -39,   -32,   191,   -31,  1866,  -496,   -30,   -34,
+    1602,  -496,  -496,  -138,  5271,  1602,   -41,  -496,  -496,  1338,
+    4558,  -496,  -496,  -496,   -29,   -52,  -496,  -496,  1338,   -27,
+    -496,  -496,  -496
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,   -52,  -466,  -226,  -225,  -261,  -229,  -166,  -164,
-    -167,  -165,  -162,  -161,  -466,  -227,  -466,  -258,  -466,  -269,
-    -466,     4,  -466,  -466,  -466,     5,  -466,  -466,  -466,    -1,
-       9,     6,  -466,  -466,  -465,  -466,  -466,  -466,  -466,   -75,
-    -466,  -195,  -204,  -466,  -466,     0,  -212,  -466,    46,  -466,
-    -466,  -466,  -297,  -299,  -160,  -238,  -340,  -466,  -240,  -337,
-    -440,  -273,  -466,  -466,  -282,  -281,  -466,  -466,    23,  -413,
-    -232,  -466,  -466,  -251,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,  -466,    40,  -466,  -466
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,   -53,  -496,  -237,  -288,  -286,  -243,  -183,  -179,
+    -184,  -177,  -168,  -185,  -496,  -234,  -496,  -266,  -496,  -280,
+    -496,     4,  -496,  -496,  -496,     6,  -496,  -496,  -496,   -15,
+     -10,    -9,  -496,  -496,  -475,  -496,  -496,  -496,  -496,   -83,
+    -496,  -204,  -211,  -496,  -496,     0,  -221,  -496,    33,  -496,
+    -496,  -496,  -308,  -314,  -178,  -247,  -349,  -496,  -248,  -346,
+    -495,  -283,  -496,  -496,  -292,  -291,  -496,  -496,    13,  -423,
+    -242,  -496,  -496,  -263,  -496,  -496,  -496,  -496,  -496,  -496,
+    -496,  -496,  -496,  -496,  -496,  -496,  -496,    28,  -496,  -496
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -369
+#define YYTABLE_NINF -379
 static const yytype_int16 yytable[] =
 {
-     208,   236,   229,   355,   192,   194,   364,   439,   252,   244,
-     485,   304,   440,   220,   442,   403,   409,   444,   394,   503,
-     217,   262,   215,   365,   366,   236,   307,   383,   384,   238,
-     229,   373,   308,   306,   503,   216,   260,   251,   238,   222,
-     231,   318,   -27,   232,   367,   261,   351,   353,   368,   381,
-     382,   221,   218,   395,   313,   224,   417,   360,   419,   225,
-     361,   445,   385,   386,   424,   425,   426,   427,   428,   429,
-     430,   431,   432,   433,   238,   478,   528,   306,   233,   398,
-     531,   352,   400,   434,   357,   531,   306,   436,   238,   263,
-     437,   310,   264,   441,   355,   265,   355,   311,   449,   355,
-     370,   488,   447,   242,   409,   500,   371,   476,   436,   236,
-     477,   436,   501,   451,   248,   534,   538,   313,   436,   253,
-     313,   436,   459,   460,   461,   462,   436,   476,   258,   481,
-     494,   188,   189,   190,   387,   388,   376,   377,   378,   379,
-     489,   380,   490,   436,   483,   480,   409,   306,   439,   482,
-     508,   436,   509,   455,   456,   259,   457,   458,   463,   464,
-     309,   359,   245,   313,   317,   369,   374,   391,   389,   390,
-     393,   392,   396,   399,   405,   410,   413,   486,   487,   414,
-     411,   415,   418,   355,   446,   420,   291,   421,   -26,   450,
-     540,   422,   -21,   475,   496,   472,   492,   230,   510,  -368,
-     519,   439,   493,   436,   520,   237,   521,   524,   313,   525,
-     526,   330,   208,   529,   530,   502,   192,   194,   542,   250,
-     541,   362,   363,   465,   467,   230,   466,   468,   256,   230,
-     502,   469,   355,   470,   255,   257,   402,   219,   495,   497,
-     375,   523,   527,   536,   474,   537,   254,   498,   511,   314,
-     313,   522,   241,   339,   291,   535,     0,   291,     0,     0,
+     216,   237,   244,   365,   200,   374,   202,   260,   449,   252,
+     495,   419,   314,   450,   413,   452,   228,   404,   454,   513,
+     270,   391,   392,   393,   394,   246,   244,   225,   268,   237,
+     246,   538,   362,   383,   513,   541,   317,   269,   223,   246,
+     541,   316,   318,   375,   376,   361,   363,   259,   271,   328,
+     224,   272,   405,   323,   273,   427,   229,   429,   395,   396,
+     455,   226,   -29,   316,   377,   316,   230,   320,   378,   380,
+     367,   457,   451,   321,   510,   381,   488,   446,   511,   389,
+     446,   390,   408,   232,   446,   410,   434,   435,   436,   437,
+     438,   439,   440,   441,   442,   443,   365,   459,   365,   419,
+     544,   365,   498,   467,   468,   444,   446,   469,   470,   471,
+     472,   239,   244,   233,   240,   461,   548,   370,   323,   446,
+     371,   323,   447,   486,   446,   486,   487,   491,   504,   196,
+     197,   198,   397,   398,   386,   387,   388,   499,   241,   500,
+     250,   419,   446,   493,   490,   446,   519,   246,   492,   449,
+     256,   518,   465,   466,   473,   474,   261,   266,   267,   316,
+     319,   369,   253,   327,   323,   379,   384,   402,   403,   401,
+     399,   400,   409,   406,   415,   420,   423,   421,   424,   496,
+     497,   425,   428,   430,   456,   365,   431,   460,   432,   -28,
+     506,   550,   446,   301,   485,   -23,   482,   520,   502,   529,
+    -378,   503,   449,   530,   531,   238,   535,   536,   534,   323,
+     340,   539,   540,   245,   512,   552,   475,   477,   551,   480,
+     216,   476,   264,   263,   200,   478,   202,   258,   265,   512,
+     372,   373,   227,   238,   365,   479,   484,   238,   412,   505,
+     533,   507,   537,   546,   262,   547,   521,   508,   249,   385,
+       0,   323,     0,   532,   545,     0,     0,   324,     0,     0,
+       0,   349,     0,   301,     0,     0,   301,     0,     0,     0,
+       0,     0,     0,     0,   365,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   355,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   504,
+     514,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   244,     0,   514,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     236,     0,     0,     0,   504,     0,     0,     0,     0,     0,
-       0,     0,   314,   404,     0,   314,     0,     0,     0,     0,
-       0,     0,     0,     0,   452,   453,   454,   291,   291,   291,
-     291,   291,   291,   291,   291,   291,   291,   291,   291,   291,
-     291,   291,   291,     0,   339,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   314,     0,
+       0,     0,   324,   414,     0,   324,     0,     0,     0,     0,
+       0,     0,     0,   462,   463,   464,   301,   301,   301,   301,
+     301,   301,   301,   301,   301,   301,   301,   301,   301,   301,
+     301,   301,     0,     0,   349,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   324,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   314,     0,     0,     0,     0,     0,     0,
-       0,     0,   339,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   339,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   324,     0,     0,     0,     0,     0,     0,
+       0,     0,   349,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   349,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   314,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   324,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   339,
-       0,     0,     0,     0,   339,   339,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   339,
-       0,     0,     0,     0,   237,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   339,     0,     0,     0,
-     339,     0,     0,     0,     0,   339,     0,   240,     0,   339,
-       1,     2,     3,     4,     5,     6,     7,     8,   339,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    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,     0,     0,   185,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   186,   187,
-     188,   189,   190,   191,     1,     2,     3,     4,     5,     6,
-       7,     8,   319,   320,   321,     0,   322,   323,   324,   325,
-     326,   327,   328,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-      36,    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,   329,
-     267,   185,   268,   269,   270,   271,   272,     0,     0,   273,
-     274,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   275,     0,
-       0,     0,   330,   331,     0,     0,     0,     0,   332,   277,
-     278,   279,   280,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   186,   187,   188,   189,   190,   191,     1,     2,
-       3,     4,     5,     6,     7,     8,   319,   320,   321,     0,
-     322,   323,   324,   325,   326,   327,   328,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    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,   329,   267,   185,   268,   269,   270,   271,
-     272,     0,     0,   273,   274,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   275,     0,     0,     0,   330,   438,     0,     0,
-       0,     0,   332,   277,   278,   279,   280,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   186,   187,   188,   189,
-     190,   191,     1,     2,     3,     4,     5,     6,     7,     8,
-     319,   320,   321,     0,   322,   323,   324,   325,   326,   327,
-     328,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    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,   329,   267,   185,
-     268,   269,   270,   271,   272,     0,     0,   273,   274,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   275,     0,     0,     0,
-     330,     0,     0,     0,     0,     0,   332,   277,   278,   279,
-     280,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     186,   187,   188,   189,   190,   191,     1,     2,     3,     4,
-       5,     6,     7,     8,   319,   320,   321,     0,   322,   323,
-     324,   325,   326,   327,   328,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      34,    35,    36,    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,   329,   267,   185,   268,   269,   270,   271,   272,     0,
-       0,   273,   274,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     275,     0,     0,     0,   253,     0,     0,     0,     0,     0,
-     332,   277,   278,   279,   280,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   186,   187,   188,   189,   190,   191,
-       1,     2,     3,     4,     5,     6,     7,     8,   319,   320,
-     321,     0,   322,   323,   324,   325,   326,   327,   328,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    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,   329,   267,   185,   268,   269,
-     270,   271,   272,     0,     0,   273,   274,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   349,
+       0,     0,     0,     0,   349,   349,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   349,
+       0,     0,     0,     0,   245,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   349,     0,     0,     0,
+     349,     0,     0,     0,     0,   349,     0,     0,     0,   349,
+       0,     0,     0,     0,     0,     0,   248,     0,   349,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   275,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   332,   277,   278,   279,   280,     1,
-       2,     3,     4,     5,     6,     7,     8,     0,   186,   187,
-     188,   189,   190,   191,     0,     0,     0,     0,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -1574,37 +1448,16 @@ static const yytype_int16 yytable[] =
      151,   152,   153,   154,   155,   156,   157,   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,     0,   267,   185,   268,   269,   270,
-     271,   272,     0,     0,   273,   274,     0,     0,     0,     0,
+     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
+     191,   192,     0,     0,   193,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   275,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   332,   277,   278,   279,   280,     1,     2,
-       3,     4,     5,     6,     7,     8,     0,   186,   187,   188,
-     189,   190,   191,     0,     0,     0,     0,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    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,     0,     0,   185,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     1,     2,     3,     4,     5,     6,     7,
-       8,     0,     0,     0,     0,     0,   186,   187,   188,   189,
-     190,   191,     9,    10,    11,    12,    13,    14,    15,    16,
+       0,     0,     0,     0,     0,     0,     0,   194,   195,   196,
+     197,   198,   199,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,   329,   330,   331,     0,   332,   333,   334,
+     335,   336,   337,   338,    11,    12,    13,    14,    15,    16,
       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
@@ -1621,37 +1474,16 @@ static const yytype_int16 yytable[] =
      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
      157,   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,     0,   267,
-     185,   268,   269,   270,   271,   272,     0,     0,   273,   274,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   275,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   277,   278,
-     279,   280,     1,     2,     3,     4,     5,     6,     7,     8,
-       0,   186,   187,   188,   189,   190,     0,     0,     0,     0,
-       0,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    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,     0,   234,   185,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   339,   275,   193,   276,
+     277,   278,   279,   280,   281,   282,     0,     0,   283,   284,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   235,     1,     2,     3,
-       4,     5,     6,     7,     8,     0,     0,     0,     0,     0,
-     186,   187,   188,   189,   190,     0,     9,    10,    11,    12,
+       0,     0,     0,     0,     0,     0,     0,   285,     0,     0,
+       0,   340,   341,     0,     0,     0,     0,   342,   287,   288,
+     289,   290,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   194,   195,   196,   197,   198,   199,     1,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,   329,   330,   331,
+       0,   332,   333,   334,   335,   336,   337,   338,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
@@ -1669,13 +1501,16 @@ static const yytype_int16 yytable[] =
      153,   154,   155,   156,   157,   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,     0,     0,   185,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
+     339,   275,   193,   276,   277,   278,   279,   280,   281,   282,
+       0,     0,   283,   284,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   408,     0,     0,     0,
-       0,     1,     2,     3,     4,     5,     6,     7,     8,     0,
-       0,     0,     0,     0,     0,   186,   187,   188,   189,   190,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+       0,   285,     0,     0,     0,   340,   448,     0,     0,     0,
+       0,   342,   287,   288,   289,   290,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   194,   195,   196,   197,   198,
+     199,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,   329,   330,   331,     0,   332,   333,   334,   335,   336,
+     337,   338,    11,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
@@ -1692,13 +1527,16 @@ static const yytype_int16 yytable[] =
      149,   150,   151,   152,   153,   154,   155,   156,   157,   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,     0,     0,   185,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   339,   275,   193,   276,   277,   278,
+     279,   280,   281,   282,     0,     0,   283,   284,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     473,     0,     0,     0,     0,     1,     2,     3,     4,     5,
-       6,     7,     8,     0,     0,     0,     0,     0,     0,   186,
-     187,   188,   189,   190,     9,    10,    11,    12,    13,    14,
+       0,     0,     0,     0,     0,   285,     0,     0,     0,   340,
+       0,     0,     0,     0,     0,   342,   287,   288,   289,   290,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   194,
+     195,   196,   197,   198,   199,     1,     2,     3,     4,     5,
+       6,     7,     8,     9,    10,   329,   330,   331,     0,   332,
+     333,   334,   335,   336,   337,   338,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
@@ -1716,12 +1554,15 @@ static const yytype_int16 yytable[] =
      155,   156,   157,   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,
-       0,     0,   185,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   491,     0,     0,     0,     0,     1,
-       2,     3,     4,     5,     6,     7,     8,     0,     0,     0,
-       0,     0,     0,   186,   187,   188,   189,   190,     9,    10,
+     185,   186,   187,   188,   189,   190,   191,   192,   339,   275,
+     193,   276,   277,   278,   279,   280,   281,   282,     0,     0,
+     283,   284,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   285,
+       0,     0,     0,   261,     0,     0,     0,     0,     0,   342,
+     287,   288,   289,   290,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   194,   195,   196,   197,   198,   199,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,   329,
+     330,   331,     0,   332,   333,   334,   335,   336,   337,   338,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
@@ -1739,14 +1580,20 @@ static const yytype_int16 yytable[] =
      151,   152,   153,   154,   155,   156,   157,   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,     0,     0,   185,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     4,     5,     6,     7,
-       8,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   186,   187,   188,
-     189,   190,    39,    40,    41,    42,    43,    44,     0,     0,
-       0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
+     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
+     191,   192,   339,   275,   193,   276,   277,   278,   279,   280,
+     281,   282,     0,     0,   283,   284,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   285,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   342,   287,   288,   289,   290,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   194,   195,   196,
+     197,   198,   199,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      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,
@@ -1759,16 +1606,44 @@ static const yytype_int16 yytable[] =
      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
      157,   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,     0,   267,
-     185,   268,   269,   270,   271,   272,     0,     0,   273,   274,
+     177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,     0,   275,   193,   276,
+     277,   278,   279,   280,   281,   282,     0,     0,   283,   284,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   285,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   342,   287,   288,
+     289,   290,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   194,   195,   196,   197,   198,   199,     1,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    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,
+       0,     0,   193,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   275,     0,     0,
-       0,   354,   507,     4,     5,     6,     7,     8,   277,   278,
-     279,   280,     0,     0,     0,     0,     0,     0,     0,     0,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    39,
-      40,    41,    42,    43,    44,     0,     0,     0,     0,    49,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
+       0,     0,     0,     0,     0,   194,   195,   196,   197,   198,
+     199,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    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,
@@ -1782,83 +1657,44 @@ static const yytype_int16 yytable[] =
      150,   151,   152,   153,   154,   155,   156,   157,   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,     0,   267,   185,   268,   269,
-     270,   271,   272,     0,     0,   273,   274,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   275,     0,     0,   276,     4,     5,
-       6,     7,     8,     0,     0,   277,   278,   279,   280,     0,
-       0,     0,     0,     0,     0,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+     190,   191,   192,     0,   275,   193,   276,   277,   278,   279,
+     280,   281,   282,     0,     0,   283,   284,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    39,    40,    41,    42,    43,    44,
-       0,     0,     0,     0,    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,
-       0,   267,   185,   268,   269,   270,   271,   272,     0,     0,
-     273,   274,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   275,
-       0,     0,     0,   354,     4,     5,     6,     7,     8,     0,
-     277,   278,   279,   280,     0,     0,     0,     0,     0,     0,
-       0,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,     0,     0,
+       0,     0,     0,     0,   285,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   287,   288,   289,   290,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   194,   195,
+     196,   197,   198,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      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,     0,   242,   193,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      39,    40,    41,    42,    43,    44,     0,     0,     0,     0,
-      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,     0,   267,   185,   268,
-     269,   270,   271,   272,     0,     0,   273,   274,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   275,     0,     0,   397,     4,
-       5,     6,     7,     8,     0,     0,   277,   278,   279,   280,
-       0,     0,     0,     0,     0,     0,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    39,    40,    41,    42,    43,
-      44,     0,     0,     0,     0,    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,     0,   267,   185,   268,   269,   270,   271,   272,     0,
-       0,   273,   274,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     275,     4,     5,     6,     7,     8,     0,     0,     0,     0,
-     416,   277,   278,   279,   280,     0,     0,     0,    10,    11,
+       0,     0,     0,     0,     0,     0,     0,   243,     1,     2,
+       3,     4,     5,     6,     7,     8,     9,    10,     0,     0,
+       0,   194,   195,   196,   197,   198,     0,     0,     0,    11,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    39,    40,    41,
-      42,    43,    44,     0,     0,     0,     0,    49,    50,    51,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    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,
@@ -1872,15 +1708,17 @@ static const yytype_int16 yytable[] =
      152,   153,   154,   155,   156,   157,   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,     0,   267,   185,   268,   269,   270,   271,
-     272,     0,     0,   273,   274,     0,     0,     0,     0,     0,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+     192,     0,     0,   193,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   275,     4,     5,     6,     7,     8,     0,     0,
-       0,     0,     0,   277,   278,   279,   280,     0,     0,     0,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    39,
-      40,    41,    42,    43,    44,     0,     0,     0,     0,    49,
+       0,     0,     0,     0,     0,     0,     0,   418,     0,     0,
+       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
+       0,     0,     0,     0,     0,     0,   194,   195,   196,   197,
+     198,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    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,
@@ -1894,16 +1732,18 @@ static const yytype_int16 yytable[] =
      150,   151,   152,   153,   154,   155,   156,   157,   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,   372,     0,   267,   185,   268,   269,
-     270,   271,   272,     0,     0,   273,   274,     0,     0,     0,
+     180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
+     190,   191,   192,     0,     0,   193,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   275,     4,     5,     6,     7,     8,
-       0,     0,     0,     0,     0,   277,   278,   279,   280,     0,
-       0,     0,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    39,    40,    41,    42,    43,    44,     0,     0,     0,
-       0,    49,    50,    51,    52,    53,    54,    55,    56,    57,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   483,
+       0,     0,     1,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,     0,     0,     0,     0,     0,     0,   194,   195,
+     196,   197,   198,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    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,
@@ -1916,101 +1756,87 @@ static const yytype_int16 yytable[] =
      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,     0,     0,   185
-};
-
-#define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-466)))
-
-#define yytable_value_is_error(Yytable_value) \
-  YYID (0)
-
-static const yytype_int16 yycheck[] =
-{
-       0,   205,   197,   261,     0,     0,   275,   344,   220,    46,
-     423,   238,   352,   199,   354,   312,   315,   357,   215,   484,
-     199,   233,   227,   208,   209,   229,   228,   210,   211,   229,
-     225,   289,   234,   229,   499,   227,   227,   237,   229,   237,
-     234,   237,   227,   237,   229,   236,   258,   259,   233,   206,
-     207,   237,   231,   250,   249,   228,   325,   234,   327,   234,
-     237,   358,   245,   246,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   229,   412,   516,   229,   199,   306,
-     520,   236,   309,   236,   236,   525,   229,   234,   229,   231,
-     237,   228,   234,   236,   352,   237,   354,   234,   367,   357,
-     228,   441,   228,   200,   403,   228,   234,   234,   234,   313,
-     237,   234,   228,   371,   231,   228,   529,   312,   234,   231,
-     315,   234,   383,   384,   385,   386,   234,   234,   199,   237,
-     237,   253,   254,   255,   212,   213,   242,   243,   244,   239,
-     232,   241,   234,   234,   235,   414,   445,   229,   485,   418,
-     490,   234,   235,   379,   380,   199,   381,   382,   387,   388,
-     236,   199,   199,   358,   237,   228,   227,   247,   249,   248,
-     216,   214,   230,   200,   199,   237,   227,   435,   436,   227,
-     237,   237,   227,   441,   199,   235,   238,   227,   227,   199,
-     530,   232,   228,   405,   198,   230,   230,   197,   227,   231,
-     199,   538,   471,   234,   228,   205,   232,   237,   403,   228,
-      14,   231,   212,   231,   236,   484,   212,   212,   232,   219,
-     237,   273,   274,   389,   391,   225,   390,   392,   229,   229,
-     499,   393,   490,   394,   225,   229,   311,   191,   476,   479,
-     292,   510,   515,   525,   404,   526,   223,   479,   499,   249,
-     445,   509,   212,   253,   306,   524,    -1,   309,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   530,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   484,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     504,    -1,    -1,    -1,   499,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   312,   313,    -1,   315,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   376,   377,   378,   379,   380,   381,
-     382,   383,   384,   385,   386,   387,   388,   389,   390,   391,
-     392,   393,   394,    -1,   344,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   358,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   403,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   412,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   423,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   445,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   479,
-      -1,    -1,    -1,    -1,   484,   485,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   499,
-      -1,    -1,    -1,    -1,   504,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   516,    -1,    -1,    -1,
-     520,    -1,    -1,    -1,    -1,   525,    -1,     0,    -1,   529,
-       3,     4,     5,     6,     7,     8,     9,    10,   538,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    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,    -1,    -1,   200,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   251,   252,
-     253,   254,   255,   256,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    -1,    15,    16,    17,    18,
+     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
+     188,   189,   190,   191,   192,     0,     0,   193,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   501,     0,     0,     1,     2,     3,     4,     5,     6,
+       7,     8,     9,    10,     0,     0,     0,     0,     0,     0,
+     194,   195,   196,   197,   198,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    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,     0,     0,   193,
+       0,     0,     0,     4,     5,     6,     7,     8,     9,    10,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   194,   195,   196,   197,   198,    47,    48,    49,
+      50,    51,    52,     0,     0,     0,     0,    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,     0,   275,   193,   276,   277,   278,   279,
+     280,   281,   282,     0,     0,   283,   284,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   285,     0,     0,     0,   364,   517,
+       0,     0,     0,     0,     0,   287,   288,   289,   290,     4,
+       5,     6,     7,     8,     9,    10,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    47,    48,    49,    50,    51,    52,     0,
+       0,     0,     0,    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,     0,
+     275,   193,   276,   277,   278,   279,   280,   281,   282,     0,
+       0,   283,   284,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     285,     0,     0,   286,     4,     5,     6,     7,     8,     9,
+      10,   287,   288,   289,   290,     0,     0,     0,     0,     0,
+       0,     0,     0,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      29,    30,    31,    32,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    47,    48,
+      49,    50,    51,    52,     0,     0,     0,     0,    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,
@@ -2024,95 +1850,18 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   208,
-     209,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   227,    -1,
-      -1,    -1,   231,   232,    -1,    -1,    -1,    -1,   237,   238,
-     239,   240,   241,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   251,   252,   253,   254,   255,   256,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    -1,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    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,    -1,    -1,   208,   209,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   227,    -1,    -1,    -1,   231,   232,    -1,    -1,
-      -1,    -1,   237,   238,   239,   240,   241,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   251,   252,   253,   254,
-     255,   256,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    -1,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    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,    -1,    -1,   208,   209,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   227,    -1,    -1,    -1,
-     231,    -1,    -1,    -1,    -1,    -1,   237,   238,   239,   240,
-     241,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     251,   252,   253,   254,   255,   256,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    -1,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      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,    -1,
-      -1,   208,   209,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     227,    -1,    -1,    -1,   231,    -1,    -1,    -1,    -1,    -1,
-     237,   238,   239,   240,   241,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   251,   252,   253,   254,   255,   256,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
+     189,   190,   191,   192,     0,   275,   193,   276,   277,   278,
+     279,   280,   281,   282,     0,     0,   283,   284,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   285,     0,     0,     0,   364,
+       0,     0,     0,     0,     0,     0,   287,   288,   289,   290,
+       4,     5,     6,     7,     8,     9,    10,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    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,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    47,    48,    49,    50,    51,    52,
+       0,     0,     0,     0,    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,
@@ -2126,13 +1875,167 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   208,   209,    -1,    -1,    -1,
+       0,   275,   193,   276,   277,   278,   279,   280,   281,   282,
+       0,     0,   283,   284,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   285,     0,     0,   407,     4,     5,     6,     7,     8,
+       9,    10,   287,   288,   289,   290,     0,     0,     0,     0,
+       0,     0,     0,     0,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    47,
+      48,    49,    50,    51,    52,     0,     0,     0,     0,    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,     0,   275,   193,   276,   277,
+     278,   279,   280,   281,   282,     0,     0,   283,   284,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   285,     4,     5,     6,
+       7,     8,     9,    10,     0,     0,   426,   287,   288,   289,
+     290,     0,     0,     0,     0,     0,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    47,    48,    49,    50,    51,    52,     0,     0,     0,
+       0,    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,     0,   275,   193,
+     276,   277,   278,   279,   280,   281,   282,     0,     0,   283,
+     284,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   285,     4,
+       5,     6,     7,     8,     9,    10,     0,     0,     0,   287,
+     288,   289,   290,     0,     0,     0,     0,     0,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    47,    48,    49,    50,    51,    52,     0,
+       0,     0,     0,    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,   382,     0,
+     275,   193,   276,   277,   278,   279,   280,   281,   282,     0,
+       0,   283,   284,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     285,     4,     5,     6,     7,     8,     9,    10,     0,     0,
+       0,   287,   288,   289,   290,     0,     0,     0,     0,     0,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    47,    48,    49,    50,    51,
+      52,     0,     0,     0,     0,    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,     0,     0,   193
+};
+
+#define yypact_value_is_default(Yystate) \
+  (!!((Yystate) == (-496)))
+
+#define yytable_value_is_error(Yytable_value) \
+  YYID (0)
+
+static const yytype_int16 yycheck[] =
+{
+       0,   205,   213,   269,     0,   285,     0,   228,   354,    54,
+     433,   325,   246,   362,   322,   364,   207,   225,   367,   494,
+     241,   216,   217,   220,   221,   239,   237,   207,   237,   233,
+     239,   526,   246,   299,   509,   530,   238,   246,   237,   239,
+     535,   239,   244,   218,   219,   266,   267,   247,   241,   247,
+     237,   244,   260,   257,   247,   335,   247,   337,   255,   256,
+     368,   241,   237,   239,   239,   239,   247,   238,   243,   238,
+     246,   238,   246,   244,   238,   244,   422,   244,   238,   249,
+     244,   251,   316,   238,   244,   319,   227,   228,   229,   230,
+     231,   232,   233,   234,   235,   236,   362,   377,   364,   413,
+     238,   367,   451,   391,   392,   246,   244,   393,   394,   395,
+     396,   244,   323,   244,   247,   381,   539,   244,   322,   244,
+     247,   325,   247,   244,   244,   244,   247,   247,   247,   263,
+     264,   265,   222,   223,   252,   253,   254,   242,   207,   244,
+     208,   455,   244,   245,   424,   244,   245,   239,   428,   495,
+     241,   500,   389,   390,   397,   398,   241,   207,   207,   239,
+     246,   207,   207,   247,   368,   238,   237,   224,   226,   257,
+     259,   258,   208,   240,   207,   247,   237,   247,   237,   445,
+     446,   247,   237,   245,   207,   451,   237,   207,   242,   237,
+     206,   540,   244,   246,   415,   238,   240,   237,   240,   207,
+     241,   481,   548,   238,   242,   205,   238,    16,   247,   413,
+     241,   241,   246,   213,   494,   242,   399,   401,   247,   404,
+     220,   400,   237,   233,   220,   402,   220,   227,   237,   509,
+     283,   284,   199,   233,   500,   403,   414,   237,   321,   486,
+     520,   489,   525,   535,   231,   536,   509,   489,   220,   302,
+      -1,   455,    -1,   519,   534,    -1,    -1,   257,    -1,    -1,
+      -1,   261,    -1,   316,    -1,    -1,   319,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   540,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     494,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   514,    -1,   509,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   322,   323,    -1,   325,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   386,   387,   388,   389,   390,   391,   392,
+     393,   394,   395,   396,   397,   398,   399,   400,   401,   402,
+     403,   404,    -1,    -1,   354,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   368,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   413,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   422,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   433,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   455,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   489,
+      -1,    -1,    -1,    -1,   494,   495,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   509,
+      -1,    -1,    -1,    -1,   514,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   526,    -1,    -1,    -1,
+     530,    -1,    -1,    -1,    -1,   535,    -1,    -1,    -1,   539,
+      -1,    -1,    -1,    -1,    -1,    -1,     0,    -1,   548,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   227,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   237,   238,   239,   240,   241,     3,
-       4,     5,     6,     7,     8,     9,    10,    -1,   251,   252,
-     253,   254,   255,   256,    -1,    -1,    -1,    -1,    22,    23,
       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
@@ -2150,37 +2053,16 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,   200,   201,   202,   203,
-     204,   205,    -1,    -1,   208,   209,    -1,    -1,    -1,    -1,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,    -1,    -1,   208,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   227,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   237,   238,   239,   240,   241,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,   251,   252,   253,
-     254,   255,   256,    -1,    -1,    -1,    -1,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    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,    -1,    -1,   200,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    -1,    -1,    -1,    -1,    -1,   251,   252,   253,   254,
-     255,   256,    22,    23,    24,    25,    26,    27,    28,    29,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   261,   262,   263,
+     264,   265,   266,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    -1,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
@@ -2197,37 +2079,16 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,
-     200,   201,   202,   203,   204,   205,    -1,    -1,   208,   209,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,    -1,    -1,   218,   219,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   227,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   238,   239,
-     240,   241,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,   251,   252,   253,   254,   255,    -1,    -1,    -1,    -1,
-      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    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,    -1,   199,   200,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   237,     3,     4,     5,
-       6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
-     251,   252,   253,   254,   255,    -1,    22,    23,    24,    25,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,
+      -1,   241,   242,    -1,    -1,    -1,    -1,   247,   248,   249,
+     250,   251,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   261,   262,   263,   264,   265,   266,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
@@ -2245,12 +2106,15 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   200,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
+     206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+      -1,    -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   232,    -1,    -1,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    -1,
-      -1,    -1,    -1,    -1,    -1,   251,   252,   253,   254,   255,
+      -1,   237,    -1,    -1,    -1,   241,   242,    -1,    -1,    -1,
+      -1,   247,   248,   249,   250,   251,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   261,   262,   263,   264,   265,
+     266,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    -1,    17,    18,    19,    20,    21,
       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
@@ -2268,13 +2132,16 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   200,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,    -1,    -1,   218,   219,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     232,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,   251,
-     252,   253,   254,   255,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,   241,
+      -1,    -1,    -1,    -1,    -1,   247,   248,   249,   250,   251,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   261,
+     262,   263,   264,   265,   266,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    -1,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
@@ -2292,12 +2159,15 @@ static const yytype_int16 yycheck[] =
      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
-      -1,    -1,   200,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   232,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    -1,    -1,    -1,
-      -1,    -1,    -1,   251,   252,   253,   254,   255,    22,    23,
+     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+     208,   209,   210,   211,   212,   213,   214,   215,    -1,    -1,
+     218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,
+      -1,    -1,    -1,   241,    -1,    -1,    -1,    -1,    -1,   247,
+     248,   249,   250,   251,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   261,   262,   263,   264,   265,   266,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    -1,    17,    18,    19,    20,    21,    22,    23,
       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
@@ -2315,14 +2185,20 @@ static const yytype_int16 yycheck[] =
      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,    -1,    -1,   200,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,     6,     7,     8,     9,
-      10,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    37,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   251,   252,   253,
-     254,   255,    52,    53,    54,    55,    56,    57,    -1,    -1,
-      -1,    -1,    62,    63,    64,    65,    66,    67,    68,    69,
+     194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
+     204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
+     214,   215,    -1,    -1,   218,   219,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   247,   248,   249,   250,   251,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   261,   262,   263,
+     264,   265,   266,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    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,
@@ -2335,17 +2211,189 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,
-     200,   201,   202,   203,   204,   205,    -1,    -1,   208,   209,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+     200,   201,   202,   203,   204,   205,    -1,   207,   208,   209,
+     210,   211,   212,   213,   214,   215,    -1,    -1,   218,   219,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   247,   248,   249,
+     250,   251,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   261,   262,   263,   264,   265,   266,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    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,
+      -1,    -1,   208,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      -1,    -1,    -1,    -1,    -1,   261,   262,   263,   264,   265,
+     266,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    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,    -1,   207,   208,   209,   210,   211,   212,
+     213,   214,   215,    -1,    -1,   218,   219,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   248,   249,   250,   251,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   261,   262,
+     263,   264,   265,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    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,    -1,   207,   208,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   247,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    -1,    -1,
+      -1,   261,   262,   263,   264,   265,    -1,    -1,    -1,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    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,    -1,    -1,   208,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   242,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,   261,   262,   263,   264,
+     265,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    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,    -1,    -1,   208,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   242,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    12,    -1,    -1,    -1,    -1,    -1,    -1,   261,   262,
+     263,   264,   265,    24,    25,    26,    27,    28,    29,    30,
+      31,    32,    33,    34,    35,    36,    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,    -1,    -1,   208,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   227,    -1,    -1,
-      -1,   231,   232,     6,     7,     8,     9,    10,   238,   239,
-     240,   241,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,
-      53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   242,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,
+     261,   262,   263,   264,   265,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    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,    -1,    -1,   208,
+      -1,    -1,    -1,     6,     7,     8,     9,    10,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
+      43,    44,    45,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   261,   262,   263,   264,   265,    60,    61,    62,
+      63,    64,    65,    -1,    -1,    -1,    -1,    70,    71,    72,
       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
       93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
@@ -2358,39 +2406,42 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,   200,   201,   202,
-     203,   204,   205,    -1,    -1,   208,   209,    -1,    -1,    -1,
+     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,    -1,   207,   208,   209,   210,   211,   212,
+     213,   214,   215,    -1,    -1,   218,   219,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   227,    -1,    -1,   230,     6,     7,
-       8,     9,    10,    -1,    -1,   238,   239,   240,   241,    -1,
-      -1,    -1,    -1,    -1,    -1,    23,    24,    25,    26,    27,
-      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,   241,   242,
+      -1,    -1,    -1,    -1,    -1,   248,   249,   250,   251,     6,
+       7,     8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    52,    53,    54,    55,    56,    57,
-      -1,    -1,    -1,    -1,    62,    63,    64,    65,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
-     118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
-     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,
-      -1,   199,   200,   201,   202,   203,   204,   205,    -1,    -1,
-     208,   209,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   227,
-      -1,    -1,    -1,   231,     6,     7,     8,     9,    10,    -1,
-     238,   239,   240,   241,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    60,    61,    62,    63,    64,    65,    -1,
+      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+     117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+     157,   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,    -1,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,    -1,
+      -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      52,    53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+     237,    -1,    -1,   240,     6,     7,     8,     9,    10,    11,
+      12,   248,   249,   250,   251,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    61,
+      62,    63,    64,    65,    -1,    -1,    -1,    -1,    70,    71,
       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
@@ -2403,17 +2454,89 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,   200,   201,
-     202,   203,   204,   205,    -1,    -1,   208,   209,    -1,    -1,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,    -1,   207,   208,   209,   210,   211,
+     212,   213,   214,   215,    -1,    -1,   218,   219,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   237,    -1,    -1,    -1,   241,
+      -1,    -1,    -1,    -1,    -1,    -1,   248,   249,   250,   251,
+       6,     7,     8,     9,    10,    11,    12,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,    65,
+      -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
+     116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
+     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
+     156,   157,   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,
+      -1,   207,   208,   209,   210,   211,   212,   213,   214,   215,
+      -1,    -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   237,    -1,    -1,   240,     6,     7,     8,     9,    10,
+      11,    12,   248,   249,   250,   251,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    25,    26,    27,    28,    29,    30,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
+      41,    42,    43,    44,    45,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,
+      61,    62,    63,    64,    65,    -1,    -1,    -1,    -1,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
+      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
+      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
+     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
+     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
+     151,   152,   153,   154,   155,   156,   157,   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,    -1,   207,   208,   209,   210,
+     211,   212,   213,   214,   215,    -1,    -1,   218,   219,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   237,     6,     7,     8,
+       9,    10,    11,    12,    -1,    -1,   247,   248,   249,   250,
+     251,    -1,    -1,    -1,    -1,    -1,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   227,    -1,    -1,   230,     6,
-       7,     8,     9,    10,    -1,    -1,   238,   239,   240,   241,
-      -1,    -1,    -1,    -1,    -1,    -1,    23,    24,    25,    26,
+      -1,    60,    61,    62,    63,    64,    65,    -1,    -1,    -1,
+      -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
+     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
+     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,   154,   155,   156,   157,   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,    -1,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,    -1,    -1,   218,
+     219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   237,     6,
+       7,     8,     9,    10,    11,    12,    -1,    -1,    -1,   248,
+     249,   250,   251,    -1,    -1,    -1,    -1,    -1,    25,    26,
       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    52,    53,    54,    55,    56,
-      57,    -1,    -1,    -1,    -1,    62,    63,    64,    65,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    60,    61,    62,    63,    64,    65,    -1,
+      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
@@ -2426,16 +2549,17 @@ static const yytype_int16 yycheck[] =
      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
-     197,    -1,   199,   200,   201,   202,   203,   204,   205,    -1,
-      -1,   208,   209,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,    -1,
+     207,   208,   209,   210,   211,   212,   213,   214,   215,    -1,
+      -1,   218,   219,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     227,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
-     237,   238,   239,   240,   241,    -1,    -1,    -1,    23,    24,
+     237,     6,     7,     8,     9,    10,    11,    12,    -1,    -1,
+      -1,   248,   249,   250,   251,    -1,    -1,    -1,    -1,    -1,
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
-      55,    56,    57,    -1,    -1,    -1,    -1,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    60,    61,    62,    63,    64,
+      65,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
@@ -2448,59 +2572,16 @@ static const yytype_int16 yycheck[] =
      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,    -1,   199,   200,   201,   202,   203,   204,
-     205,    -1,    -1,   208,   209,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   227,     6,     7,     8,     9,    10,    -1,    -1,
-      -1,    -1,    -1,   238,   239,   240,   241,    -1,    -1,    -1,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,
-      53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
-     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,   157,   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,    -1,   199,   200,   201,   202,
-     203,   204,   205,    -1,    -1,   208,   209,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   227,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,   238,   239,   240,   241,    -1,
-      -1,    -1,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    52,    53,    54,    55,    56,    57,    -1,    -1,    -1,
-      -1,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
-     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,   157,   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,    -1,    -1,   200
+     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+     205,    -1,    -1,   208
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const yytype_uint16 yystos[] =
 {
-       0,     3,     4,     5,     6,     7,     8,     9,    10,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       33,    34,    35,    36,    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,
@@ -2517,43 +2598,44 @@ static const yytype_uint16 yystos[] =
      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,   200,   251,   252,   253,   254,
-     255,   256,   291,   292,   295,   296,   297,   298,   302,   303,
-     304,   305,   306,   307,   310,   311,   312,   313,   315,   317,
-     318,   319,   356,   357,   358,   227,   227,   199,   231,   318,
-     199,   237,   237,   359,   228,   234,   299,   300,   301,   311,
-     315,   234,   237,   199,   199,   237,   312,   315,   229,   316,
-       0,   357,   200,   314,    46,   199,   308,   309,   231,   321,
-     315,   237,   316,   231,   338,   300,   299,   301,   199,   199,
-     227,   236,   316,   231,   234,   237,   294,   199,   201,   202,
-     203,   204,   205,   208,   209,   227,   230,   238,   239,   240,
-     241,   261,   262,   263,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
-     281,   282,   283,   284,   285,   315,   229,   228,   234,   236,
-     228,   234,   320,   311,   315,   322,   323,   237,   237,    11,
-      12,    13,    15,    16,    17,    18,    19,    20,    21,   198,
-     231,   232,   237,   272,   285,   287,   289,   291,   295,   315,
-     328,   329,   330,   331,   339,   340,   341,   344,   347,   348,
-     355,   316,   236,   316,   231,   287,   326,   236,   293,   199,
-     234,   237,   272,   272,   289,   208,   209,   229,   233,   228,
-     228,   234,   197,   287,   227,   272,   242,   243,   244,   239,
-     241,   206,   207,   210,   211,   245,   246,   212,   213,   249,
-     248,   247,   214,   216,   215,   250,   230,   230,   285,   200,
-     285,   290,   309,   322,   315,   199,   324,   325,   232,   323,
-     237,   237,   350,   227,   227,   237,   237,   289,   227,   289,
-     235,   227,   232,   332,   217,   218,   219,   220,   221,   222,
-     223,   224,   225,   226,   236,   288,   234,   237,   232,   329,
-     326,   236,   326,   327,   326,   322,   199,   228,   264,   289,
-     199,   287,   272,   272,   272,   274,   274,   275,   275,   276,
-     276,   276,   276,   277,   277,   278,   279,   280,   281,   282,
-     283,   286,   230,   232,   324,   316,   234,   237,   329,   351,
-     289,   237,   289,   235,   349,   339,   287,   287,   326,   232,
-     234,   232,   230,   289,   237,   325,   198,   328,   340,   352,
-     228,   228,   289,   304,   311,   343,   333,   232,   326,   235,
-     227,   343,   353,   354,   335,   336,   337,   342,   345,   199,
-     228,   232,   287,   289,   237,   228,    14,   331,   330,   231,
-     236,   330,   334,   338,   228,   289,   334,   335,   339,   346,
-     326,   237,   232
+     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,   208,   261,   262,   263,   264,   265,   266,
+     301,   302,   305,   306,   307,   308,   312,   313,   314,   315,
+     316,   317,   320,   321,   322,   323,   325,   327,   328,   329,
+     366,   367,   368,   237,   237,   207,   241,   328,   207,   247,
+     247,   369,   238,   244,   309,   310,   311,   321,   325,   244,
+     247,   207,   207,   247,   322,   325,   239,   326,     0,   367,
+     208,   324,    54,   207,   318,   319,   241,   331,   325,   247,
+     326,   241,   348,   310,   309,   311,   207,   207,   237,   246,
+     326,   241,   244,   247,   304,   207,   209,   210,   211,   212,
+     213,   214,   215,   218,   219,   237,   240,   248,   249,   250,
+     251,   271,   272,   273,   275,   276,   277,   278,   279,   280,
+     281,   282,   283,   284,   285,   286,   287,   288,   289,   290,
+     291,   292,   293,   294,   295,   325,   239,   238,   244,   246,
+     238,   244,   330,   321,   325,   332,   333,   247,   247,    13,
+      14,    15,    17,    18,    19,    20,    21,    22,    23,   206,
+     241,   242,   247,   282,   295,   297,   299,   301,   305,   325,
+     338,   339,   340,   341,   349,   350,   351,   354,   357,   358,
+     365,   326,   246,   326,   241,   297,   336,   246,   303,   207,
+     244,   247,   282,   282,   299,   218,   219,   239,   243,   238,
+     238,   244,   205,   297,   237,   282,   252,   253,   254,   249,
+     251,   216,   217,   220,   221,   255,   256,   222,   223,   259,
+     258,   257,   224,   226,   225,   260,   240,   240,   295,   208,
+     295,   300,   319,   332,   325,   207,   334,   335,   242,   333,
+     247,   247,   360,   237,   237,   247,   247,   299,   237,   299,
+     245,   237,   242,   342,   227,   228,   229,   230,   231,   232,
+     233,   234,   235,   236,   246,   298,   244,   247,   242,   339,
+     336,   246,   336,   337,   336,   332,   207,   238,   274,   299,
+     207,   297,   282,   282,   282,   284,   284,   285,   285,   286,
+     286,   286,   286,   287,   287,   288,   289,   290,   291,   292,
+     293,   296,   240,   242,   334,   326,   244,   247,   339,   361,
+     299,   247,   299,   245,   359,   349,   297,   297,   336,   242,
+     244,   242,   240,   299,   247,   335,   206,   338,   350,   362,
+     238,   238,   299,   314,   321,   353,   343,   242,   336,   245,
+     237,   353,   363,   364,   345,   346,   347,   352,   355,   207,
+     238,   242,   297,   299,   247,   238,    16,   341,   340,   241,
+     246,   340,   344,   348,   238,   299,   344,   345,   349,   356,
+     336,   247,   242
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -3374,7 +3456,7 @@ yyreduce:
     {
         case 2:
 /* Line 1792 of yacc.c  */
-#line 244 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 246 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[(1) - (1)].lex).loc, (yyvsp[(1) - (1)].lex).symbol, (yyvsp[(1) - (1)].lex).string);
     }
@@ -3382,7 +3464,7 @@ yyreduce:
 
   case 3:
 /* Line 1792 of yacc.c  */
-#line 250 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 252 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
@@ -3390,7 +3472,7 @@ yyreduce:
 
   case 4:
 /* Line 1792 of yacc.c  */
-#line 253 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 255 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).i, (yyvsp[(1) - (1)].lex).loc, true);
     }
@@ -3398,7 +3480,7 @@ yyreduce:
 
   case 5:
 /* Line 1792 of yacc.c  */
-#line 256 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 258 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).u, (yyvsp[(1) - (1)].lex).loc, true);
@@ -3407,32 +3489,50 @@ yyreduce:
 
   case 6:
 /* Line 1792 of yacc.c  */
-#line 260 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 262 "glslang.y"
     {
-        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtFloat, (yyvsp[(1) - (1)].lex).loc, true);
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer literal");
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).i64, (yyvsp[(1) - (1)].lex).loc, true);
     }
     break;
 
   case 7:
 /* Line 1792 of yacc.c  */
-#line 263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 266 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer literal");
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).u64, (yyvsp[(1) - (1)].lex).loc, true);
+    }
+    break;
+
+  case 8:
+/* Line 1792 of yacc.c  */
+#line 270 "glslang.y"
+    {
+        (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtFloat, (yyvsp[(1) - (1)].lex).loc, true);
+    }
+    break;
+
+  case 9:
+/* Line 1792 of yacc.c  */
+#line 273 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double literal");
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).d, EbtDouble, (yyvsp[(1) - (1)].lex).loc, true);
     }
     break;
 
-  case 8:
+  case 10:
 /* Line 1792 of yacc.c  */
-#line 267 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 277 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[(1) - (1)].lex).b, (yyvsp[(1) - (1)].lex).loc, true);
     }
     break;
 
-  case 9:
+  case 11:
 /* Line 1792 of yacc.c  */
-#line 270 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 280 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(2) - (3)].interm.intermTypedNode);
         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
@@ -3440,41 +3540,41 @@ yyreduce:
     }
     break;
 
-  case 10:
+  case 12:
 /* Line 1792 of yacc.c  */
-#line 278 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 288 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 11:
+  case 13:
 /* Line 1792 of yacc.c  */
-#line 281 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 291 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[(2) - (4)].lex).loc, (yyvsp[(1) - (4)].interm.intermTypedNode), (yyvsp[(3) - (4)].interm.intermTypedNode));
     }
     break;
 
-  case 12:
+  case 14:
 /* Line 1792 of yacc.c  */
-#line 284 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 294 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 13:
+  case 15:
 /* Line 1792 of yacc.c  */
-#line 287 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 297 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[(3) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode), *(yyvsp[(3) - (3)].lex).string);
     }
     break;
 
-  case 14:
+  case 16:
 /* Line 1792 of yacc.c  */
-#line 290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 300 "glslang.y"
     {
         parseContext.variableCheck((yyvsp[(1) - (2)].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[(2) - (2)].lex).loc, "++", (yyvsp[(1) - (2)].interm.intermTypedNode));
@@ -3482,9 +3582,9 @@ yyreduce:
     }
     break;
 
-  case 15:
+  case 17:
 /* Line 1792 of yacc.c  */
-#line 295 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 305 "glslang.y"
     {
         parseContext.variableCheck((yyvsp[(1) - (2)].interm.intermTypedNode));
         parseContext.lValueErrorCheck((yyvsp[(2) - (2)].lex).loc, "--", (yyvsp[(1) - (2)].interm.intermTypedNode));
@@ -3492,69 +3592,69 @@ yyreduce:
     }
     break;
 
-  case 16:
+  case 18:
 /* Line 1792 of yacc.c  */
-#line 303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 313 "glslang.y"
     {
         parseContext.integerCheck((yyvsp[(1) - (1)].interm.intermTypedNode), "[]");
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 17:
+  case 19:
 /* Line 1792 of yacc.c  */
-#line 310 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 320 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[(1) - (1)].interm).loc, (yyvsp[(1) - (1)].interm).function, (yyvsp[(1) - (1)].interm).intermNode);
         delete (yyvsp[(1) - (1)].interm).function;
     }
     break;
 
-  case 18:
+  case 20:
 /* Line 1792 of yacc.c  */
-#line 317 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 327 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
     }
     break;
 
-  case 19:
+  case 21:
 /* Line 1792 of yacc.c  */
-#line 323 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 333 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
         (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc;
     }
     break;
 
-  case 20:
+  case 22:
 /* Line 1792 of yacc.c  */
-#line 327 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 337 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
         (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc;
     }
     break;
 
-  case 21:
+  case 23:
 /* Line 1792 of yacc.c  */
-#line 334 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 344 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
     }
     break;
 
-  case 22:
+  case 24:
 /* Line 1792 of yacc.c  */
-#line 337 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 347 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
     }
     break;
 
-  case 23:
+  case 25:
 /* Line 1792 of yacc.c  */
-#line 343 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 353 "glslang.y"
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[(2) - (2)].interm.intermTypedNode)->getType());
@@ -3564,9 +3664,9 @@ yyreduce:
     }
     break;
 
-  case 24:
+  case 26:
 /* Line 1792 of yacc.c  */
-#line 350 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 360 "glslang.y"
     {
         TParameter param = { 0, new TType };
         param.type->shallowCopy((yyvsp[(3) - (3)].interm.intermTypedNode)->getType());
@@ -3576,17 +3676,17 @@ yyreduce:
     }
     break;
 
-  case 25:
+  case 27:
 /* Line 1792 of yacc.c  */
-#line 360 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 370 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
     }
     break;
 
-  case 26:
+  case 28:
 /* Line 1792 of yacc.c  */
-#line 368 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 378 "glslang.y"
     {
         // Constructor
         (yyval.interm).intermNode = 0;
@@ -3594,9 +3694,9 @@ yyreduce:
     }
     break;
 
-  case 27:
+  case 29:
 /* Line 1792 of yacc.c  */
-#line 373 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 383 "glslang.y"
     {
         //
         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
@@ -3626,9 +3726,9 @@ yyreduce:
     }
     break;
 
-  case 28:
+  case 30:
 /* Line 1792 of yacc.c  */
-#line 403 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 413 "glslang.y"
     {
         parseContext.variableCheck((yyvsp[(1) - (1)].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
@@ -3637,27 +3737,27 @@ yyreduce:
     }
     break;
 
-  case 29:
+  case 31:
 /* Line 1792 of yacc.c  */
-#line 409 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 419 "glslang.y"
     {
         parseContext.lValueErrorCheck((yyvsp[(1) - (2)].lex).loc, "++", (yyvsp[(2) - (2)].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[(1) - (2)].lex).loc, "++", EOpPreIncrement, (yyvsp[(2) - (2)].interm.intermTypedNode));
     }
     break;
 
-  case 30:
+  case 32:
 /* Line 1792 of yacc.c  */
-#line 413 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 423 "glslang.y"
     {
         parseContext.lValueErrorCheck((yyvsp[(1) - (2)].lex).loc, "--", (yyvsp[(2) - (2)].interm.intermTypedNode));
         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[(1) - (2)].lex).loc, "--", EOpPreDecrement, (yyvsp[(2) - (2)].interm.intermTypedNode));
     }
     break;
 
-  case 31:
+  case 33:
 /* Line 1792 of yacc.c  */
-#line 417 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 427 "glslang.y"
     {
         if ((yyvsp[(1) - (2)].interm).op != EOpNull) {
             char errorOp[2] = {0, 0};
@@ -3676,40 +3776,40 @@ yyreduce:
     }
     break;
 
-  case 32:
+  case 34:
 /* Line 1792 of yacc.c  */
-#line 437 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 447 "glslang.y"
     { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNull; }
     break;
 
-  case 33:
+  case 35:
 /* Line 1792 of yacc.c  */
-#line 438 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 448 "glslang.y"
     { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpNegative; }
     break;
 
-  case 34:
+  case 36:
 /* Line 1792 of yacc.c  */
-#line 439 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 449 "glslang.y"
     { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpLogicalNot; }
     break;
 
-  case 35:
+  case 37:
 /* Line 1792 of yacc.c  */
-#line 440 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 450 "glslang.y"
     { (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpBitwiseNot;
               parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise not"); }
     break;
 
-  case 36:
+  case 38:
 /* Line 1792 of yacc.c  */
-#line 446 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 456 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 37:
+  case 39:
 /* Line 1792 of yacc.c  */
-#line 447 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 457 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "*", EOpMul, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3717,9 +3817,9 @@ yyreduce:
     }
     break;
 
-  case 38:
+  case 40:
 /* Line 1792 of yacc.c  */
-#line 452 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 462 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "/", EOpDiv, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3727,9 +3827,9 @@ yyreduce:
     }
     break;
 
-  case 39:
+  case 41:
 /* Line 1792 of yacc.c  */
-#line 457 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 467 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "%");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "%", EOpMod, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3738,15 +3838,15 @@ yyreduce:
     }
     break;
 
-  case 40:
+  case 42:
 /* Line 1792 of yacc.c  */
-#line 466 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 476 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 41:
+  case 43:
 /* Line 1792 of yacc.c  */
-#line 467 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 477 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "+", EOpAdd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3754,9 +3854,9 @@ yyreduce:
     }
     break;
 
-  case 42:
+  case 44:
 /* Line 1792 of yacc.c  */
-#line 472 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 482 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "-", EOpSub, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3764,15 +3864,15 @@ yyreduce:
     }
     break;
 
-  case 43:
+  case 45:
 /* Line 1792 of yacc.c  */
-#line 480 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 490 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 44:
+  case 46:
 /* Line 1792 of yacc.c  */
-#line 481 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 491 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bit shift left");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<<", EOpLeftShift, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3781,9 +3881,9 @@ yyreduce:
     }
     break;
 
-  case 45:
+  case 47:
 /* Line 1792 of yacc.c  */
-#line 487 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 497 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bit shift right");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">>", EOpRightShift, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3792,15 +3892,15 @@ yyreduce:
     }
     break;
 
-  case 46:
+  case 48:
 /* Line 1792 of yacc.c  */
-#line 496 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 506 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 47:
+  case 49:
 /* Line 1792 of yacc.c  */
-#line 497 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 507 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<", EOpLessThan, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3808,9 +3908,9 @@ yyreduce:
     }
     break;
 
-  case 48:
+  case 50:
 /* Line 1792 of yacc.c  */
-#line 502 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 512 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">", EOpGreaterThan, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3818,9 +3918,9 @@ yyreduce:
     }
     break;
 
-  case 49:
+  case 51:
 /* Line 1792 of yacc.c  */
-#line 507 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 517 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "<=", EOpLessThanEqual, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3828,9 +3928,9 @@ yyreduce:
     }
     break;
 
-  case 50:
+  case 52:
 /* Line 1792 of yacc.c  */
-#line 512 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 522 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3838,15 +3938,15 @@ yyreduce:
     }
     break;
 
-  case 51:
+  case 53:
 /* Line 1792 of yacc.c  */
-#line 520 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 530 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 52:
+  case 54:
 /* Line 1792 of yacc.c  */
-#line 521 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 531 "glslang.y"
     {
         parseContext.arrayObjectCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "==");
@@ -3857,9 +3957,9 @@ yyreduce:
     }
     break;
 
-  case 53:
+  case 55:
 /* Line 1792 of yacc.c  */
-#line 529 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 539 "glslang.y"
     {
         parseContext.arrayObjectCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array comparison");
         parseContext.opaqueCheck((yyvsp[(2) - (3)].lex).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "!=");
@@ -3870,15 +3970,15 @@ yyreduce:
     }
     break;
 
-  case 54:
+  case 56:
 /* Line 1792 of yacc.c  */
-#line 540 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 550 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 55:
+  case 57:
 /* Line 1792 of yacc.c  */
-#line 541 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 551 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise and");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "&", EOpAnd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3887,15 +3987,15 @@ yyreduce:
     }
     break;
 
-  case 56:
+  case 58:
 /* Line 1792 of yacc.c  */
-#line 550 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 560 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 57:
+  case 59:
 /* Line 1792 of yacc.c  */
-#line 551 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 561 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise exclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "^", EOpExclusiveOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3904,15 +4004,15 @@ yyreduce:
     }
     break;
 
-  case 58:
+  case 60:
 /* Line 1792 of yacc.c  */
-#line 560 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 570 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 59:
+  case 61:
 /* Line 1792 of yacc.c  */
-#line 561 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 571 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(2) - (3)].lex).loc, "bitwise inclusive or");
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "|", EOpInclusiveOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
@@ -3921,15 +4021,15 @@ yyreduce:
     }
     break;
 
-  case 60:
+  case 62:
 /* Line 1792 of yacc.c  */
-#line 570 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 580 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 61:
+  case 63:
 /* Line 1792 of yacc.c  */
-#line 571 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 581 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "&&", EOpLogicalAnd, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3937,15 +4037,15 @@ yyreduce:
     }
     break;
 
-  case 62:
+  case 64:
 /* Line 1792 of yacc.c  */
-#line 579 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 589 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 63:
+  case 65:
 /* Line 1792 of yacc.c  */
-#line 580 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 590 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "^^", EOpLogicalXor, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3953,15 +4053,15 @@ yyreduce:
     }
     break;
 
-  case 64:
+  case 66:
 /* Line 1792 of yacc.c  */
-#line 588 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 598 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 65:
+  case 67:
 /* Line 1792 of yacc.c  */
-#line 589 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 599 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[(2) - (3)].lex).loc, "||", EOpLogicalOr, (yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
         if ((yyval.interm.intermTypedNode) == 0)
@@ -3969,23 +4069,23 @@ yyreduce:
     }
     break;
 
-  case 66:
+  case 68:
 /* Line 1792 of yacc.c  */
-#line 597 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 607 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 67:
+  case 69:
 /* Line 1792 of yacc.c  */
-#line 598 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 608 "glslang.y"
     {
         ++parseContext.controlFlowNestingLevel;
     }
     break;
 
-  case 68:
+  case 70:
 /* Line 1792 of yacc.c  */
-#line 601 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 611 "glslang.y"
     {
         --parseContext.controlFlowNestingLevel;
         parseContext.boolCheck((yyvsp[(2) - (6)].lex).loc, (yyvsp[(1) - (6)].interm.intermTypedNode));
@@ -4000,15 +4100,15 @@ yyreduce:
     }
     break;
 
-  case 69:
+  case 71:
 /* Line 1792 of yacc.c  */
-#line 616 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 626 "glslang.y"
     { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
-  case 70:
+  case 72:
 /* Line 1792 of yacc.c  */
-#line 617 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 627 "glslang.y"
     {
         parseContext.arrayObjectCheck((yyvsp[(2) - (3)].interm).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "array assignment");
         parseContext.opaqueCheck((yyvsp[(2) - (3)].interm).loc, (yyvsp[(1) - (3)].interm.intermTypedNode)->getType(), "=");
@@ -4023,36 +4123,36 @@ yyreduce:
     }
     break;
 
-  case 71:
+  case 73:
 /* Line 1792 of yacc.c  */
-#line 632 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 642 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
         (yyval.interm).op = EOpAssign;
     }
     break;
 
-  case 72:
+  case 74:
 /* Line 1792 of yacc.c  */
-#line 636 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 646 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
         (yyval.interm).op = EOpMulAssign;
     }
     break;
 
-  case 73:
+  case 75:
 /* Line 1792 of yacc.c  */
-#line 640 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 650 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
         (yyval.interm).op = EOpDivAssign;
     }
     break;
 
-  case 74:
+  case 76:
 /* Line 1792 of yacc.c  */
-#line 644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 654 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "%=");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
@@ -4060,80 +4160,80 @@ yyreduce:
     }
     break;
 
-  case 75:
+  case 77:
 /* Line 1792 of yacc.c  */
-#line 649 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 659 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
         (yyval.interm).op = EOpAddAssign;
     }
     break;
 
-  case 76:
+  case 78:
 /* Line 1792 of yacc.c  */
-#line 653 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 663 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc;
         (yyval.interm).op = EOpSubAssign;
     }
     break;
 
-  case 77:
+  case 79:
 /* Line 1792 of yacc.c  */
-#line 657 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 667 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bit-shift left assign");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
     }
     break;
 
-  case 78:
+  case 80:
 /* Line 1792 of yacc.c  */
-#line 661 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 671 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bit-shift right assign");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
     }
     break;
 
-  case 79:
+  case 81:
 /* Line 1792 of yacc.c  */
-#line 665 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 675 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-and assign");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpAndAssign;
     }
     break;
 
-  case 80:
+  case 82:
 /* Line 1792 of yacc.c  */
-#line 669 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 679 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-xor assign");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
     }
     break;
 
-  case 81:
+  case 83:
 /* Line 1792 of yacc.c  */
-#line 673 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 683 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "bitwise-or assign");
         (yyval.interm).loc = (yyvsp[(1) - (1)].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
     }
     break;
 
-  case 82:
+  case 84:
 /* Line 1792 of yacc.c  */
-#line 680 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 690 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 83:
+  case 85:
 /* Line 1792 of yacc.c  */
-#line 683 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 693 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode), (yyvsp[(2) - (3)].lex).loc);
         if ((yyval.interm.intermTypedNode) == 0) {
@@ -4143,18 +4243,18 @@ yyreduce:
     }
     break;
 
-  case 84:
+  case 86:
 /* Line 1792 of yacc.c  */
-#line 693 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 703 "glslang.y"
     {
         parseContext.constantValueCheck((yyvsp[(1) - (1)].interm.intermTypedNode), "");
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 85:
+  case 87:
 /* Line 1792 of yacc.c  */
-#line 700 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 710 "glslang.y"
     {
         parseContext.handleFunctionDeclarator((yyvsp[(1) - (2)].interm).loc, *(yyvsp[(1) - (2)].interm).function, true /* prototype */);
         (yyval.interm.intermNode) = 0;
@@ -4162,9 +4262,9 @@ yyreduce:
     }
     break;
 
-  case 86:
+  case 88:
 /* Line 1792 of yacc.c  */
-#line 705 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 715 "glslang.y"
     {
         if ((yyvsp[(1) - (2)].interm).intermNode && (yyvsp[(1) - (2)].interm).intermNode->getAsAggregate())
             (yyvsp[(1) - (2)].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
@@ -4172,9 +4272,9 @@ yyreduce:
     }
     break;
 
-  case 87:
+  case 89:
 /* Line 1792 of yacc.c  */
-#line 710 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 720 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (4)].lex).loc, ENoProfile, 130, 0, "precision statement");
 
@@ -4185,36 +4285,36 @@ yyreduce:
     }
     break;
 
-  case 88:
+  case 90:
 /* Line 1792 of yacc.c  */
-#line 718 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 728 "glslang.y"
     {
         parseContext.declareBlock((yyvsp[(1) - (2)].interm).loc, *(yyvsp[(1) - (2)].interm).typeList);
         (yyval.interm.intermNode) = 0;
     }
     break;
 
-  case 89:
+  case 91:
 /* Line 1792 of yacc.c  */
-#line 722 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 732 "glslang.y"
     {
         parseContext.declareBlock((yyvsp[(1) - (3)].interm).loc, *(yyvsp[(1) - (3)].interm).typeList, (yyvsp[(2) - (3)].lex).string);
         (yyval.interm.intermNode) = 0;
     }
     break;
 
-  case 90:
+  case 92:
 /* Line 1792 of yacc.c  */
-#line 726 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 736 "glslang.y"
     {
         parseContext.declareBlock((yyvsp[(1) - (4)].interm).loc, *(yyvsp[(1) - (4)].interm).typeList, (yyvsp[(2) - (4)].lex).string, (yyvsp[(3) - (4)].interm).arraySizes);
         (yyval.interm.intermNode) = 0;
     }
     break;
 
-  case 91:
+  case 93:
 /* Line 1792 of yacc.c  */
-#line 730 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 740 "glslang.y"
     {
         parseContext.globalQualifierFixCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier);
         parseContext.updateStandaloneQualifierDefaults((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type));
@@ -4222,9 +4322,9 @@ yyreduce:
     }
     break;
 
-  case 92:
+  case 94:
 /* Line 1792 of yacc.c  */
-#line 735 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 745 "glslang.y"
     {
         parseContext.checkNoShaderLayouts((yyvsp[(1) - (3)].interm.type).loc, (yyvsp[(1) - (3)].interm.type).shaderQualifiers);
         parseContext.addQualifierToExisting((yyvsp[(1) - (3)].interm.type).loc, (yyvsp[(1) - (3)].interm.type).qualifier, *(yyvsp[(2) - (3)].lex).string);
@@ -4232,9 +4332,9 @@ yyreduce:
     }
     break;
 
-  case 93:
+  case 95:
 /* Line 1792 of yacc.c  */
-#line 740 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 750 "glslang.y"
     {
         parseContext.checkNoShaderLayouts((yyvsp[(1) - (4)].interm.type).loc, (yyvsp[(1) - (4)].interm.type).shaderQualifiers);
         (yyvsp[(3) - (4)].interm.identifierList)->push_back((yyvsp[(2) - (4)].lex).string);
@@ -4243,15 +4343,15 @@ yyreduce:
     }
     break;
 
-  case 94:
+  case 96:
 /* Line 1792 of yacc.c  */
-#line 749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 759 "glslang.y"
     { parseContext.nestedBlockCheck((yyvsp[(1) - (3)].interm.type).loc); }
     break;
 
-  case 95:
+  case 97:
 /* Line 1792 of yacc.c  */
-#line 749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 759 "glslang.y"
     {
         --parseContext.structNestingLevel;
         parseContext.blockName = (yyvsp[(2) - (6)].lex).string;
@@ -4263,52 +4363,52 @@ yyreduce:
     }
     break;
 
-  case 96:
+  case 98:
 /* Line 1792 of yacc.c  */
-#line 760 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 770 "glslang.y"
     {
         (yyval.interm.identifierList) = new TIdentifierList;
         (yyval.interm.identifierList)->push_back((yyvsp[(2) - (2)].lex).string);
     }
     break;
 
-  case 97:
+  case 99:
 /* Line 1792 of yacc.c  */
-#line 764 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 774 "glslang.y"
     {
         (yyval.interm.identifierList) = (yyvsp[(1) - (3)].interm.identifierList);
         (yyval.interm.identifierList)->push_back((yyvsp[(3) - (3)].lex).string);
     }
     break;
 
-  case 98:
+  case 100:
 /* Line 1792 of yacc.c  */
-#line 771 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 781 "glslang.y"
     {
         (yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
         (yyval.interm).loc = (yyvsp[(2) - (2)].lex).loc;
     }
     break;
 
-  case 99:
+  case 101:
 /* Line 1792 of yacc.c  */
-#line 778 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 788 "glslang.y"
     {
         (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
     }
     break;
 
-  case 100:
+  case 102:
 /* Line 1792 of yacc.c  */
-#line 781 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 791 "glslang.y"
     {
         (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
     }
     break;
 
-  case 101:
+  case 103:
 /* Line 1792 of yacc.c  */
-#line 788 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 798 "glslang.y"
     {
         // Add the parameter
         (yyval.interm.function) = (yyvsp[(1) - (2)].interm.function);
@@ -4319,9 +4419,9 @@ yyreduce:
     }
     break;
 
-  case 102:
+  case 104:
 /* Line 1792 of yacc.c  */
-#line 796 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 806 "glslang.y"
     {
         //
         // Only first parameter of one-parameter functions can be void
@@ -4341,9 +4441,9 @@ yyreduce:
     }
     break;
 
-  case 103:
+  case 105:
 /* Line 1792 of yacc.c  */
-#line 816 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 826 "glslang.y"
     {
         if ((yyvsp[(1) - (3)].interm.type).qualifier.storage != EvqGlobal && (yyvsp[(1) - (3)].interm.type).qualifier.storage != EvqTemporary) {
             parseContext.error((yyvsp[(2) - (3)].lex).loc, "no qualifiers allowed for function return",
@@ -4360,9 +4460,9 @@ yyreduce:
     }
     break;
 
-  case 104:
+  case 106:
 /* Line 1792 of yacc.c  */
-#line 834 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 844 "glslang.y"
     {
         if ((yyvsp[(1) - (2)].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[(1) - (2)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -4380,9 +4480,9 @@ yyreduce:
     }
     break;
 
-  case 105:
+  case 107:
 /* Line 1792 of yacc.c  */
-#line 849 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 859 "glslang.y"
     {
         if ((yyvsp[(1) - (3)].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[(1) - (3)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -4402,9 +4502,9 @@ yyreduce:
     }
     break;
 
-  case 106:
+  case 108:
 /* Line 1792 of yacc.c  */
-#line 872 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 882 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(2) - (2)].interm);
         if ((yyvsp[(1) - (2)].interm.type).qualifier.precision != EpqNone)
@@ -4418,9 +4518,9 @@ yyreduce:
     }
     break;
 
-  case 107:
+  case 109:
 /* Line 1792 of yacc.c  */
-#line 883 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 893 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
 
@@ -4430,9 +4530,9 @@ yyreduce:
     }
     break;
 
-  case 108:
+  case 110:
 /* Line 1792 of yacc.c  */
-#line 893 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 903 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(2) - (2)].interm);
         if ((yyvsp[(1) - (2)].interm.type).qualifier.precision != EpqNone)
@@ -4445,9 +4545,9 @@ yyreduce:
     }
     break;
 
-  case 109:
+  case 111:
 /* Line 1792 of yacc.c  */
-#line 903 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 913 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
 
@@ -4457,9 +4557,9 @@ yyreduce:
     }
     break;
 
-  case 110:
+  case 112:
 /* Line 1792 of yacc.c  */
-#line 913 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 923 "glslang.y"
     {
         TParameter param = { 0, new TType((yyvsp[(1) - (1)].interm.type)) };
         (yyval.interm).param = param;
@@ -4468,35 +4568,35 @@ yyreduce:
     }
     break;
 
-  case 111:
+  case 113:
 /* Line 1792 of yacc.c  */
-#line 922 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 932 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
     }
     break;
 
-  case 112:
+  case 114:
 /* Line 1792 of yacc.c  */
-#line 925 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 935 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (3)].interm);
         parseContext.declareVariable((yyvsp[(3) - (3)].lex).loc, *(yyvsp[(3) - (3)].lex).string, (yyvsp[(1) - (3)].interm).type);
     }
     break;
 
-  case 113:
+  case 115:
 /* Line 1792 of yacc.c  */
-#line 929 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 939 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (4)].interm);
         parseContext.declareVariable((yyvsp[(3) - (4)].lex).loc, *(yyvsp[(3) - (4)].lex).string, (yyvsp[(1) - (4)].interm).type, (yyvsp[(4) - (4)].interm).arraySizes);
     }
     break;
 
-  case 114:
+  case 116:
 /* Line 1792 of yacc.c  */
-#line 933 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 943 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (6)].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[(3) - (6)].lex).loc, *(yyvsp[(3) - (6)].lex).string, (yyvsp[(1) - (6)].interm).type, (yyvsp[(4) - (6)].interm).arraySizes, (yyvsp[(6) - (6)].interm.intermTypedNode));
@@ -4504,9 +4604,9 @@ yyreduce:
     }
     break;
 
-  case 115:
+  case 117:
 /* Line 1792 of yacc.c  */
-#line 938 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 948 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (5)].interm).type;
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[(3) - (5)].lex).loc, *(yyvsp[(3) - (5)].lex).string, (yyvsp[(1) - (5)].interm).type, 0, (yyvsp[(5) - (5)].interm.intermTypedNode));
@@ -4514,9 +4614,9 @@ yyreduce:
     }
     break;
 
-  case 116:
+  case 118:
 /* Line 1792 of yacc.c  */
-#line 946 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 956 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (1)].interm.type);
         (yyval.interm).intermNode = 0;
@@ -4524,9 +4624,9 @@ yyreduce:
     }
     break;
 
-  case 117:
+  case 119:
 /* Line 1792 of yacc.c  */
-#line 951 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 961 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (2)].interm.type);
         (yyval.interm).intermNode = 0;
@@ -4534,9 +4634,9 @@ yyreduce:
     }
     break;
 
-  case 118:
+  case 120:
 /* Line 1792 of yacc.c  */
-#line 956 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 966 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (3)].interm.type);
         (yyval.interm).intermNode = 0;
@@ -4544,9 +4644,9 @@ yyreduce:
     }
     break;
 
-  case 119:
+  case 121:
 /* Line 1792 of yacc.c  */
-#line 961 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 971 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (5)].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[(2) - (5)].lex).loc, *(yyvsp[(2) - (5)].lex).string, (yyvsp[(1) - (5)].interm.type), (yyvsp[(3) - (5)].interm).arraySizes, (yyvsp[(5) - (5)].interm.intermTypedNode));
@@ -4554,9 +4654,9 @@ yyreduce:
     }
     break;
 
-  case 120:
+  case 122:
 /* Line 1792 of yacc.c  */
-#line 966 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 976 "glslang.y"
     {
         (yyval.interm).type = (yyvsp[(1) - (4)].interm.type);
         TIntermNode* initNode = parseContext.declareVariable((yyvsp[(2) - (4)].lex).loc, *(yyvsp[(2) - (4)].lex).string, (yyvsp[(1) - (4)].interm.type), 0, (yyvsp[(4) - (4)].interm.intermTypedNode));
@@ -4564,9 +4664,9 @@ yyreduce:
     }
     break;
 
-  case 121:
+  case 123:
 /* Line 1792 of yacc.c  */
-#line 975 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 985 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
 
@@ -4580,9 +4680,9 @@ yyreduce:
     }
     break;
 
-  case 122:
+  case 124:
 /* Line 1792 of yacc.c  */
-#line 986 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 996 "glslang.y"
     {
         parseContext.globalQualifierFixCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier);
         parseContext.globalQualifierTypeCheck((yyvsp[(1) - (2)].interm.type).loc, (yyvsp[(1) - (2)].interm.type).qualifier, (yyvsp[(2) - (2)].interm.type));
@@ -4609,9 +4709,9 @@ yyreduce:
     }
     break;
 
-  case 123:
+  case 125:
 /* Line 1792 of yacc.c  */
-#line 1013 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1023 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "invariant");
         parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
@@ -4620,9 +4720,9 @@ yyreduce:
     }
     break;
 
-  case 124:
+  case 126:
 /* Line 1792 of yacc.c  */
-#line 1022 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1032 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "smooth");
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "smooth");
@@ -4632,9 +4732,9 @@ yyreduce:
     }
     break;
 
-  case 125:
+  case 127:
 /* Line 1792 of yacc.c  */
-#line 1029 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1039 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "flat");
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "flat");
@@ -4644,9 +4744,9 @@ yyreduce:
     }
     break;
 
-  case 126:
+  case 128:
 /* Line 1792 of yacc.c  */
-#line 1036 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1046 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "noperspective");
         parseContext.requireProfile((yyvsp[(1) - (1)].lex).loc, ~EEsProfile, "noperspective");
@@ -4656,25 +4756,25 @@ yyreduce:
     }
     break;
 
-  case 127:
+  case 129:
 /* Line 1792 of yacc.c  */
-#line 1046 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1056 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(3) - (4)].interm.type);
     }
     break;
 
-  case 128:
+  case 130:
 /* Line 1792 of yacc.c  */
-#line 1052 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1062 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 129:
+  case 131:
 /* Line 1792 of yacc.c  */
-#line 1055 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1065 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (3)].interm.type);
         (yyval.interm.type).shaderQualifiers.merge((yyvsp[(3) - (3)].interm.type).shaderQualifiers);
@@ -4682,27 +4782,27 @@ yyreduce:
     }
     break;
 
-  case 130:
+  case 132:
 /* Line 1792 of yacc.c  */
-#line 1062 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1072 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[(1) - (1)].lex).loc, (yyval.interm.type), *(yyvsp[(1) - (1)].lex).string);
     }
     break;
 
-  case 131:
+  case 133:
 /* Line 1792 of yacc.c  */
-#line 1066 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1076 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (3)].lex).loc);
         parseContext.setLayoutQualifier((yyvsp[(1) - (3)].lex).loc, (yyval.interm.type), *(yyvsp[(1) - (3)].lex).string, (yyvsp[(3) - (3)].interm.intermTypedNode));
     }
     break;
 
-  case 132:
+  case 134:
 /* Line 1792 of yacc.c  */
-#line 1070 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1080 "glslang.y"
     { // because "shared" is both an identifier and a keyword
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         TString strShared("shared");
@@ -4710,25 +4810,25 @@ yyreduce:
     }
     break;
 
-  case 133:
+  case 135:
 /* Line 1792 of yacc.c  */
-#line 1078 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1088 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
     }
     break;
 
-  case 134:
+  case 136:
 /* Line 1792 of yacc.c  */
-#line 1084 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1094 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 135:
+  case 137:
 /* Line 1792 of yacc.c  */
-#line 1087 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1097 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (2)].interm.type);
         if ((yyval.interm.type).basicType == EbtVoid)
@@ -4739,69 +4839,69 @@ yyreduce:
     }
     break;
 
-  case 136:
+  case 138:
 /* Line 1792 of yacc.c  */
-#line 1098 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1108 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 137:
+  case 139:
 /* Line 1792 of yacc.c  */
-#line 1101 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1111 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 138:
+  case 140:
 /* Line 1792 of yacc.c  */
-#line 1104 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1114 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 139:
+  case 141:
 /* Line 1792 of yacc.c  */
-#line 1107 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1117 "glslang.y"
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 140:
+  case 142:
 /* Line 1792 of yacc.c  */
-#line 1111 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1121 "glslang.y"
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 141:
+  case 143:
 /* Line 1792 of yacc.c  */
-#line 1115 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1125 "glslang.y"
     {
         // allow inheritance of storage qualifier from block declaration
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
     }
     break;
 
-  case 142:
+  case 144:
 /* Line 1792 of yacc.c  */
-#line 1122 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1132 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
     }
     break;
 
-  case 143:
+  case 145:
 /* Line 1792 of yacc.c  */
-#line 1126 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1136 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangVertex, "attribute");
         parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ECoreProfile, 130, "attribute");
@@ -4816,9 +4916,9 @@ yyreduce:
     }
     break;
 
-  case 144:
+  case 146:
 /* Line 1792 of yacc.c  */
-#line 1138 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1148 "glslang.y"
     {
         parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, "varying");
         parseContext.checkDeprecated((yyvsp[(1) - (1)].lex).loc, ECoreProfile, 130, "varying");
@@ -4835,9 +4935,9 @@ yyreduce:
     }
     break;
 
-  case 145:
+  case 147:
 /* Line 1792 of yacc.c  */
-#line 1152 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1162 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "inout");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4845,9 +4945,9 @@ yyreduce:
     }
     break;
 
-  case 146:
+  case 148:
 /* Line 1792 of yacc.c  */
-#line 1157 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1167 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "in");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4856,9 +4956,9 @@ yyreduce:
     }
     break;
 
-  case 147:
+  case 149:
 /* Line 1792 of yacc.c  */
-#line 1163 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1173 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "out");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4867,9 +4967,9 @@ yyreduce:
     }
     break;
 
-  case 148:
+  case 150:
 /* Line 1792 of yacc.c  */
-#line 1169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1179 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 120, 0, "centroid");
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, EEsProfile, 300, 0, "centroid");
@@ -4879,9 +4979,9 @@ yyreduce:
     }
     break;
 
-  case 149:
+  case 151:
 /* Line 1792 of yacc.c  */
-#line 1176 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1186 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "patch");
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
@@ -4890,9 +4990,9 @@ yyreduce:
     }
     break;
 
-  case 150:
+  case 152:
 /* Line 1792 of yacc.c  */
-#line 1182 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1192 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "sample");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4900,9 +5000,9 @@ yyreduce:
     }
     break;
 
-  case 151:
+  case 153:
 /* Line 1792 of yacc.c  */
-#line 1187 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1197 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "uniform");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4910,9 +5010,9 @@ yyreduce:
     }
     break;
 
-  case 152:
+  case 154:
 /* Line 1792 of yacc.c  */
-#line 1192 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1202 "glslang.y"
     {
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "buffer");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
@@ -4920,9 +5020,9 @@ yyreduce:
     }
     break;
 
-  case 153:
+  case 155:
 /* Line 1792 of yacc.c  */
-#line 1197 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1207 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ECoreProfile | ECompatibilityProfile, 430, 0, "shared");
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, EEsProfile, 310, 0, "shared");
@@ -4932,54 +5032,54 @@ yyreduce:
     }
     break;
 
-  case 154:
+  case 156:
 /* Line 1792 of yacc.c  */
-#line 1204 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1214 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.coherent = true;
     }
     break;
 
-  case 155:
+  case 157:
 /* Line 1792 of yacc.c  */
-#line 1208 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1218 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.volatil = true;
     }
     break;
 
-  case 156:
+  case 158:
 /* Line 1792 of yacc.c  */
-#line 1212 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1222 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.restrict = true;
     }
     break;
 
-  case 157:
+  case 159:
 /* Line 1792 of yacc.c  */
-#line 1216 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1226 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.readonly = true;
     }
     break;
 
-  case 158:
+  case 160:
 /* Line 1792 of yacc.c  */
-#line 1220 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1230 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc);
         (yyval.interm.type).qualifier.writeonly = true;
     }
     break;
 
-  case 159:
+  case 161:
 /* Line 1792 of yacc.c  */
-#line 1224 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1234 "glslang.y"
     {
         parseContext.spvRemoved((yyvsp[(1) - (1)].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[(1) - (1)].lex).loc, "subroutine");
@@ -4988,9 +5088,9 @@ yyreduce:
     }
     break;
 
-  case 160:
+  case 162:
 /* Line 1792 of yacc.c  */
-#line 1230 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1240 "glslang.y"
     {
         parseContext.spvRemoved((yyvsp[(1) - (4)].lex).loc, "subroutine");
         parseContext.globalCheck((yyvsp[(1) - (4)].lex).loc, "subroutine");
@@ -5002,33 +5102,33 @@ yyreduce:
     }
     break;
 
-  case 161:
+  case 163:
 /* Line 1792 of yacc.c  */
-#line 1242 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1252 "glslang.y"
     {
         // TODO: 4.0 functionality: subroutine type to list
     }
     break;
 
-  case 162:
+  case 164:
 /* Line 1792 of yacc.c  */
-#line 1245 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1255 "glslang.y"
     {
     }
     break;
 
-  case 163:
+  case 165:
 /* Line 1792 of yacc.c  */
-#line 1250 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1260 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
     }
     break;
 
-  case 164:
+  case 166:
 /* Line 1792 of yacc.c  */
-#line 1254 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1264 "glslang.y"
     {
         parseContext.arrayDimCheck((yyvsp[(2) - (2)].interm).loc, (yyvsp[(2) - (2)].interm).arraySizes, 0);
         (yyval.interm.type) = (yyvsp[(1) - (2)].interm.type);
@@ -5037,9 +5137,9 @@ yyreduce:
     }
     break;
 
-  case 165:
+  case 167:
 /* Line 1792 of yacc.c  */
-#line 1263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1273 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (2)].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -5047,9 +5147,9 @@ yyreduce:
     }
     break;
 
-  case 166:
+  case 168:
 /* Line 1792 of yacc.c  */
-#line 1268 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1278 "glslang.y"
     {
         (yyval.interm).loc = (yyvsp[(1) - (3)].lex).loc;
         (yyval.interm).arraySizes = new TArraySizes;
@@ -5060,18 +5160,18 @@ yyreduce:
     }
     break;
 
-  case 167:
+  case 169:
 /* Line 1792 of yacc.c  */
-#line 1276 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1286 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (3)].interm);
         (yyval.interm).arraySizes->addInnerSize();
     }
     break;
 
-  case 168:
+  case 170:
 /* Line 1792 of yacc.c  */
-#line 1280 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1290 "glslang.y"
     {
         (yyval.interm) = (yyvsp[(1) - (4)].interm);
 
@@ -5081,27 +5181,27 @@ yyreduce:
     }
     break;
 
-  case 169:
+  case 171:
 /* Line 1792 of yacc.c  */
-#line 1290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1300 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtVoid;
     }
     break;
 
-  case 170:
+  case 172:
 /* Line 1792 of yacc.c  */
-#line 1294 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1304 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
     }
     break;
 
-  case 171:
+  case 173:
 /* Line 1792 of yacc.c  */
-#line 1298 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1308 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5109,18 +5209,18 @@ yyreduce:
     }
     break;
 
-  case 172:
+  case 174:
 /* Line 1792 of yacc.c  */
-#line 1303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1313 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
     }
     break;
 
-  case 173:
+  case 175:
 /* Line 1792 of yacc.c  */
-#line 1307 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1317 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5128,18 +5228,38 @@ yyreduce:
     }
     break;
 
-  case 174:
+  case 176:
+/* Line 1792 of yacc.c  */
+#line 1322 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtInt64;
+    }
+    break;
+
+  case 177:
+/* Line 1792 of yacc.c  */
+#line 1327 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtUint64;
+    }
+    break;
+
+  case 178:
 /* Line 1792 of yacc.c  */
-#line 1312 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1332 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
     }
     break;
 
-  case 175:
+  case 179:
 /* Line 1792 of yacc.c  */
-#line 1316 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1336 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5147,9 +5267,9 @@ yyreduce:
     }
     break;
 
-  case 176:
+  case 180:
 /* Line 1792 of yacc.c  */
-#line 1321 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1341 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5157,9 +5277,9 @@ yyreduce:
     }
     break;
 
-  case 177:
+  case 181:
 /* Line 1792 of yacc.c  */
-#line 1326 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1346 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5167,9 +5287,9 @@ yyreduce:
     }
     break;
 
-  case 178:
+  case 182:
 /* Line 1792 of yacc.c  */
-#line 1331 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1351 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5178,9 +5298,9 @@ yyreduce:
     }
     break;
 
-  case 179:
+  case 183:
 /* Line 1792 of yacc.c  */
-#line 1337 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1357 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5189,9 +5309,9 @@ yyreduce:
     }
     break;
 
-  case 180:
+  case 184:
 /* Line 1792 of yacc.c  */
-#line 1343 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1363 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5200,9 +5320,9 @@ yyreduce:
     }
     break;
 
-  case 181:
+  case 185:
 /* Line 1792 of yacc.c  */
-#line 1349 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1369 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
@@ -5210,9 +5330,9 @@ yyreduce:
     }
     break;
 
-  case 182:
+  case 186:
 /* Line 1792 of yacc.c  */
-#line 1354 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1374 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
@@ -5220,9 +5340,9 @@ yyreduce:
     }
     break;
 
-  case 183:
+  case 187:
 /* Line 1792 of yacc.c  */
-#line 1359 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1379 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtBool;
@@ -5230,9 +5350,9 @@ yyreduce:
     }
     break;
 
-  case 184:
+  case 188:
 /* Line 1792 of yacc.c  */
-#line 1364 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1384 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
@@ -5240,9 +5360,9 @@ yyreduce:
     }
     break;
 
-  case 185:
+  case 189:
 /* Line 1792 of yacc.c  */
-#line 1369 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1389 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
@@ -5250,9 +5370,9 @@ yyreduce:
     }
     break;
 
-  case 186:
+  case 190:
 /* Line 1792 of yacc.c  */
-#line 1374 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1394 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtInt;
@@ -5260,9 +5380,42 @@ yyreduce:
     }
     break;
 
-  case 187:
+  case 191:
+/* Line 1792 of yacc.c  */
+#line 1399 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtInt64;
+        (yyval.interm.type).setVector(2);
+    }
+    break;
+
+  case 192:
+/* Line 1792 of yacc.c  */
+#line 1405 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtInt64;
+        (yyval.interm.type).setVector(3);
+    }
+    break;
+
+  case 193:
+/* Line 1792 of yacc.c  */
+#line 1411 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtInt64;
+        (yyval.interm.type).setVector(4);
+    }
+    break;
+
+  case 194:
 /* Line 1792 of yacc.c  */
-#line 1379 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1417 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5271,9 +5424,9 @@ yyreduce:
     }
     break;
 
-  case 188:
+  case 195:
 /* Line 1792 of yacc.c  */
-#line 1385 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1423 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5282,9 +5435,9 @@ yyreduce:
     }
     break;
 
-  case 189:
+  case 196:
 /* Line 1792 of yacc.c  */
-#line 1391 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1429 "glslang.y"
     {
         parseContext.fullIntegerCheck((yyvsp[(1) - (1)].lex).loc, "unsigned integer vector");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5293,9 +5446,42 @@ yyreduce:
     }
     break;
 
-  case 190:
+  case 197:
+/* Line 1792 of yacc.c  */
+#line 1435 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtUint64;
+        (yyval.interm.type).setVector(2);
+    }
+    break;
+
+  case 198:
 /* Line 1792 of yacc.c  */
-#line 1397 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1441 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtUint64;
+        (yyval.interm.type).setVector(3);
+    }
+    break;
+
+  case 199:
+/* Line 1792 of yacc.c  */
+#line 1447 "glslang.y"
+    {
+        parseContext.int64Check((yyvsp[(1) - (1)].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
+        (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
+        (yyval.interm.type).basicType = EbtUint64;
+        (yyval.interm.type).setVector(4);
+    }
+    break;
+
+  case 200:
+/* Line 1792 of yacc.c  */
+#line 1453 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5303,9 +5489,9 @@ yyreduce:
     }
     break;
 
-  case 191:
+  case 201:
 /* Line 1792 of yacc.c  */
-#line 1402 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1458 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5313,9 +5499,9 @@ yyreduce:
     }
     break;
 
-  case 192:
+  case 202:
 /* Line 1792 of yacc.c  */
-#line 1407 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1463 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5323,9 +5509,9 @@ yyreduce:
     }
     break;
 
-  case 193:
+  case 203:
 /* Line 1792 of yacc.c  */
-#line 1412 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1468 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5333,9 +5519,9 @@ yyreduce:
     }
     break;
 
-  case 194:
+  case 204:
 /* Line 1792 of yacc.c  */
-#line 1417 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1473 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5343,9 +5529,9 @@ yyreduce:
     }
     break;
 
-  case 195:
+  case 205:
 /* Line 1792 of yacc.c  */
-#line 1422 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1478 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5353,9 +5539,9 @@ yyreduce:
     }
     break;
 
-  case 196:
+  case 206:
 /* Line 1792 of yacc.c  */
-#line 1427 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1483 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5363,9 +5549,9 @@ yyreduce:
     }
     break;
 
-  case 197:
+  case 207:
 /* Line 1792 of yacc.c  */
-#line 1432 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1488 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5373,9 +5559,9 @@ yyreduce:
     }
     break;
 
-  case 198:
+  case 208:
 /* Line 1792 of yacc.c  */
-#line 1437 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1493 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5383,9 +5569,9 @@ yyreduce:
     }
     break;
 
-  case 199:
+  case 209:
 /* Line 1792 of yacc.c  */
-#line 1442 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1498 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5393,9 +5579,9 @@ yyreduce:
     }
     break;
 
-  case 200:
+  case 210:
 /* Line 1792 of yacc.c  */
-#line 1447 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1503 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5403,9 +5589,9 @@ yyreduce:
     }
     break;
 
-  case 201:
+  case 211:
 /* Line 1792 of yacc.c  */
-#line 1452 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1508 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtFloat;
@@ -5413,9 +5599,9 @@ yyreduce:
     }
     break;
 
-  case 202:
+  case 212:
 /* Line 1792 of yacc.c  */
-#line 1457 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1513 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5424,9 +5610,9 @@ yyreduce:
     }
     break;
 
-  case 203:
+  case 213:
 /* Line 1792 of yacc.c  */
-#line 1463 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1519 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5435,9 +5621,9 @@ yyreduce:
     }
     break;
 
-  case 204:
+  case 214:
 /* Line 1792 of yacc.c  */
-#line 1469 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1525 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5446,9 +5632,9 @@ yyreduce:
     }
     break;
 
-  case 205:
+  case 215:
 /* Line 1792 of yacc.c  */
-#line 1475 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1531 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5457,9 +5643,9 @@ yyreduce:
     }
     break;
 
-  case 206:
+  case 216:
 /* Line 1792 of yacc.c  */
-#line 1481 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1537 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5468,9 +5654,9 @@ yyreduce:
     }
     break;
 
-  case 207:
+  case 217:
 /* Line 1792 of yacc.c  */
-#line 1487 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1543 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5479,9 +5665,9 @@ yyreduce:
     }
     break;
 
-  case 208:
+  case 218:
 /* Line 1792 of yacc.c  */
-#line 1493 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1549 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5490,9 +5676,9 @@ yyreduce:
     }
     break;
 
-  case 209:
+  case 219:
 /* Line 1792 of yacc.c  */
-#line 1499 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1555 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5501,9 +5687,9 @@ yyreduce:
     }
     break;
 
-  case 210:
+  case 220:
 /* Line 1792 of yacc.c  */
-#line 1505 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1561 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5512,9 +5698,9 @@ yyreduce:
     }
     break;
 
-  case 211:
+  case 221:
 /* Line 1792 of yacc.c  */
-#line 1511 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1567 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5523,9 +5709,9 @@ yyreduce:
     }
     break;
 
-  case 212:
+  case 222:
 /* Line 1792 of yacc.c  */
-#line 1517 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1573 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5534,9 +5720,9 @@ yyreduce:
     }
     break;
 
-  case 213:
+  case 223:
 /* Line 1792 of yacc.c  */
-#line 1523 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1579 "glslang.y"
     {
         parseContext.doubleCheck((yyvsp[(1) - (1)].lex).loc, "double matrix");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5545,9 +5731,9 @@ yyreduce:
     }
     break;
 
-  case 214:
+  case 224:
 /* Line 1792 of yacc.c  */
-#line 1529 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1585 "glslang.y"
     {
         parseContext.vulkanRemoved((yyvsp[(1) - (1)].lex).loc, "atomic counter types");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -5555,9 +5741,9 @@ yyreduce:
     }
     break;
 
-  case 215:
+  case 225:
 /* Line 1792 of yacc.c  */
-#line 1534 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1590 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5565,9 +5751,9 @@ yyreduce:
     }
     break;
 
-  case 216:
+  case 226:
 /* Line 1792 of yacc.c  */
-#line 1539 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1595 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5575,9 +5761,9 @@ yyreduce:
     }
     break;
 
-  case 217:
+  case 227:
 /* Line 1792 of yacc.c  */
-#line 1544 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1600 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5585,9 +5771,9 @@ yyreduce:
     }
     break;
 
-  case 218:
+  case 228:
 /* Line 1792 of yacc.c  */
-#line 1549 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1605 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5595,9 +5781,9 @@ yyreduce:
     }
     break;
 
-  case 219:
+  case 229:
 /* Line 1792 of yacc.c  */
-#line 1554 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1610 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5605,9 +5791,9 @@ yyreduce:
     }
     break;
 
-  case 220:
+  case 230:
 /* Line 1792 of yacc.c  */
-#line 1559 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1615 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5615,9 +5801,9 @@ yyreduce:
     }
     break;
 
-  case 221:
+  case 231:
 /* Line 1792 of yacc.c  */
-#line 1564 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1620 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5625,9 +5811,9 @@ yyreduce:
     }
     break;
 
-  case 222:
+  case 232:
 /* Line 1792 of yacc.c  */
-#line 1569 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1625 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5635,9 +5821,9 @@ yyreduce:
     }
     break;
 
-  case 223:
+  case 233:
 /* Line 1792 of yacc.c  */
-#line 1574 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1630 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5645,9 +5831,9 @@ yyreduce:
     }
     break;
 
-  case 224:
+  case 234:
 /* Line 1792 of yacc.c  */
-#line 1579 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1635 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5655,9 +5841,9 @@ yyreduce:
     }
     break;
 
-  case 225:
+  case 235:
 /* Line 1792 of yacc.c  */
-#line 1584 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1640 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5665,9 +5851,9 @@ yyreduce:
     }
     break;
 
-  case 226:
+  case 236:
 /* Line 1792 of yacc.c  */
-#line 1589 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1645 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5675,9 +5861,9 @@ yyreduce:
     }
     break;
 
-  case 227:
+  case 237:
 /* Line 1792 of yacc.c  */
-#line 1594 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1650 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5685,9 +5871,9 @@ yyreduce:
     }
     break;
 
-  case 228:
+  case 238:
 /* Line 1792 of yacc.c  */
-#line 1599 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1655 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5695,9 +5881,9 @@ yyreduce:
     }
     break;
 
-  case 229:
+  case 239:
 /* Line 1792 of yacc.c  */
-#line 1604 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1660 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5705,9 +5891,9 @@ yyreduce:
     }
     break;
 
-  case 230:
+  case 240:
 /* Line 1792 of yacc.c  */
-#line 1609 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1665 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5715,9 +5901,9 @@ yyreduce:
     }
     break;
 
-  case 231:
+  case 241:
 /* Line 1792 of yacc.c  */
-#line 1614 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1670 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5725,9 +5911,9 @@ yyreduce:
     }
     break;
 
-  case 232:
+  case 242:
 /* Line 1792 of yacc.c  */
-#line 1619 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1675 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5735,9 +5921,9 @@ yyreduce:
     }
     break;
 
-  case 233:
+  case 243:
 /* Line 1792 of yacc.c  */
-#line 1624 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1680 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5745,9 +5931,9 @@ yyreduce:
     }
     break;
 
-  case 234:
+  case 244:
 /* Line 1792 of yacc.c  */
-#line 1629 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1685 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5755,9 +5941,9 @@ yyreduce:
     }
     break;
 
-  case 235:
+  case 245:
 /* Line 1792 of yacc.c  */
-#line 1634 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1690 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5765,9 +5951,9 @@ yyreduce:
     }
     break;
 
-  case 236:
+  case 246:
 /* Line 1792 of yacc.c  */
-#line 1639 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1695 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5775,9 +5961,9 @@ yyreduce:
     }
     break;
 
-  case 237:
+  case 247:
 /* Line 1792 of yacc.c  */
-#line 1644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1700 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5785,9 +5971,9 @@ yyreduce:
     }
     break;
 
-  case 238:
+  case 248:
 /* Line 1792 of yacc.c  */
-#line 1649 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1705 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5795,9 +5981,9 @@ yyreduce:
     }
     break;
 
-  case 239:
+  case 249:
 /* Line 1792 of yacc.c  */
-#line 1654 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1710 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5805,9 +5991,9 @@ yyreduce:
     }
     break;
 
-  case 240:
+  case 250:
 /* Line 1792 of yacc.c  */
-#line 1659 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1715 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5815,9 +6001,9 @@ yyreduce:
     }
     break;
 
-  case 241:
+  case 251:
 /* Line 1792 of yacc.c  */
-#line 1664 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1720 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5825,9 +6011,9 @@ yyreduce:
     }
     break;
 
-  case 242:
+  case 252:
 /* Line 1792 of yacc.c  */
-#line 1669 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1725 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5835,9 +6021,9 @@ yyreduce:
     }
     break;
 
-  case 243:
+  case 253:
 /* Line 1792 of yacc.c  */
-#line 1674 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1730 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5845,9 +6031,9 @@ yyreduce:
     }
     break;
 
-  case 244:
+  case 254:
 /* Line 1792 of yacc.c  */
-#line 1679 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1735 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5855,9 +6041,9 @@ yyreduce:
     }
     break;
 
-  case 245:
+  case 255:
 /* Line 1792 of yacc.c  */
-#line 1684 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1740 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5865,9 +6051,9 @@ yyreduce:
     }
     break;
 
-  case 246:
+  case 256:
 /* Line 1792 of yacc.c  */
-#line 1689 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1745 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5875,9 +6061,9 @@ yyreduce:
     }
     break;
 
-  case 247:
+  case 257:
 /* Line 1792 of yacc.c  */
-#line 1694 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1750 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5885,9 +6071,9 @@ yyreduce:
     }
     break;
 
-  case 248:
+  case 258:
 /* Line 1792 of yacc.c  */
-#line 1699 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1755 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5895,9 +6081,9 @@ yyreduce:
     }
     break;
 
-  case 249:
+  case 259:
 /* Line 1792 of yacc.c  */
-#line 1704 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1760 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5905,9 +6091,9 @@ yyreduce:
     }
     break;
 
-  case 250:
+  case 260:
 /* Line 1792 of yacc.c  */
-#line 1709 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1765 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5915,9 +6101,9 @@ yyreduce:
     }
     break;
 
-  case 251:
+  case 261:
 /* Line 1792 of yacc.c  */
-#line 1714 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1770 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5925,9 +6111,9 @@ yyreduce:
     }
     break;
 
-  case 252:
+  case 262:
 /* Line 1792 of yacc.c  */
-#line 1719 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1775 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5935,9 +6121,9 @@ yyreduce:
     }
     break;
 
-  case 253:
+  case 263:
 /* Line 1792 of yacc.c  */
-#line 1724 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1780 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5945,9 +6131,9 @@ yyreduce:
     }
     break;
 
-  case 254:
+  case 264:
 /* Line 1792 of yacc.c  */
-#line 1729 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1785 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5955,9 +6141,9 @@ yyreduce:
     }
     break;
 
-  case 255:
+  case 265:
 /* Line 1792 of yacc.c  */
-#line 1734 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1790 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5965,9 +6151,9 @@ yyreduce:
     }
     break;
 
-  case 256:
+  case 266:
 /* Line 1792 of yacc.c  */
-#line 1739 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1795 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5975,9 +6161,9 @@ yyreduce:
     }
     break;
 
-  case 257:
+  case 267:
 /* Line 1792 of yacc.c  */
-#line 1744 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1800 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5985,9 +6171,9 @@ yyreduce:
     }
     break;
 
-  case 258:
+  case 268:
 /* Line 1792 of yacc.c  */
-#line 1749 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1805 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -5995,9 +6181,9 @@ yyreduce:
     }
     break;
 
-  case 259:
+  case 269:
 /* Line 1792 of yacc.c  */
-#line 1754 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1810 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6005,9 +6191,9 @@ yyreduce:
     }
     break;
 
-  case 260:
+  case 270:
 /* Line 1792 of yacc.c  */
-#line 1759 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1815 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6015,9 +6201,9 @@ yyreduce:
     }
     break;
 
-  case 261:
+  case 271:
 /* Line 1792 of yacc.c  */
-#line 1764 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1820 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6025,9 +6211,9 @@ yyreduce:
     }
     break;
 
-  case 262:
+  case 272:
 /* Line 1792 of yacc.c  */
-#line 1769 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1825 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6035,9 +6221,9 @@ yyreduce:
     }
     break;
 
-  case 263:
+  case 273:
 /* Line 1792 of yacc.c  */
-#line 1774 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1830 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6045,9 +6231,9 @@ yyreduce:
     }
     break;
 
-  case 264:
+  case 274:
 /* Line 1792 of yacc.c  */
-#line 1779 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1835 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6055,9 +6241,9 @@ yyreduce:
     }
     break;
 
-  case 265:
+  case 275:
 /* Line 1792 of yacc.c  */
-#line 1784 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1840 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6065,9 +6251,9 @@ yyreduce:
     }
     break;
 
-  case 266:
+  case 276:
 /* Line 1792 of yacc.c  */
-#line 1789 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1845 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6075,9 +6261,9 @@ yyreduce:
     }
     break;
 
-  case 267:
+  case 277:
 /* Line 1792 of yacc.c  */
-#line 1794 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1850 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6085,9 +6271,9 @@ yyreduce:
     }
     break;
 
-  case 268:
+  case 278:
 /* Line 1792 of yacc.c  */
-#line 1799 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1855 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6095,9 +6281,9 @@ yyreduce:
     }
     break;
 
-  case 269:
+  case 279:
 /* Line 1792 of yacc.c  */
-#line 1804 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1860 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6105,9 +6291,9 @@ yyreduce:
     }
     break;
 
-  case 270:
+  case 280:
 /* Line 1792 of yacc.c  */
-#line 1809 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1865 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6115,9 +6301,9 @@ yyreduce:
     }
     break;
 
-  case 271:
+  case 281:
 /* Line 1792 of yacc.c  */
-#line 1814 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1870 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6125,9 +6311,9 @@ yyreduce:
     }
     break;
 
-  case 272:
+  case 282:
 /* Line 1792 of yacc.c  */
-#line 1819 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1875 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6135,9 +6321,9 @@ yyreduce:
     }
     break;
 
-  case 273:
+  case 283:
 /* Line 1792 of yacc.c  */
-#line 1824 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1880 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6145,9 +6331,9 @@ yyreduce:
     }
     break;
 
-  case 274:
+  case 284:
 /* Line 1792 of yacc.c  */
-#line 1829 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1885 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6155,9 +6341,9 @@ yyreduce:
     }
     break;
 
-  case 275:
+  case 285:
 /* Line 1792 of yacc.c  */
-#line 1834 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1890 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6165,9 +6351,9 @@ yyreduce:
     }
     break;
 
-  case 276:
+  case 286:
 /* Line 1792 of yacc.c  */
-#line 1839 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1895 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6175,9 +6361,9 @@ yyreduce:
     }
     break;
 
-  case 277:
+  case 287:
 /* Line 1792 of yacc.c  */
-#line 1844 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1900 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6185,9 +6371,9 @@ yyreduce:
     }
     break;
 
-  case 278:
+  case 288:
 /* Line 1792 of yacc.c  */
-#line 1849 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1905 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6195,9 +6381,9 @@ yyreduce:
     }
     break;
 
-  case 279:
+  case 289:
 /* Line 1792 of yacc.c  */
-#line 1854 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1910 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6205,9 +6391,9 @@ yyreduce:
     }
     break;
 
-  case 280:
+  case 290:
 /* Line 1792 of yacc.c  */
-#line 1859 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1915 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6215,9 +6401,9 @@ yyreduce:
     }
     break;
 
-  case 281:
+  case 291:
 /* Line 1792 of yacc.c  */
-#line 1864 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1920 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6225,9 +6411,9 @@ yyreduce:
     }
     break;
 
-  case 282:
+  case 292:
 /* Line 1792 of yacc.c  */
-#line 1869 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1925 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6235,9 +6421,9 @@ yyreduce:
     }
     break;
 
-  case 283:
+  case 293:
 /* Line 1792 of yacc.c  */
-#line 1874 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1930 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6245,9 +6431,9 @@ yyreduce:
     }
     break;
 
-  case 284:
+  case 294:
 /* Line 1792 of yacc.c  */
-#line 1879 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1935 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6255,9 +6441,9 @@ yyreduce:
     }
     break;
 
-  case 285:
+  case 295:
 /* Line 1792 of yacc.c  */
-#line 1884 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1940 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6265,9 +6451,9 @@ yyreduce:
     }
     break;
 
-  case 286:
+  case 296:
 /* Line 1792 of yacc.c  */
-#line 1889 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1945 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6275,9 +6461,9 @@ yyreduce:
     }
     break;
 
-  case 287:
+  case 297:
 /* Line 1792 of yacc.c  */
-#line 1894 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1950 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6285,9 +6471,9 @@ yyreduce:
     }
     break;
 
-  case 288:
+  case 298:
 /* Line 1792 of yacc.c  */
-#line 1899 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1955 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6295,9 +6481,9 @@ yyreduce:
     }
     break;
 
-  case 289:
+  case 299:
 /* Line 1792 of yacc.c  */
-#line 1904 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1960 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6305,9 +6491,9 @@ yyreduce:
     }
     break;
 
-  case 290:
+  case 300:
 /* Line 1792 of yacc.c  */
-#line 1909 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1965 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6315,9 +6501,9 @@ yyreduce:
     }
     break;
 
-  case 291:
+  case 301:
 /* Line 1792 of yacc.c  */
-#line 1914 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1970 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6325,9 +6511,9 @@ yyreduce:
     }
     break;
 
-  case 292:
+  case 302:
 /* Line 1792 of yacc.c  */
-#line 1919 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1975 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6335,9 +6521,9 @@ yyreduce:
     }
     break;
 
-  case 293:
+  case 303:
 /* Line 1792 of yacc.c  */
-#line 1924 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1980 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6345,9 +6531,9 @@ yyreduce:
     }
     break;
 
-  case 294:
+  case 304:
 /* Line 1792 of yacc.c  */
-#line 1929 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1985 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6355,9 +6541,9 @@ yyreduce:
     }
     break;
 
-  case 295:
+  case 305:
 /* Line 1792 of yacc.c  */
-#line 1934 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1990 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6365,9 +6551,9 @@ yyreduce:
     }
     break;
 
-  case 296:
+  case 306:
 /* Line 1792 of yacc.c  */
-#line 1939 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 1995 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6375,9 +6561,9 @@ yyreduce:
     }
     break;
 
-  case 297:
+  case 307:
 /* Line 1792 of yacc.c  */
-#line 1944 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2000 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6385,9 +6571,9 @@ yyreduce:
     }
     break;
 
-  case 298:
+  case 308:
 /* Line 1792 of yacc.c  */
-#line 1949 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2005 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6395,9 +6581,9 @@ yyreduce:
     }
     break;
 
-  case 299:
+  case 309:
 /* Line 1792 of yacc.c  */
-#line 1954 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2010 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6405,9 +6591,9 @@ yyreduce:
     }
     break;
 
-  case 300:
+  case 310:
 /* Line 1792 of yacc.c  */
-#line 1959 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2015 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6415,9 +6601,9 @@ yyreduce:
     }
     break;
 
-  case 301:
+  case 311:
 /* Line 1792 of yacc.c  */
-#line 1964 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2020 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6425,9 +6611,9 @@ yyreduce:
     }
     break;
 
-  case 302:
+  case 312:
 /* Line 1792 of yacc.c  */
-#line 1969 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2025 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6435,9 +6621,9 @@ yyreduce:
     }
     break;
 
-  case 303:
+  case 313:
 /* Line 1792 of yacc.c  */
-#line 1974 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2030 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6445,9 +6631,9 @@ yyreduce:
     }
     break;
 
-  case 304:
+  case 314:
 /* Line 1792 of yacc.c  */
-#line 1979 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2035 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6455,9 +6641,9 @@ yyreduce:
     }
     break;
 
-  case 305:
+  case 315:
 /* Line 1792 of yacc.c  */
-#line 1984 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2040 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6465,9 +6651,9 @@ yyreduce:
     }
     break;
 
-  case 306:
+  case 316:
 /* Line 1792 of yacc.c  */
-#line 1989 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2045 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6475,9 +6661,9 @@ yyreduce:
     }
     break;
 
-  case 307:
+  case 317:
 /* Line 1792 of yacc.c  */
-#line 1994 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2050 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6485,9 +6671,9 @@ yyreduce:
     }
     break;
 
-  case 308:
+  case 318:
 /* Line 1792 of yacc.c  */
-#line 1999 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2055 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6495,9 +6681,9 @@ yyreduce:
     }
     break;
 
-  case 309:
+  case 319:
 /* Line 1792 of yacc.c  */
-#line 2004 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2060 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6505,9 +6691,9 @@ yyreduce:
     }
     break;
 
-  case 310:
+  case 320:
 /* Line 1792 of yacc.c  */
-#line 2009 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2065 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6515,9 +6701,9 @@ yyreduce:
     }
     break;
 
-  case 311:
+  case 321:
 /* Line 1792 of yacc.c  */
-#line 2014 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2070 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6525,9 +6711,9 @@ yyreduce:
     }
     break;
 
-  case 312:
+  case 322:
 /* Line 1792 of yacc.c  */
-#line 2019 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2075 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6535,9 +6721,9 @@ yyreduce:
     }
     break;
 
-  case 313:
+  case 323:
 /* Line 1792 of yacc.c  */
-#line 2024 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2080 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6545,9 +6731,9 @@ yyreduce:
     }
     break;
 
-  case 314:
+  case 324:
 /* Line 1792 of yacc.c  */
-#line 2029 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2085 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6555,9 +6741,9 @@ yyreduce:
     }
     break;
 
-  case 315:
+  case 325:
 /* Line 1792 of yacc.c  */
-#line 2034 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2090 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6565,9 +6751,9 @@ yyreduce:
     }
     break;
 
-  case 316:
+  case 326:
 /* Line 1792 of yacc.c  */
-#line 2039 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2095 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6575,9 +6761,9 @@ yyreduce:
     }
     break;
 
-  case 317:
+  case 327:
 /* Line 1792 of yacc.c  */
-#line 2044 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2100 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6585,9 +6771,9 @@ yyreduce:
     }
     break;
 
-  case 318:
+  case 328:
 /* Line 1792 of yacc.c  */
-#line 2049 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2105 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6595,9 +6781,9 @@ yyreduce:
     }
     break;
 
-  case 319:
+  case 329:
 /* Line 1792 of yacc.c  */
-#line 2054 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2110 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6605,9 +6791,9 @@ yyreduce:
     }
     break;
 
-  case 320:
+  case 330:
 /* Line 1792 of yacc.c  */
-#line 2059 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2115 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6615,9 +6801,9 @@ yyreduce:
     }
     break;
 
-  case 321:
+  case 331:
 /* Line 1792 of yacc.c  */
-#line 2064 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2120 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6625,9 +6811,9 @@ yyreduce:
     }
     break;
 
-  case 322:
+  case 332:
 /* Line 1792 of yacc.c  */
-#line 2069 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2125 "glslang.y"
     {
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6635,9 +6821,9 @@ yyreduce:
     }
     break;
 
-  case 323:
+  case 333:
 /* Line 1792 of yacc.c  */
-#line 2074 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2130 "glslang.y"
     {  // GL_OES_EGL_image_external
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtSampler;
@@ -6646,9 +6832,9 @@ yyreduce:
     }
     break;
 
-  case 324:
+  case 334:
 /* Line 1792 of yacc.c  */
-#line 2080 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2136 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6657,9 +6843,9 @@ yyreduce:
     }
     break;
 
-  case 325:
+  case 335:
 /* Line 1792 of yacc.c  */
-#line 2086 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2142 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6668,9 +6854,9 @@ yyreduce:
     }
     break;
 
-  case 326:
+  case 336:
 /* Line 1792 of yacc.c  */
-#line 2092 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2148 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6679,9 +6865,9 @@ yyreduce:
     }
     break;
 
-  case 327:
+  case 337:
 /* Line 1792 of yacc.c  */
-#line 2098 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2154 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6690,9 +6876,9 @@ yyreduce:
     }
     break;
 
-  case 328:
+  case 338:
 /* Line 1792 of yacc.c  */
-#line 2104 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2160 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6701,9 +6887,9 @@ yyreduce:
     }
     break;
 
-  case 329:
+  case 339:
 /* Line 1792 of yacc.c  */
-#line 2110 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2166 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (1)].lex).loc, EShLangFragment, "subpass input");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6712,9 +6898,9 @@ yyreduce:
     }
     break;
 
-  case 330:
+  case 340:
 /* Line 1792 of yacc.c  */
-#line 2116 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2172 "glslang.y"
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
         (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
@@ -6722,9 +6908,9 @@ yyreduce:
     }
     break;
 
-  case 331:
+  case 341:
 /* Line 1792 of yacc.c  */
-#line 2121 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2177 "glslang.y"
     {
         //
         // This is for user defined type names.  The lexical phase looked up the
@@ -6740,9 +6926,9 @@ yyreduce:
     }
     break;
 
-  case 332:
+  case 342:
 /* Line 1792 of yacc.c  */
-#line 2137 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2193 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6751,9 +6937,9 @@ yyreduce:
     }
     break;
 
-  case 333:
+  case 343:
 /* Line 1792 of yacc.c  */
-#line 2143 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2199 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6762,9 +6948,9 @@ yyreduce:
     }
     break;
 
-  case 334:
+  case 344:
 /* Line 1792 of yacc.c  */
-#line 2149 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2205 "glslang.y"
     {
         parseContext.profileRequires((yyvsp[(1) - (1)].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
         (yyval.interm.type).init((yyvsp[(1) - (1)].lex).loc, parseContext.symbolTable.atGlobalLevel());
@@ -6773,15 +6959,15 @@ yyreduce:
     }
     break;
 
-  case 335:
+  case 345:
 /* Line 1792 of yacc.c  */
-#line 2158 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2214 "glslang.y"
     { parseContext.nestedStructCheck((yyvsp[(1) - (3)].lex).loc); }
     break;
 
-  case 336:
+  case 346:
 /* Line 1792 of yacc.c  */
-#line 2158 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2214 "glslang.y"
     {
         TType* structure = new TType((yyvsp[(5) - (6)].interm.typeList), *(yyvsp[(2) - (6)].lex).string);
         parseContext.structArrayCheck((yyvsp[(2) - (6)].lex).loc, *structure);
@@ -6795,15 +6981,15 @@ yyreduce:
     }
     break;
 
-  case 337:
+  case 347:
 /* Line 1792 of yacc.c  */
-#line 2169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2225 "glslang.y"
     { parseContext.nestedStructCheck((yyvsp[(1) - (2)].lex).loc); }
     break;
 
-  case 338:
+  case 348:
 /* Line 1792 of yacc.c  */
-#line 2169 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2225 "glslang.y"
     {
         TType* structure = new TType((yyvsp[(4) - (5)].interm.typeList), TString(""));
         (yyval.interm.type).init((yyvsp[(1) - (5)].lex).loc);
@@ -6813,17 +6999,17 @@ yyreduce:
     }
     break;
 
-  case 339:
+  case 349:
 /* Line 1792 of yacc.c  */
-#line 2179 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2235 "glslang.y"
     {
         (yyval.interm.typeList) = (yyvsp[(1) - (1)].interm.typeList);
     }
     break;
 
-  case 340:
+  case 350:
 /* Line 1792 of yacc.c  */
-#line 2182 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2238 "glslang.y"
     {
         (yyval.interm.typeList) = (yyvsp[(1) - (2)].interm.typeList);
         for (unsigned int i = 0; i < (yyvsp[(2) - (2)].interm.typeList)->size(); ++i) {
@@ -6836,9 +7022,9 @@ yyreduce:
     }
     break;
 
-  case 341:
+  case 351:
 /* Line 1792 of yacc.c  */
-#line 2195 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2251 "glslang.y"
     {
         if ((yyvsp[(1) - (3)].interm.type).arraySizes) {
             parseContext.profileRequires((yyvsp[(1) - (3)].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
@@ -6859,9 +7045,9 @@ yyreduce:
     }
     break;
 
-  case 342:
+  case 352:
 /* Line 1792 of yacc.c  */
-#line 2213 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2269 "glslang.y"
     {
         parseContext.globalQualifierFixCheck((yyvsp[(1) - (4)].interm.type).loc, (yyvsp[(1) - (4)].interm.type).qualifier);
         if ((yyvsp[(2) - (4)].interm.type).arraySizes) {
@@ -6885,26 +7071,26 @@ yyreduce:
     }
     break;
 
-  case 343:
+  case 353:
 /* Line 1792 of yacc.c  */
-#line 2237 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2293 "glslang.y"
     {
         (yyval.interm.typeList) = new TTypeList;
         (yyval.interm.typeList)->push_back((yyvsp[(1) - (1)].interm.typeLine));
     }
     break;
 
-  case 344:
+  case 354:
 /* Line 1792 of yacc.c  */
-#line 2241 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2297 "glslang.y"
     {
         (yyval.interm.typeList)->push_back((yyvsp[(3) - (3)].interm.typeLine));
     }
     break;
 
-  case 345:
+  case 355:
 /* Line 1792 of yacc.c  */
-#line 2247 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2303 "glslang.y"
     {
         (yyval.interm.typeLine).type = new TType(EbtVoid);
         (yyval.interm.typeLine).loc = (yyvsp[(1) - (1)].lex).loc;
@@ -6912,9 +7098,9 @@ yyreduce:
     }
     break;
 
-  case 346:
+  case 356:
 /* Line 1792 of yacc.c  */
-#line 2252 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2308 "glslang.y"
     {
         parseContext.arrayDimCheck((yyvsp[(1) - (2)].lex).loc, (yyvsp[(2) - (2)].interm).arraySizes, 0);
 
@@ -6925,17 +7111,17 @@ yyreduce:
     }
     break;
 
-  case 347:
+  case 357:
 /* Line 1792 of yacc.c  */
-#line 2263 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2319 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 348:
+  case 358:
 /* Line 1792 of yacc.c  */
-#line 2266 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2322 "glslang.y"
     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[(1) - (3)].lex).loc, ~EEsProfile, initFeature);
@@ -6944,9 +7130,9 @@ yyreduce:
     }
     break;
 
-  case 349:
+  case 359:
 /* Line 1792 of yacc.c  */
-#line 2272 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2328 "glslang.y"
     {
         const char* initFeature = "{ } style initializers";
         parseContext.requireProfile((yyvsp[(1) - (4)].lex).loc, ~EEsProfile, initFeature);
@@ -6955,109 +7141,109 @@ yyreduce:
     }
     break;
 
-  case 350:
+  case 360:
 /* Line 1792 of yacc.c  */
-#line 2281 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2337 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[(1) - (1)].interm.intermTypedNode), (yyvsp[(1) - (1)].interm.intermTypedNode)->getLoc());
     }
     break;
 
-  case 351:
+  case 361:
 /* Line 1792 of yacc.c  */
-#line 2284 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2340 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[(1) - (3)].interm.intermTypedNode), (yyvsp[(3) - (3)].interm.intermTypedNode));
     }
     break;
 
-  case 352:
+  case 362:
 /* Line 1792 of yacc.c  */
-#line 2290 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2346 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 353:
+  case 363:
 /* Line 1792 of yacc.c  */
-#line 2294 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2350 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 354:
+  case 364:
 /* Line 1792 of yacc.c  */
-#line 2295 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2351 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 355:
+  case 365:
 /* Line 1792 of yacc.c  */
-#line 2301 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2357 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 356:
+  case 366:
 /* Line 1792 of yacc.c  */
-#line 2302 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2358 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 357:
+  case 367:
 /* Line 1792 of yacc.c  */
-#line 2303 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2359 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 358:
+  case 368:
 /* Line 1792 of yacc.c  */
-#line 2304 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2360 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 359:
+  case 369:
 /* Line 1792 of yacc.c  */
-#line 2305 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2361 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 360:
+  case 370:
 /* Line 1792 of yacc.c  */
-#line 2306 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2362 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 361:
+  case 371:
 /* Line 1792 of yacc.c  */
-#line 2307 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2363 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 362:
+  case 372:
 /* Line 1792 of yacc.c  */
-#line 2311 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2367 "glslang.y"
     { (yyval.interm.intermNode) = 0; }
     break;
 
-  case 363:
+  case 373:
 /* Line 1792 of yacc.c  */
-#line 2312 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2368 "glslang.y"
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
     }
     break;
 
-  case 364:
+  case 374:
 /* Line 1792 of yacc.c  */
-#line 2316 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2372 "glslang.y"
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
     }
     break;
 
-  case 365:
+  case 375:
 /* Line 1792 of yacc.c  */
-#line 2320 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2376 "glslang.y"
     {
         if ((yyvsp[(3) - (5)].interm.intermNode) && (yyvsp[(3) - (5)].interm.intermNode)->getAsAggregate())
             (yyvsp[(3) - (5)].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
@@ -7065,38 +7251,38 @@ yyreduce:
     }
     break;
 
-  case 366:
+  case 376:
 /* Line 1792 of yacc.c  */
-#line 2328 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2384 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 367:
+  case 377:
 /* Line 1792 of yacc.c  */
-#line 2329 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2385 "glslang.y"
     { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
-  case 368:
+  case 378:
 /* Line 1792 of yacc.c  */
-#line 2333 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2389 "glslang.y"
     {
         ++parseContext.controlFlowNestingLevel;
     }
     break;
 
-  case 369:
+  case 379:
 /* Line 1792 of yacc.c  */
-#line 2336 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2392 "glslang.y"
     {
         --parseContext.controlFlowNestingLevel;
         (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode);
     }
     break;
 
-  case 370:
+  case 380:
 /* Line 1792 of yacc.c  */
-#line 2340 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2396 "glslang.y"
     {
         parseContext.symbolTable.push();
         ++parseContext.statementNestingLevel;
@@ -7104,9 +7290,9 @@ yyreduce:
     }
     break;
 
-  case 371:
+  case 381:
 /* Line 1792 of yacc.c  */
-#line 2345 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2401 "glslang.y"
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         --parseContext.statementNestingLevel;
@@ -7115,17 +7301,17 @@ yyreduce:
     }
     break;
 
-  case 372:
+  case 382:
 /* Line 1792 of yacc.c  */
-#line 2354 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2410 "glslang.y"
     {
         (yyval.interm.intermNode) = 0;
     }
     break;
 
-  case 373:
+  case 383:
 /* Line 1792 of yacc.c  */
-#line 2357 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2413 "glslang.y"
     {
         if ((yyvsp[(2) - (3)].interm.intermNode) && (yyvsp[(2) - (3)].interm.intermNode)->getAsAggregate())
             (yyvsp[(2) - (3)].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
@@ -7133,9 +7319,9 @@ yyreduce:
     }
     break;
 
-  case 374:
+  case 384:
 /* Line 1792 of yacc.c  */
-#line 2365 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2421 "glslang.y"
     {
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode));
         if ((yyvsp[(1) - (1)].interm.intermNode) && (yyvsp[(1) - (1)].interm.intermNode)->getAsBranchNode() && ((yyvsp[(1) - (1)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
@@ -7146,9 +7332,9 @@ yyreduce:
     }
     break;
 
-  case 375:
+  case 385:
 /* Line 1792 of yacc.c  */
-#line 2373 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2429 "glslang.y"
     {
         if ((yyvsp[(2) - (2)].interm.intermNode) && (yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode() && ((yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                             (yyvsp[(2) - (2)].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
@@ -7159,57 +7345,57 @@ yyreduce:
     }
     break;
 
-  case 376:
+  case 386:
 /* Line 1792 of yacc.c  */
-#line 2384 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2440 "glslang.y"
     { (yyval.interm.intermNode) = 0; }
     break;
 
-  case 377:
+  case 387:
 /* Line 1792 of yacc.c  */
-#line 2385 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2441 "glslang.y"
     { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[(1) - (2)].interm.intermTypedNode)); }
     break;
 
-  case 378:
+  case 388:
 /* Line 1792 of yacc.c  */
-#line 2389 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2445 "glslang.y"
     {
         parseContext.boolCheck((yyvsp[(1) - (5)].lex).loc, (yyvsp[(3) - (5)].interm.intermTypedNode));
         (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).loc);
     }
     break;
 
-  case 379:
+  case 389:
 /* Line 1792 of yacc.c  */
-#line 2396 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2452 "glslang.y"
     {
         (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode);
         (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode);
     }
     break;
 
-  case 380:
+  case 390:
 /* Line 1792 of yacc.c  */
-#line 2400 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2456 "glslang.y"
     {
         (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode);
         (yyval.interm.nodePair).node2 = 0;
     }
     break;
 
-  case 381:
+  case 391:
 /* Line 1792 of yacc.c  */
-#line 2408 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2464 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
         parseContext.boolCheck((yyvsp[(1) - (1)].interm.intermTypedNode)->getLoc(), (yyvsp[(1) - (1)].interm.intermTypedNode));
     }
     break;
 
-  case 382:
+  case 392:
 /* Line 1792 of yacc.c  */
-#line 2412 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2468 "glslang.y"
     {
         parseContext.boolCheck((yyvsp[(2) - (4)].lex).loc, (yyvsp[(1) - (4)].interm.type));
 
@@ -7222,9 +7408,9 @@ yyreduce:
     }
     break;
 
-  case 383:
+  case 393:
 /* Line 1792 of yacc.c  */
-#line 2425 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2481 "glslang.y"
     {
         // start new switch sequence on the switch stack
         ++parseContext.controlFlowNestingLevel;
@@ -7235,9 +7421,9 @@ yyreduce:
     }
     break;
 
-  case 384:
+  case 394:
 /* Line 1792 of yacc.c  */
-#line 2433 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2489 "glslang.y"
     {
         (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[(1) - (8)].lex).loc, (yyvsp[(3) - (8)].interm.intermTypedNode), (yyvsp[(7) - (8)].interm.intermNode) ? (yyvsp[(7) - (8)].interm.intermNode)->getAsAggregate() : 0);
         delete parseContext.switchSequenceStack.back();
@@ -7249,25 +7435,25 @@ yyreduce:
     }
     break;
 
-  case 385:
+  case 395:
 /* Line 1792 of yacc.c  */
-#line 2445 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2501 "glslang.y"
     {
         (yyval.interm.intermNode) = 0;
     }
     break;
 
-  case 386:
+  case 396:
 /* Line 1792 of yacc.c  */
-#line 2448 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2504 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
     }
     break;
 
-  case 387:
+  case 397:
 /* Line 1792 of yacc.c  */
-#line 2454 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2510 "glslang.y"
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -7282,9 +7468,9 @@ yyreduce:
     }
     break;
 
-  case 388:
+  case 398:
 /* Line 1792 of yacc.c  */
-#line 2466 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2522 "glslang.y"
     {
         (yyval.interm.intermNode) = 0;
         if (parseContext.switchLevel.size() == 0)
@@ -7296,9 +7482,9 @@ yyreduce:
     }
     break;
 
-  case 389:
+  case 399:
 /* Line 1792 of yacc.c  */
-#line 2478 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2534 "glslang.y"
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[(1) - (2)].lex).loc, "while loops not available", "limitation", "");
@@ -7309,9 +7495,9 @@ yyreduce:
     }
     break;
 
-  case 390:
+  case 400:
 /* Line 1792 of yacc.c  */
-#line 2486 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2542 "glslang.y"
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[(6) - (6)].interm.intermNode), (yyvsp[(4) - (6)].interm.intermTypedNode), 0, true, (yyvsp[(1) - (6)].lex).loc);
@@ -7321,9 +7507,9 @@ yyreduce:
     }
     break;
 
-  case 391:
+  case 401:
 /* Line 1792 of yacc.c  */
-#line 2493 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2549 "glslang.y"
     {
         ++parseContext.loopNestingLevel;
         ++parseContext.statementNestingLevel;
@@ -7331,9 +7517,9 @@ yyreduce:
     }
     break;
 
-  case 392:
+  case 402:
 /* Line 1792 of yacc.c  */
-#line 2498 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2554 "glslang.y"
     {
         if (! parseContext.limits.whileLoops)
             parseContext.error((yyvsp[(1) - (8)].lex).loc, "do-while loops not available", "limitation", "");
@@ -7347,9 +7533,9 @@ yyreduce:
     }
     break;
 
-  case 393:
+  case 403:
 /* Line 1792 of yacc.c  */
-#line 2509 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2565 "glslang.y"
     {
         parseContext.symbolTable.push();
         ++parseContext.loopNestingLevel;
@@ -7358,9 +7544,9 @@ yyreduce:
     }
     break;
 
-  case 394:
+  case 404:
 /* Line 1792 of yacc.c  */
-#line 2515 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2571 "glslang.y"
     {
         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[(4) - (7)].interm.intermNode), (yyvsp[(2) - (7)].lex).loc);
@@ -7375,59 +7561,59 @@ yyreduce:
     }
     break;
 
-  case 395:
+  case 405:
 /* Line 1792 of yacc.c  */
-#line 2530 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2586 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
     }
     break;
 
-  case 396:
+  case 406:
 /* Line 1792 of yacc.c  */
-#line 2533 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2589 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
     }
     break;
 
-  case 397:
+  case 407:
 /* Line 1792 of yacc.c  */
-#line 2539 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2595 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
     }
     break;
 
-  case 398:
+  case 408:
 /* Line 1792 of yacc.c  */
-#line 2542 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2598 "glslang.y"
     {
         (yyval.interm.intermTypedNode) = 0;
     }
     break;
 
-  case 399:
+  case 409:
 /* Line 1792 of yacc.c  */
-#line 2548 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2604 "glslang.y"
     {
         (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = 0;
     }
     break;
 
-  case 400:
+  case 410:
 /* Line 1792 of yacc.c  */
-#line 2552 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2608 "glslang.y"
     {
         (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode);
         (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode);
     }
     break;
 
-  case 401:
+  case 411:
 /* Line 1792 of yacc.c  */
-#line 2559 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2615 "glslang.y"
     {
         if (parseContext.loopNestingLevel <= 0)
             parseContext.error((yyvsp[(1) - (2)].lex).loc, "continue statement only allowed in loops", "", "");
@@ -7435,9 +7621,9 @@ yyreduce:
     }
     break;
 
-  case 402:
+  case 412:
 /* Line 1792 of yacc.c  */
-#line 2564 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2620 "glslang.y"
     {
         if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
             parseContext.error((yyvsp[(1) - (2)].lex).loc, "break statement only allowed in switch and loops", "", "");
@@ -7445,9 +7631,9 @@ yyreduce:
     }
     break;
 
-  case 403:
+  case 413:
 /* Line 1792 of yacc.c  */
-#line 2569 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2625 "glslang.y"
     {
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[(1) - (2)].lex).loc);
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
@@ -7457,9 +7643,9 @@ yyreduce:
     }
     break;
 
-  case 404:
+  case 414:
 /* Line 1792 of yacc.c  */
-#line 2576 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2632 "glslang.y"
     {
         parseContext.functionReturnsValue = true;
         if (parseContext.currentFunctionType->getBasicType() == EbtVoid) {
@@ -7480,61 +7666,61 @@ yyreduce:
     }
     break;
 
-  case 405:
+  case 415:
 /* Line 1792 of yacc.c  */
-#line 2594 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2650 "glslang.y"
     {
         parseContext.requireStage((yyvsp[(1) - (2)].lex).loc, EShLangFragment, "discard");
         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).loc);
     }
     break;
 
-  case 406:
+  case 416:
 /* Line 1792 of yacc.c  */
-#line 2603 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2659 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
     break;
 
-  case 407:
+  case 417:
 /* Line 1792 of yacc.c  */
-#line 2607 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2663 "glslang.y"
     {
         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode));
         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
     }
     break;
 
-  case 408:
+  case 418:
 /* Line 1792 of yacc.c  */
-#line 2614 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2670 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
     }
     break;
 
-  case 409:
+  case 419:
 /* Line 1792 of yacc.c  */
-#line 2617 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2673 "glslang.y"
     {
         (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
     }
     break;
 
-  case 410:
+  case 420:
 /* Line 1792 of yacc.c  */
-#line 2623 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2679 "glslang.y"
     {
         (yyvsp[(1) - (1)].interm).function = parseContext.handleFunctionDeclarator((yyvsp[(1) - (1)].interm).loc, *(yyvsp[(1) - (1)].interm).function, false /* not prototype */);
         (yyvsp[(1) - (1)].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[(1) - (1)].interm).loc, *(yyvsp[(1) - (1)].interm).function);
     }
     break;
 
-  case 411:
+  case 421:
 /* Line 1792 of yacc.c  */
-#line 2627 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2683 "glslang.y"
     {
         //   May be best done as post process phase on intermediate code
         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
@@ -7554,7 +7740,7 @@ yyreduce:
 
 
 /* Line 1792 of yacc.c  */
-#line 7558 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp"
+#line 7744 "glslang_tab.cpp"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -7786,5 +7972,5 @@ yyreturn:
 
 
 /* Line 2055 of yacc.c  */
-#line 2644 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 2700 "glslang.y"
 

diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
index 0c6ab3b..03f5706 100644 (file)
--- a/glslang/MachineIndependent/glslang_tab.cpp.h
+++ b/glslang/MachineIndependent/glslang_tab.cpp.h
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -54,255 +54,265 @@ extern int yydebug;
      DOUBLE = 263,
      INT = 264,
      UINT = 265,
-     BREAK = 266,
-     CONTINUE = 267,
-     DO = 268,
-     ELSE = 269,
-     FOR = 270,
-     IF = 271,
-     DISCARD = 272,
-     RETURN = 273,
-     SWITCH = 274,
-     CASE = 275,
-     DEFAULT = 276,
-     SUBROUTINE = 277,
-     BVEC2 = 278,
-     BVEC3 = 279,
-     BVEC4 = 280,
-     IVEC2 = 281,
-     IVEC3 = 282,
-     IVEC4 = 283,
-     UVEC2 = 284,
-     UVEC3 = 285,
-     UVEC4 = 286,
-     VEC2 = 287,
-     VEC3 = 288,
-     VEC4 = 289,
-     MAT2 = 290,
-     MAT3 = 291,
-     MAT4 = 292,
-     CENTROID = 293,
-     IN = 294,
-     OUT = 295,
-     INOUT = 296,
-     UNIFORM = 297,
-     PATCH = 298,
-     SAMPLE = 299,
-     BUFFER = 300,
-     SHARED = 301,
-     COHERENT = 302,
-     VOLATILE = 303,
-     RESTRICT = 304,
-     READONLY = 305,
-     WRITEONLY = 306,
-     DVEC2 = 307,
-     DVEC3 = 308,
-     DVEC4 = 309,
-     DMAT2 = 310,
-     DMAT3 = 311,
-     DMAT4 = 312,
-     NOPERSPECTIVE = 313,
-     FLAT = 314,
-     SMOOTH = 315,
-     LAYOUT = 316,
-     MAT2X2 = 317,
-     MAT2X3 = 318,
-     MAT2X4 = 319,
-     MAT3X2 = 320,
-     MAT3X3 = 321,
-     MAT3X4 = 322,
-     MAT4X2 = 323,
-     MAT4X3 = 324,
-     MAT4X4 = 325,
-     DMAT2X2 = 326,
-     DMAT2X3 = 327,
-     DMAT2X4 = 328,
-     DMAT3X2 = 329,
-     DMAT3X3 = 330,
-     DMAT3X4 = 331,
-     DMAT4X2 = 332,
-     DMAT4X3 = 333,
-     DMAT4X4 = 334,
-     ATOMIC_UINT = 335,
-     SAMPLER1D = 336,
-     SAMPLER2D = 337,
-     SAMPLER3D = 338,
-     SAMPLERCUBE = 339,
-     SAMPLER1DSHADOW = 340,
-     SAMPLER2DSHADOW = 341,
-     SAMPLERCUBESHADOW = 342,
-     SAMPLER1DARRAY = 343,
-     SAMPLER2DARRAY = 344,
-     SAMPLER1DARRAYSHADOW = 345,
-     SAMPLER2DARRAYSHADOW = 346,
-     ISAMPLER1D = 347,
-     ISAMPLER2D = 348,
-     ISAMPLER3D = 349,
-     ISAMPLERCUBE = 350,
-     ISAMPLER1DARRAY = 351,
-     ISAMPLER2DARRAY = 352,
-     USAMPLER1D = 353,
-     USAMPLER2D = 354,
-     USAMPLER3D = 355,
-     USAMPLERCUBE = 356,
-     USAMPLER1DARRAY = 357,
-     USAMPLER2DARRAY = 358,
-     SAMPLER2DRECT = 359,
-     SAMPLER2DRECTSHADOW = 360,
-     ISAMPLER2DRECT = 361,
-     USAMPLER2DRECT = 362,
-     SAMPLERBUFFER = 363,
-     ISAMPLERBUFFER = 364,
-     USAMPLERBUFFER = 365,
-     SAMPLERCUBEARRAY = 366,
-     SAMPLERCUBEARRAYSHADOW = 367,
-     ISAMPLERCUBEARRAY = 368,
-     USAMPLERCUBEARRAY = 369,
-     SAMPLER2DMS = 370,
-     ISAMPLER2DMS = 371,
-     USAMPLER2DMS = 372,
-     SAMPLER2DMSARRAY = 373,
-     ISAMPLER2DMSARRAY = 374,
-     USAMPLER2DMSARRAY = 375,
-     SAMPLEREXTERNALOES = 376,
-     SAMPLER = 377,
-     SAMPLERSHADOW = 378,
-     TEXTURE1D = 379,
-     TEXTURE2D = 380,
-     TEXTURE3D = 381,
-     TEXTURECUBE = 382,
-     TEXTURE1DARRAY = 383,
-     TEXTURE2DARRAY = 384,
-     ITEXTURE1D = 385,
-     ITEXTURE2D = 386,
-     ITEXTURE3D = 387,
-     ITEXTURECUBE = 388,
-     ITEXTURE1DARRAY = 389,
-     ITEXTURE2DARRAY = 390,
-     UTEXTURE1D = 391,
-     UTEXTURE2D = 392,
-     UTEXTURE3D = 393,
-     UTEXTURECUBE = 394,
-     UTEXTURE1DARRAY = 395,
-     UTEXTURE2DARRAY = 396,
-     TEXTURE2DRECT = 397,
-     ITEXTURE2DRECT = 398,
-     UTEXTURE2DRECT = 399,
-     TEXTUREBUFFER = 400,
-     ITEXTUREBUFFER = 401,
-     UTEXTUREBUFFER = 402,
-     TEXTURECUBEARRAY = 403,
-     ITEXTURECUBEARRAY = 404,
-     UTEXTURECUBEARRAY = 405,
-     TEXTURE2DMS = 406,
-     ITEXTURE2DMS = 407,
-     UTEXTURE2DMS = 408,
-     TEXTURE2DMSARRAY = 409,
-     ITEXTURE2DMSARRAY = 410,
-     UTEXTURE2DMSARRAY = 411,
-     SUBPASSINPUT = 412,
-     SUBPASSINPUTMS = 413,
-     ISUBPASSINPUT = 414,
-     ISUBPASSINPUTMS = 415,
-     USUBPASSINPUT = 416,
-     USUBPASSINPUTMS = 417,
-     IMAGE1D = 418,
-     IIMAGE1D = 419,
-     UIMAGE1D = 420,
-     IMAGE2D = 421,
-     IIMAGE2D = 422,
-     UIMAGE2D = 423,
-     IMAGE3D = 424,
-     IIMAGE3D = 425,
-     UIMAGE3D = 426,
-     IMAGE2DRECT = 427,
-     IIMAGE2DRECT = 428,
-     UIMAGE2DRECT = 429,
-     IMAGECUBE = 430,
-     IIMAGECUBE = 431,
-     UIMAGECUBE = 432,
-     IMAGEBUFFER = 433,
-     IIMAGEBUFFER = 434,
-     UIMAGEBUFFER = 435,
-     IMAGE1DARRAY = 436,
-     IIMAGE1DARRAY = 437,
-     UIMAGE1DARRAY = 438,
-     IMAGE2DARRAY = 439,
-     IIMAGE2DARRAY = 440,
-     UIMAGE2DARRAY = 441,
-     IMAGECUBEARRAY = 442,
-     IIMAGECUBEARRAY = 443,
-     UIMAGECUBEARRAY = 444,
-     IMAGE2DMS = 445,
-     IIMAGE2DMS = 446,
-     UIMAGE2DMS = 447,
-     IMAGE2DMSARRAY = 448,
-     IIMAGE2DMSARRAY = 449,
-     UIMAGE2DMSARRAY = 450,
-     STRUCT = 451,
-     VOID = 452,
-     WHILE = 453,
-     IDENTIFIER = 454,
-     TYPE_NAME = 455,
-     FLOATCONSTANT = 456,
-     DOUBLECONSTANT = 457,
-     INTCONSTANT = 458,
-     UINTCONSTANT = 459,
-     BOOLCONSTANT = 460,
-     LEFT_OP = 461,
-     RIGHT_OP = 462,
-     INC_OP = 463,
-     DEC_OP = 464,
-     LE_OP = 465,
-     GE_OP = 466,
-     EQ_OP = 467,
-     NE_OP = 468,
-     AND_OP = 469,
-     OR_OP = 470,
-     XOR_OP = 471,
-     MUL_ASSIGN = 472,
-     DIV_ASSIGN = 473,
-     ADD_ASSIGN = 474,
-     MOD_ASSIGN = 475,
-     LEFT_ASSIGN = 476,
-     RIGHT_ASSIGN = 477,
-     AND_ASSIGN = 478,
-     XOR_ASSIGN = 479,
-     OR_ASSIGN = 480,
-     SUB_ASSIGN = 481,
-     LEFT_PAREN = 482,
-     RIGHT_PAREN = 483,
-     LEFT_BRACKET = 484,
-     RIGHT_BRACKET = 485,
-     LEFT_BRACE = 486,
-     RIGHT_BRACE = 487,
-     DOT = 488,
-     COMMA = 489,
-     COLON = 490,
-     EQUAL = 491,
-     SEMICOLON = 492,
-     BANG = 493,
-     DASH = 494,
-     TILDE = 495,
-     PLUS = 496,
-     STAR = 497,
-     SLASH = 498,
-     PERCENT = 499,
-     LEFT_ANGLE = 500,
-     RIGHT_ANGLE = 501,
-     VERTICAL_BAR = 502,
-     CARET = 503,
-     AMPERSAND = 504,
-     QUESTION = 505,
-     INVARIANT = 506,
-     PRECISE = 507,
-     HIGH_PRECISION = 508,
-     MEDIUM_PRECISION = 509,
-     LOW_PRECISION = 510,
-     PRECISION = 511,
-     PACKED = 512,
-     RESOURCE = 513,
-     SUPERP = 514
+     INT64_T = 266,
+     UINT64_T = 267,
+     BREAK = 268,
+     CONTINUE = 269,
+     DO = 270,
+     ELSE = 271,
+     FOR = 272,
+     IF = 273,
+     DISCARD = 274,
+     RETURN = 275,
+     SWITCH = 276,
+     CASE = 277,
+     DEFAULT = 278,
+     SUBROUTINE = 279,
+     BVEC2 = 280,
+     BVEC3 = 281,
+     BVEC4 = 282,
+     IVEC2 = 283,
+     IVEC3 = 284,
+     IVEC4 = 285,
+     I64VEC2 = 286,
+     I64VEC3 = 287,
+     I64VEC4 = 288,
+     UVEC2 = 289,
+     UVEC3 = 290,
+     UVEC4 = 291,
+     U64VEC2 = 292,
+     U64VEC3 = 293,
+     U64VEC4 = 294,
+     VEC2 = 295,
+     VEC3 = 296,
+     VEC4 = 297,
+     MAT2 = 298,
+     MAT3 = 299,
+     MAT4 = 300,
+     CENTROID = 301,
+     IN = 302,
+     OUT = 303,
+     INOUT = 304,
+     UNIFORM = 305,
+     PATCH = 306,
+     SAMPLE = 307,
+     BUFFER = 308,
+     SHARED = 309,
+     COHERENT = 310,
+     VOLATILE = 311,
+     RESTRICT = 312,
+     READONLY = 313,
+     WRITEONLY = 314,
+     DVEC2 = 315,
+     DVEC3 = 316,
+     DVEC4 = 317,
+     DMAT2 = 318,
+     DMAT3 = 319,
+     DMAT4 = 320,
+     NOPERSPECTIVE = 321,
+     FLAT = 322,
+     SMOOTH = 323,
+     LAYOUT = 324,
+     MAT2X2 = 325,
+     MAT2X3 = 326,
+     MAT2X4 = 327,
+     MAT3X2 = 328,
+     MAT3X3 = 329,
+     MAT3X4 = 330,
+     MAT4X2 = 331,
+     MAT4X3 = 332,
+     MAT4X4 = 333,
+     DMAT2X2 = 334,
+     DMAT2X3 = 335,
+     DMAT2X4 = 336,
+     DMAT3X2 = 337,
+     DMAT3X3 = 338,
+     DMAT3X4 = 339,
+     DMAT4X2 = 340,
+     DMAT4X3 = 341,
+     DMAT4X4 = 342,
+     ATOMIC_UINT = 343,
+     SAMPLER1D = 344,
+     SAMPLER2D = 345,
+     SAMPLER3D = 346,
+     SAMPLERCUBE = 347,
+     SAMPLER1DSHADOW = 348,
+     SAMPLER2DSHADOW = 349,
+     SAMPLERCUBESHADOW = 350,
+     SAMPLER1DARRAY = 351,
+     SAMPLER2DARRAY = 352,
+     SAMPLER1DARRAYSHADOW = 353,
+     SAMPLER2DARRAYSHADOW = 354,
+     ISAMPLER1D = 355,
+     ISAMPLER2D = 356,
+     ISAMPLER3D = 357,
+     ISAMPLERCUBE = 358,
+     ISAMPLER1DARRAY = 359,
+     ISAMPLER2DARRAY = 360,
+     USAMPLER1D = 361,
+     USAMPLER2D = 362,
+     USAMPLER3D = 363,
+     USAMPLERCUBE = 364,
+     USAMPLER1DARRAY = 365,
+     USAMPLER2DARRAY = 366,
+     SAMPLER2DRECT = 367,
+     SAMPLER2DRECTSHADOW = 368,
+     ISAMPLER2DRECT = 369,
+     USAMPLER2DRECT = 370,
+     SAMPLERBUFFER = 371,
+     ISAMPLERBUFFER = 372,
+     USAMPLERBUFFER = 373,
+     SAMPLERCUBEARRAY = 374,
+     SAMPLERCUBEARRAYSHADOW = 375,
+     ISAMPLERCUBEARRAY = 376,
+     USAMPLERCUBEARRAY = 377,
+     SAMPLER2DMS = 378,
+     ISAMPLER2DMS = 379,
+     USAMPLER2DMS = 380,
+     SAMPLER2DMSARRAY = 381,
+     ISAMPLER2DMSARRAY = 382,
+     USAMPLER2DMSARRAY = 383,
+     SAMPLEREXTERNALOES = 384,
+     SAMPLER = 385,
+     SAMPLERSHADOW = 386,
+     TEXTURE1D = 387,
+     TEXTURE2D = 388,
+     TEXTURE3D = 389,
+     TEXTURECUBE = 390,
+     TEXTURE1DARRAY = 391,
+     TEXTURE2DARRAY = 392,
+     ITEXTURE1D = 393,
+     ITEXTURE2D = 394,
+     ITEXTURE3D = 395,
+     ITEXTURECUBE = 396,
+     ITEXTURE1DARRAY = 397,
+     ITEXTURE2DARRAY = 398,
+     UTEXTURE1D = 399,
+     UTEXTURE2D = 400,
+     UTEXTURE3D = 401,
+     UTEXTURECUBE = 402,
+     UTEXTURE1DARRAY = 403,
+     UTEXTURE2DARRAY = 404,
+     TEXTURE2DRECT = 405,
+     ITEXTURE2DRECT = 406,
+     UTEXTURE2DRECT = 407,
+     TEXTUREBUFFER = 408,
+     ITEXTUREBUFFER = 409,
+     UTEXTUREBUFFER = 410,
+     TEXTURECUBEARRAY = 411,
+     ITEXTURECUBEARRAY = 412,
+     UTEXTURECUBEARRAY = 413,
+     TEXTURE2DMS = 414,
+     ITEXTURE2DMS = 415,
+     UTEXTURE2DMS = 416,
+     TEXTURE2DMSARRAY = 417,
+     ITEXTURE2DMSARRAY = 418,
+     UTEXTURE2DMSARRAY = 419,
+     SUBPASSINPUT = 420,
+     SUBPASSINPUTMS = 421,
+     ISUBPASSINPUT = 422,
+     ISUBPASSINPUTMS = 423,
+     USUBPASSINPUT = 424,
+     USUBPASSINPUTMS = 425,
+     IMAGE1D = 426,
+     IIMAGE1D = 427,
+     UIMAGE1D = 428,
+     IMAGE2D = 429,
+     IIMAGE2D = 430,
+     UIMAGE2D = 431,
+     IMAGE3D = 432,
+     IIMAGE3D = 433,
+     UIMAGE3D = 434,
+     IMAGE2DRECT = 435,
+     IIMAGE2DRECT = 436,
+     UIMAGE2DRECT = 437,
+     IMAGECUBE = 438,
+     IIMAGECUBE = 439,
+     UIMAGECUBE = 440,
+     IMAGEBUFFER = 441,
+     IIMAGEBUFFER = 442,
+     UIMAGEBUFFER = 443,
+     IMAGE1DARRAY = 444,
+     IIMAGE1DARRAY = 445,
+     UIMAGE1DARRAY = 446,
+     IMAGE2DARRAY = 447,
+     IIMAGE2DARRAY = 448,
+     UIMAGE2DARRAY = 449,
+     IMAGECUBEARRAY = 450,
+     IIMAGECUBEARRAY = 451,
+     UIMAGECUBEARRAY = 452,
+     IMAGE2DMS = 453,
+     IIMAGE2DMS = 454,
+     UIMAGE2DMS = 455,
+     IMAGE2DMSARRAY = 456,
+     IIMAGE2DMSARRAY = 457,
+     UIMAGE2DMSARRAY = 458,
+     STRUCT = 459,
+     VOID = 460,
+     WHILE = 461,
+     IDENTIFIER = 462,
+     TYPE_NAME = 463,
+     FLOATCONSTANT = 464,
+     DOUBLECONSTANT = 465,
+     INTCONSTANT = 466,
+     UINTCONSTANT = 467,
+     INT64CONSTANT = 468,
+     UINT64CONSTANT = 469,
+     BOOLCONSTANT = 470,
+     LEFT_OP = 471,
+     RIGHT_OP = 472,
+     INC_OP = 473,
+     DEC_OP = 474,
+     LE_OP = 475,
+     GE_OP = 476,
+     EQ_OP = 477,
+     NE_OP = 478,
+     AND_OP = 479,
+     OR_OP = 480,
+     XOR_OP = 481,
+     MUL_ASSIGN = 482,
+     DIV_ASSIGN = 483,
+     ADD_ASSIGN = 484,
+     MOD_ASSIGN = 485,
+     LEFT_ASSIGN = 486,
+     RIGHT_ASSIGN = 487,
+     AND_ASSIGN = 488,
+     XOR_ASSIGN = 489,
+     OR_ASSIGN = 490,
+     SUB_ASSIGN = 491,
+     LEFT_PAREN = 492,
+     RIGHT_PAREN = 493,
+     LEFT_BRACKET = 494,
+     RIGHT_BRACKET = 495,
+     LEFT_BRACE = 496,
+     RIGHT_BRACE = 497,
+     DOT = 498,
+     COMMA = 499,
+     COLON = 500,
+     EQUAL = 501,
+     SEMICOLON = 502,
+     BANG = 503,
+     DASH = 504,
+     TILDE = 505,
+     PLUS = 506,
+     STAR = 507,
+     SLASH = 508,
+     PERCENT = 509,
+     LEFT_ANGLE = 510,
+     RIGHT_ANGLE = 511,
+     VERTICAL_BAR = 512,
+     CARET = 513,
+     AMPERSAND = 514,
+     QUESTION = 515,
+     INVARIANT = 516,
+     PRECISE = 517,
+     HIGH_PRECISION = 518,
+     MEDIUM_PRECISION = 519,
+     LOW_PRECISION = 520,
+     PRECISION = 521,
+     PACKED = 522,
+     RESOURCE = 523,
+     SUPERP = 524
    };
 #endif
 
@@ -311,7 +321,7 @@ extern int yydebug;
 typedef union YYSTYPE
 {
 /* Line 2058 of yacc.c  */
-#line 66 "C:/Projects/glslang/glslang/MachineIndependent/glslang.y"
+#line 66 "glslang.y"
 
     struct {
         glslang::TSourceLoc loc;
@@ -319,6 +329,8 @@ typedef union YYSTYPE
             glslang::TString *string;
             int i;
             unsigned int u;
+            long long i64;
+            unsigned long long u64;
             bool b;
             double d;
         };
@@ -345,7 +357,7 @@ typedef union YYSTYPE
 
 
 /* Line 2058 of yacc.c  */
-#line 349 "C:/Projects/glslang/glslang/MachineIndependent/glslang_tab.cpp.h"
+#line 361 "glslang_tab.cpp.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -367,4 +379,4 @@ int yyparse ();
 #endif
 #endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_YY_C_PROJECTS_GLSLANG_GLSLANG_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */

diff --git a/glslang/MachineIndependent/intermOut.cpp b/glslang/MachineIndependent/intermOut.cpp
index eb6c30c..82e7160 100644 (file)
--- a/glslang/MachineIndependent/intermOut.cpp
+++ b/glslang/MachineIndependent/intermOut.cpp
@@ -206,22 +206,44 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
     case EOpConvUintToBool:    out.debug << "Convert uint to bool";    break;
     case EOpConvFloatToBool:   out.debug << "Convert float to bool";   break;
     case EOpConvDoubleToBool:  out.debug << "Convert double to bool";  break;
+    case EOpConvInt64ToBool:   out.debug << "Convert int64 to bool";   break;
+    case EOpConvUint64ToBool:  out.debug << "Convert uint64 to bool";  break;
     case EOpConvIntToFloat:    out.debug << "Convert int to float";    break;
     case EOpConvUintToFloat:   out.debug << "Convert uint to float";   break;
     case EOpConvDoubleToFloat: out.debug << "Convert double to float"; break;
+    case EOpConvInt64ToFloat:  out.debug << "Convert int64 to float";  break;
+    case EOpConvUint64ToFloat: out.debug << "Convert uint64 to float"; break;
     case EOpConvBoolToFloat:   out.debug << "Convert bool to float";   break;
     case EOpConvUintToInt:     out.debug << "Convert uint to int";     break;
     case EOpConvFloatToInt:    out.debug << "Convert float to int";    break;
     case EOpConvDoubleToInt:   out.debug << "Convert double to int";   break;
     case EOpConvBoolToInt:     out.debug << "Convert bool to int";     break;
+    case EOpConvInt64ToInt:    out.debug << "Convert int64 to int";    break;
+    case EOpConvUint64ToInt:   out.debug << "Convert uint64 to int";   break;
     case EOpConvIntToUint:     out.debug << "Convert int to uint";     break;
     case EOpConvFloatToUint:   out.debug << "Convert float to uint";   break;
     case EOpConvDoubleToUint:  out.debug << "Convert double to uint";  break;
     case EOpConvBoolToUint:    out.debug << "Convert bool to uint";    break;
+    case EOpConvInt64ToUint:   out.debug << "Convert int64 to uint";   break;
+    case EOpConvUint64ToUint:  out.debug << "Convert uint64 to uint";  break;
     case EOpConvIntToDouble:   out.debug << "Convert int to double";   break;
     case EOpConvUintToDouble:  out.debug << "Convert uint to double";  break;
     case EOpConvFloatToDouble: out.debug << "Convert float to double"; break;
     case EOpConvBoolToDouble:  out.debug << "Convert bool to double";  break;
+    case EOpConvInt64ToDouble: out.debug << "Convert int64 to double"; break;
+    case EOpConvUint64ToDouble: out.debug << "Convert uint64 to double";  break;
+    case EOpConvBoolToInt64:   out.debug << "Convert bool to int64";   break;
+    case EOpConvIntToInt64:    out.debug << "Convert int to int64";    break;
+    case EOpConvUintToInt64:   out.debug << "Convert uint to int64";   break;
+    case EOpConvFloatToInt64:  out.debug << "Convert float to int64";  break;
+    case EOpConvDoubleToInt64: out.debug << "Convert double to int64"; break;
+    case EOpConvUint64ToInt64: out.debug << "Convert uint64 to int64"; break;
+    case EOpConvBoolToUint64:  out.debug << "Convert bool to uint64";  break;
+    case EOpConvIntToUint64:   out.debug << "Convert int to uint64";   break;
+    case EOpConvUintToUint64:  out.debug << "Convert uint to uint64";  break;
+    case EOpConvFloatToUint64: out.debug << "Convert float to uint64"; break;
+    case EOpConvDoubleToUint64: out.debug << "Convert double to uint64"; break;
+    case EOpConvInt64ToUint64: out.debug << "Convert uint64 to uint64"; break;
 
     case EOpRadians:        out.debug << "radians";              break;
     case EOpDegrees:        out.debug << "degrees";              break;
@@ -261,6 +283,10 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
     case EOpFloatBitsToUint:out.debug << "floatBitsToUint";      break;
     case EOpIntBitsToFloat: out.debug << "intBitsToFloat";       break;
     case EOpUintBitsToFloat:out.debug << "uintBitsToFloat";      break;
+    case EOpDoubleBitsToInt64:  out.debug << "doubleBitsToInt64";  break;
+    case EOpDoubleBitsToUint64: out.debug << "doubleBitsToUint64"; break;
+    case EOpInt64BitsToDouble:  out.debug << "int64BitsToDouble";  break;
+    case EOpUint64BitsToDouble: out.debug << "uint64BitsToDouble"; break;
     case EOpPackSnorm2x16:  out.debug << "packSnorm2x16";        break;
     case EOpUnpackSnorm2x16:out.debug << "unpackSnorm2x16";      break;
     case EOpPackUnorm2x16:  out.debug << "packUnorm2x16";        break;
@@ -275,6 +301,11 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
     case EOpPackDouble2x32:   out.debug << "PackDouble2x32";     break;
     case EOpUnpackDouble2x32: out.debug << "UnpackDouble2x32";   break;
 
+    case EOpPackInt2x32:      out.debug << "packInt2x32";        break;
+    case EOpUnpackInt2x32:    out.debug << "unpackInt2x32";      break;
+    case EOpPackUint2x32:     out.debug << "packUint2x32";       break;
+    case EOpUnpackUint2x32:   out.debug << "unpackUint2x32";     break;
+
     case EOpLength:         out.debug << "length";               break;
     case EOpNormalize:      out.debug << "normalize";            break;
     case EOpDPdx:           out.debug << "dPdx";                 break;
@@ -366,6 +397,14 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpConstructUVec2:   out.debug << "Construct uvec2";   break;
     case EOpConstructUVec3:   out.debug << "Construct uvec3";   break;
     case EOpConstructUVec4:   out.debug << "Construct uvec4";   break;
+    case EOpConstructInt64:   out.debug << "Construct int64_t"; break;
+    case EOpConstructI64Vec2: out.debug << "Construct i64vec2"; break;
+    case EOpConstructI64Vec3: out.debug << "Construct i64vec3"; break;
+    case EOpConstructI64Vec4: out.debug << "Construct i64vec4"; break;
+    case EOpConstructUint64:  out.debug << "Construct uint64_t"; break;
+    case EOpConstructU64Vec2: out.debug << "Construct u64vec2"; break;
+    case EOpConstructU64Vec3: out.debug << "Construct u64vec3"; break;
+    case EOpConstructU64Vec4: out.debug << "Construct u64vec4"; break;
     case EOpConstructMat2x2:  out.debug << "Construct mat2";    break;
     case EOpConstructMat2x3:  out.debug << "Construct mat2x3";  break;
     case EOpConstructMat2x4:  out.debug << "Construct mat2x4";  break;
@@ -582,6 +621,24 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const
                 out.debug << buf << "\n";
             }
             break;
+        case EbtInt64:
+            {
+                const int maxSize = 300;
+                char buf[maxSize];
+                snprintf(buf, maxSize, "%lld (%s)", constUnion[i].getI64Const(), "const int64_t");
+
+                out.debug << buf << "\n";
+            }
+            break;
+        case EbtUint64:
+            {
+                const int maxSize = 300;
+                char buf[maxSize];
+                snprintf(buf, maxSize, "%llu (%s)", constUnion[i].getU64Const(), "const uint64_t");
+
+                out.debug << buf << "\n";
+            }
+            break;
         default:
             out.info.message(EPrefixInternalError, "Unknown constant", node->getLoc());
             break;

diff --git a/glslang/MachineIndependent/linkValidate.cpp b/glslang/MachineIndependent/linkValidate.cpp
index ef9daa8..f82ca21 100644 (file)
--- a/glslang/MachineIndependent/linkValidate.cpp
+++ b/glslang/MachineIndependent/linkValidate.cpp
@@ -880,6 +880,8 @@ const int baseAlignmentVec4Std140 = 16;
 int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size)
 {
     switch (type.getBasicType()) {
+    case EbtInt64:
+    case EbtUint64:
     case EbtDouble:  size = 8; return 8;
     default:         size = 4; return 4;
     }

diff --git a/glslang/MachineIndependent/localintermediate.h b/glslang/MachineIndependent/localintermediate.h
index c2d0c74..17b7d21 100644 (file)
--- a/glslang/MachineIndependent/localintermediate.h
+++ b/glslang/MachineIndependent/localintermediate.h
@@ -191,6 +191,8 @@ public:
     TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, const TSourceLoc&, bool literal = false) const;
     TIntermConstantUnion* addConstantUnion(int, const TSourceLoc&, bool literal = false) const;
     TIntermConstantUnion* addConstantUnion(unsigned int, const TSourceLoc&, bool literal = false) const;
+    TIntermConstantUnion* addConstantUnion(long long, const TSourceLoc&, bool literal = false) const;
+    TIntermConstantUnion* addConstantUnion(unsigned long long, const TSourceLoc&, bool literal = false) const;
     TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const;
     TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const;
     TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const;

diff --git a/glslang/MachineIndependent/parseVersions.h b/glslang/MachineIndependent/parseVersions.h
index c9dfdc9..13d7680 100755 (executable)
--- a/glslang/MachineIndependent/parseVersions.h
+++ b/glslang/MachineIndependent/parseVersions.h
@@ -76,6 +76,7 @@ public:
     virtual void updateExtensionBehavior(int line, const char* const extension, const char* behavior);
     virtual void fullIntegerCheck(const TSourceLoc&, const char* op);
     virtual void doubleCheck(const TSourceLoc&, const char* op);
+    virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void spvRemoved(const TSourceLoc&, const char* op);
     virtual void vulkanRemoved(const TSourceLoc&, const char* op);
     virtual void requireVulkan(const TSourceLoc&, const char* op);

diff --git a/glslang/MachineIndependent/preprocessor/Pp.cpp b/glslang/MachineIndependent/preprocessor/Pp.cpp
index b9d00c8..3509758 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/Pp.cpp
+++ b/glslang/MachineIndependent/preprocessor/Pp.cpp
@@ -705,7 +705,8 @@ int TPpContext::CPPerror(TPpToken* ppToken)
     TSourceLoc loc = ppToken->loc;
 
     while (token != '\n' && token != EndOfInput) {
-        if (token == PpAtomConstInt || token == PpAtomConstUint ||
+        if (token == PpAtomConstInt   || token == PpAtomConstUint   ||
+            token == PpAtomConstInt64 || token == PpAtomConstUint64 ||
             token == PpAtomConstFloat || token == PpAtomConstDouble) {
                 message.append(ppToken->name);
         } else if (token == PpAtomIdentifier || token == PpAtomConstString) {
@@ -736,6 +737,8 @@ int TPpContext::CPPpragma(TPpToken* ppToken)
         case PpAtomIdentifier:
         case PpAtomConstInt:
         case PpAtomConstUint:
+        case PpAtomConstInt64:
+        case PpAtomConstUint64:
         case PpAtomConstFloat:
         case PpAtomConstDouble:
             tokens.push_back(ppToken->name);

diff --git a/glslang/MachineIndependent/preprocessor/PpContext.h b/glslang/MachineIndependent/preprocessor/PpContext.h
index f65eb60..4e47fa0 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/PpContext.h
+++ b/glslang/MachineIndependent/preprocessor/PpContext.h
@@ -111,6 +111,7 @@ public:
     bool   space;  // true if a space (for white space or a removed comment) should also be recognized, in front of the token returned
     int    ival;
     double dval;
+    long long i64val;
     int    atom;
     char   name[MaxTokenLength + 1];
 };

diff --git a/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/glslang/MachineIndependent/preprocessor/PpScanner.cpp
index 719365d..b3d1af6 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/PpScanner.cpp
+++ b/glslang/MachineIndependent/preprocessor/PpScanner.cpp
@@ -238,9 +238,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
     int len = 0;
     int ch = 0;
     int ii = 0;
-    unsigned ival = 0;
+    unsigned long long ival = 0;
+    bool enableInt64 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64);
 
     ppToken->ival = 0;
+    ppToken->i64val = 0;
     ppToken->space = false;
     ch = getch();
     for (;;) {
@@ -299,6 +301,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                 // must be hexidecimal
 
                 bool isUnsigned = false;
+                bool isInt64 = false;
                 ppToken->name[len++] = (char)ch;
                 ch = getch();
                 if ((ch >= '0' && ch <= '9') ||
@@ -307,7 +310,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
 
                     ival = 0;
                     do {
-                        if (ival <= 0x0fffffff) {
+                        if (ival <= 0x0fffffff || (enableInt64 && ival <= 0x0fffffffffffffffull)) {
                             ppToken->name[len++] = (char)ch;
                             if (ch >= '0' && ch <= '9') {
                                 ii = ch - '0';
@@ -323,7 +326,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                                 pp->parseContext.ppError(ppToken->loc, "hexidecimal literal too big", "", "");
                                 AlreadyComplained = 1;
                             }
-                            ival = 0xffffffff;
+                            ival = 0xffffffffffffffffull;
                         }
                         ch = getch();
                     } while ((ch >= '0' && ch <= '9') ||
@@ -336,19 +339,37 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                     if (len < MaxTokenLength)
                         ppToken->name[len++] = (char)ch;
                     isUnsigned = true;
+
+                    if (enableInt64) {
+                        int nextCh = getch();
+                        if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) {
+                            if (len < MaxTokenLength)
+                                ppToken->name[len++] = (char)nextCh;
+                            isInt64 = true;
+                        } else
+                            ungetch();
+                    }
+                }
+                else if (enableInt64 && (ch == 'l' || ch == 'L')) {
+                    if (len < MaxTokenLength)
+                        ppToken->name[len++] = (char)ch;
+                    isInt64 = true;
                 } else
                     ungetch();
                 ppToken->name[len] = '\0';
-                ppToken->ival = (int)ival;
 
-                if (isUnsigned)
-                    return PpAtomConstUint;
-                else
-                    return PpAtomConstInt;
+                if (isInt64) {
+                    ppToken->i64val = ival;
+                    return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
+                } else {
+                    ppToken->ival = (int)ival;
+                    return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
+                }
             } else {
                 // could be octal integer or floating point, speculative pursue octal until it must be floating point
 
                 bool isUnsigned = false;
+                bool isInt64 = false;
                 bool octalOverflow = false;
                 bool nonOctal = false;
                 ival = 0;
@@ -361,7 +382,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                         pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", "");
                         AlreadyComplained = 1;
                     }
-                    if (ival <= 0x1fffffff) {
+                    if (ival <= 0x1fffffff || (enableInt64 && ival <= 0x1fffffffffffffffull)) {
                         ii = ch - '0';
                         ival = (ival << 3) | ii;
                     } else
@@ -382,7 +403,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                         ch = getch();
                     } while (ch >= '0' && ch <= '9');
                 }
-                if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F' || ch == 'l' || ch == 'L') 
+                if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F')
                     return pp->lFloatConst(len, ch, ppToken);
                 
                 // wasn't a float, so must be octal...
@@ -393,6 +414,21 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                     if (len < MaxTokenLength)
                         ppToken->name[len++] = (char)ch;
                     isUnsigned = true;
+
+                    if (enableInt64) {
+                        int nextCh = getch();
+                        if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) {
+                            if (len < MaxTokenLength)
+                                ppToken->name[len++] = (char)nextCh;
+                            isInt64 = true;
+                        } else
+                            ungetch();
+                    }
+                }
+                else if (enableInt64 && (ch == 'l' || ch == 'L')) {
+                    if (len < MaxTokenLength)
+                        ppToken->name[len++] = (char)ch;
+                    isInt64 = true;
                 } else
                     ungetch();
                 ppToken->name[len] = '\0';
@@ -400,12 +436,13 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                 if (octalOverflow)
                     pp->parseContext.ppError(ppToken->loc, "octal literal too big", "", "");
 
-                ppToken->ival = (int)ival;
-
-                if (isUnsigned)
-                    return PpAtomConstUint;
-                else
-                    return PpAtomConstInt;
+                if (isInt64) {
+                    ppToken->i64val = ival;
+                    return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
+                } else {
+                    ppToken->ival = (int)ival;
+                    return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
+                }
             }
             break;
         case '1': case '2': case '3': case '4':
@@ -421,16 +458,31 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                 }
                 ch = getch();
             } while (ch >= '0' && ch <= '9');
-            if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F' || ch == 'l' || ch == 'L') {
+            if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'E' || ch == 'F') {
                 return pp->lFloatConst(len, ch, ppToken);
             } else {
                 // Finish handling signed and unsigned integers
                 int numericLen = len;
-                bool uint = false;
+                bool isUnsigned = false;
+                bool isInt64 = false;
                 if (ch == 'u' || ch == 'U') {
                     if (len < MaxTokenLength)
                         ppToken->name[len++] = (char)ch;
-                    uint = true;
+                    isUnsigned = true;
+
+                    if (enableInt64) {
+                        int nextCh = getch();
+                        if ((ch == 'u' && nextCh == 'l') || (ch == 'U' && nextCh == 'L')) {
+                            if (len < MaxTokenLength)
+                                ppToken->name[len++] = (char)nextCh;
+                            isInt64 = true;
+                        } else
+                            ungetch();
+                    }
+                } else if (enableInt64 && (ch == 'l' || ch == 'L')) {
+                    if (len < MaxTokenLength)
+                        ppToken->name[len++] = (char)ch;
+                    isInt64 = true;
                 } else
                     ungetch();
 
@@ -438,21 +490,26 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
                 ival = 0;
                 const unsigned oneTenthMaxInt  = 0xFFFFFFFFu / 10;
                 const unsigned remainderMaxInt = 0xFFFFFFFFu - 10 * oneTenthMaxInt;
+                const unsigned long long oneTenthMaxInt64  = 0xFFFFFFFFFFFFFFFFull / 10;
+                const unsigned long long remainderMaxInt64 = 0xFFFFFFFFFFFFFFFFull - 10 * oneTenthMaxInt64;
                 for (int i = 0; i < numericLen; i++) {
                     ch = ppToken->name[i] - '0';
-                    if ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt)) {
+                    if ((enableInt64 == false && ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt))) ||
+                        (enableInt64 && ((ival > oneTenthMaxInt64) || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64)))) {
                         pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", "");
-                        ival = 0xFFFFFFFFu;
+                        ival = 0xFFFFFFFFFFFFFFFFull;
                         break;
                     } else
                         ival = ival * 10 + ch;
                 }
-                ppToken->ival = (int)ival;
 
-                if (uint)
-                    return PpAtomConstUint;
-                else
-                    return PpAtomConstInt;
+                if (isInt64) {
+                    ppToken->i64val = ival;
+                    return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
+                } else {
+                    ppToken->ival = (int)ival;
+                    return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
+                }
             }
             break;
         case '-':
@@ -686,6 +743,8 @@ const char* TPpContext::tokenize(TPpToken* ppToken)
         case PpAtomConstInt:
         case PpAtomConstUint:
         case PpAtomConstFloat:
+        case PpAtomConstInt64:
+        case PpAtomConstUint64:
         case PpAtomConstDouble:
             tokenString = ppToken->name;
             break;

diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/glslang/MachineIndependent/preprocessor/PpTokens.cpp
index 52343b7..95da3db 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/PpTokens.cpp
+++ b/glslang/MachineIndependent/preprocessor/PpTokens.cpp
@@ -141,6 +141,8 @@ void TPpContext::RecordToken(TokenStream *pTok, int token, TPpToken* ppToken)
         break;
     case PpAtomConstInt:
     case PpAtomConstUint:
+    case PpAtomConstInt64:
+    case PpAtomConstUint64:
     case PpAtomConstFloat:
     case PpAtomConstDouble:
         str = ppToken->name;
@@ -193,6 +195,8 @@ int TPpContext::ReadToken(TokenStream *pTok, TPpToken *ppToken)
     case PpAtomConstDouble:
     case PpAtomConstInt:
     case PpAtomConstUint:
+    case PpAtomConstInt64:
+    case PpAtomConstUint64:
         len = 0;
         ch = lReadByte(pTok);
         while (ch != 0 && ch != EndOfInput) {
@@ -227,6 +231,16 @@ int TPpContext::ReadToken(TokenStream *pTok, TPpToken *ppToken)
             } else
                 ppToken->ival = atoi(ppToken->name);
             break;
+        case PpAtomConstInt64:
+        case PpAtomConstUint64:
+            if (len > 0 && tokenText[0] == '0') {
+                if (len > 1 && (tokenText[1] == 'x' || tokenText[1] == 'X'))
+                    ppToken->i64val = std::stoll(ppToken->name, 0, 16);
+                else
+                    ppToken->i64val = std::stoll(ppToken->name, 0, 8);
+            } else
+                ppToken->i64val = std::stoll(ppToken->name);
+            break;
         }
     }
 

diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.h b/glslang/MachineIndependent/preprocessor/PpTokens.h
index 391b04a..87f0eb1 100644 (file)
--- a/glslang/MachineIndependent/preprocessor/PpTokens.h
+++ b/glslang/MachineIndependent/preprocessor/PpTokens.h
@@ -119,6 +119,8 @@ enum EFixedAtoms {
 
     PpAtomConstInt,
     PpAtomConstUint,
+    PpAtomConstInt64,
+    PpAtomConstUint64,
     PpAtomConstFloat,
     PpAtomConstDouble,
     PpAtomConstString,

diff --git a/glslang/MachineIndependent/reflection.cpp b/glslang/MachineIndependent/reflection.cpp
index 9ef6d02..19e08e1 100644 (file)
--- a/glslang/MachineIndependent/reflection.cpp
+++ b/glslang/MachineIndependent/reflection.cpp
@@ -540,6 +540,8 @@ public:
             case EbtDouble:     return GL_DOUBLE_VEC2                 + offset;
             case EbtInt:        return GL_INT_VEC2                    + offset;
             case EbtUint:       return GL_UNSIGNED_INT_VEC2           + offset;
+            case EbtInt64:      return GL_INT64_ARB                   + offset;
+            case EbtUint64:     return GL_UNSIGNED_INT64_ARB          + offset;
             case EbtBool:       return GL_BOOL_VEC2                   + offset;
             case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER + offset;
             default:            return 0;
@@ -605,6 +607,8 @@ public:
             case EbtDouble:     return GL_DOUBLE;
             case EbtInt:        return GL_INT;
             case EbtUint:       return GL_UNSIGNED_INT;
+            case EbtInt64:      return GL_INT64_ARB;
+            case EbtUint64:     return GL_UNSIGNED_INT64_ARB;
             case EbtBool:       return GL_BOOL;
             case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER;
             default:            return 0;

diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp
index 9cd0787..e5040b2 100644 (file)
--- a/gtests/Spv.FromFile.cpp
+++ b/gtests/Spv.FromFile.cpp
@@ -119,6 +119,7 @@ INSTANTIATE_TEST_CASE_P(
         "spv.functionCall.frag",
         "spv.functionSemantics.frag",
         "spv.interpOps.frag",
+        "spv.int64.frag",
         "spv.layoutNested.vert",
         "spv.length.frag",
         "spv.localAggregates.frag",