code: /* A Bison parser, made by GNU Bison 3.0.4.  */
  
  /* Bison implementation for Yacc-like parsers in C
  
     Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
  
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
  
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  
  /* As a special exception, you may create a larger work that contains
     part or all of the Bison parser skeleton and distribute that work
     under terms of your choice, so long as that work isn't itself a
     parser generator using the skeleton or a modified version thereof
     as a parser skeleton.  Alternatively, if you modify or redistribute
     the parser skeleton itself, you may (at your option) remove this
     special exception, which will cause the skeleton and the resulting
     Bison output files to be licensed under the GNU General Public
     License without this special exception.
  
     This special exception was added by the Free Software Foundation in
     version 2.2 of Bison.  */
  
  /* C LALR(1) parser skeleton written by Richard Stallman, by
     simplifying the original so-called "semantic" parser.  */
  
  /* All symbols defined below should begin with yy or YY, to avoid
     infringing on user name space.  This should be done even for local
     variables, as they might otherwise be expanded by user macros.
     There are some unavoidable exceptions within include files to
     define necessary library symbols; they are noted "INFRINGES ON
     USER NAME SPACE" below.  */
  
  /* Identify Bison output.  */
  #define YYBISON 1
  
  /* Bison version.  */
  #define YYBISON_VERSION "3.0.4"
  
  /* Skeleton name.  */
  #define YYSKELETON_NAME "yacc.c"
  
  /* Pure parsers.  */
  #define YYPURE 1
  
  /* Push parsers.  */
  #define YYPUSH 0
  
  /* Pull parsers.  */
  #define YYPULL 1
  
  
  
  
  /* Copy the first part of user declarations.  */
  #line 68 "MachineIndependent/glslang.y" /* yacc.c:339  */
  
  
  /* Based on:
  ANSI C Yacc grammar
  
  In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a
  matching Lex specification) for the April 30, 1985 draft version of the
  ANSI C standard.  Tom Stockfisch reposted it to net.sources in 1987; that
  original, as mentioned in the answer to question 17.25 of the comp.lang.c
  FAQ, can be ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
  
  I intend to keep this version as close to the current C Standard grammar as
  possible; please let me know if you discover discrepancies.
  
  Jutta Degener, 1995
  */
  
  #include "SymbolTable.h"
  #include "ParseHelper.h"
  #include "../Public/ShaderLang.h"
  #include "attribute.h"
  
  using namespace glslang;
  
  
  #line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339  */
  
  # ifndef YY_NULLPTR
  #  if defined __cplusplus && 201103L <= __cplusplus
  #   define YY_NULLPTR nullptr
  #  else
  #   define YY_NULLPTR 0
  #  endif
  # endif
  
  /* Enabling verbose error messages.  */
  #ifdef YYERROR_VERBOSE
  # undef YYERROR_VERBOSE
  # define YYERROR_VERBOSE 1
  #else
  # define YYERROR_VERBOSE 1
  #endif
  
  /* In a future release of Bison, this section will be replaced
     by #include "glslang_tab.cpp.h".  */
  #ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
  # define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
  /* Debug traces.  */
  #ifndef YYDEBUG
  # define YYDEBUG 1
  #endif
  #if YYDEBUG
  extern int yydebug;
  #endif
  
  /* Token type.  */
  #ifndef YYTOKENTYPE
  # define YYTOKENTYPE
    enum yytokentype
    {
      CONST = 258,
      BOOL = 259,
      INT = 260,
      UINT = 261,
      FLOAT = 262,
      BVEC2 = 263,
      BVEC3 = 264,
      BVEC4 = 265,
      IVEC2 = 266,
      IVEC3 = 267,
      IVEC4 = 268,
      UVEC2 = 269,
      UVEC3 = 270,
      UVEC4 = 271,
      VEC2 = 272,
      VEC3 = 273,
      VEC4 = 274,
      MAT2 = 275,
      MAT3 = 276,
      MAT4 = 277,
      MAT2X2 = 278,
      MAT2X3 = 279,
      MAT2X4 = 280,
      MAT3X2 = 281,
      MAT3X3 = 282,
      MAT3X4 = 283,
      MAT4X2 = 284,
      MAT4X3 = 285,
      MAT4X4 = 286,
      SAMPLER2D = 287,
      SAMPLER3D = 288,
      SAMPLERCUBE = 289,
      SAMPLER2DSHADOW = 290,
      SAMPLERCUBESHADOW = 291,
      SAMPLER2DARRAY = 292,
      SAMPLER2DARRAYSHADOW = 293,
      ISAMPLER2D = 294,
      ISAMPLER3D = 295,
      ISAMPLERCUBE = 296,
      ISAMPLER2DARRAY = 297,
      USAMPLER2D = 298,
      USAMPLER3D = 299,
      USAMPLERCUBE = 300,
      USAMPLER2DARRAY = 301,
      SAMPLER = 302,
      SAMPLERSHADOW = 303,
      TEXTURE2D = 304,
      TEXTURE3D = 305,
      TEXTURECUBE = 306,
      TEXTURE2DARRAY = 307,
      ITEXTURE2D = 308,
      ITEXTURE3D = 309,
      ITEXTURECUBE = 310,
      ITEXTURE2DARRAY = 311,
      UTEXTURE2D = 312,
      UTEXTURE3D = 313,
      UTEXTURECUBE = 314,
      UTEXTURE2DARRAY = 315,
      ATTRIBUTE = 316,
      VARYING = 317,
      FLOAT16_T = 318,
      FLOAT32_T = 319,
      DOUBLE = 320,
      FLOAT64_T = 321,
      INT64_T = 322,
      UINT64_T = 323,
      INT32_T = 324,
      UINT32_T = 325,
      INT16_T = 326,
      UINT16_T = 327,
      INT8_T = 328,
      UINT8_T = 329,
      I64VEC2 = 330,
      I64VEC3 = 331,
      I64VEC4 = 332,
      U64VEC2 = 333,
      U64VEC3 = 334,
      U64VEC4 = 335,
      I32VEC2 = 336,
      I32VEC3 = 337,
      I32VEC4 = 338,
      U32VEC2 = 339,
      U32VEC3 = 340,
      U32VEC4 = 341,
      I16VEC2 = 342,
      I16VEC3 = 343,
      I16VEC4 = 344,
      U16VEC2 = 345,
      U16VEC3 = 346,
      U16VEC4 = 347,
      I8VEC2 = 348,
      I8VEC3 = 349,
      I8VEC4 = 350,
      U8VEC2 = 351,
      U8VEC3 = 352,
      U8VEC4 = 353,
      DVEC2 = 354,
      DVEC3 = 355,
      DVEC4 = 356,
      DMAT2 = 357,
      DMAT3 = 358,
      DMAT4 = 359,
      F16VEC2 = 360,
      F16VEC3 = 361,
      F16VEC4 = 362,
      F16MAT2 = 363,
      F16MAT3 = 364,
      F16MAT4 = 365,
      F32VEC2 = 366,
      F32VEC3 = 367,
      F32VEC4 = 368,
      F32MAT2 = 369,
      F32MAT3 = 370,
      F32MAT4 = 371,
      F64VEC2 = 372,
      F64VEC3 = 373,
      F64VEC4 = 374,
      F64MAT2 = 375,
      F64MAT3 = 376,
      F64MAT4 = 377,
      DMAT2X2 = 378,
      DMAT2X3 = 379,
      DMAT2X4 = 380,
      DMAT3X2 = 381,
      DMAT3X3 = 382,
      DMAT3X4 = 383,
      DMAT4X2 = 384,
      DMAT4X3 = 385,
      DMAT4X4 = 386,
      F16MAT2X2 = 387,
      F16MAT2X3 = 388,
      F16MAT2X4 = 389,
      F16MAT3X2 = 390,
      F16MAT3X3 = 391,
      F16MAT3X4 = 392,
      F16MAT4X2 = 393,
      F16MAT4X3 = 394,
      F16MAT4X4 = 395,
      F32MAT2X2 = 396,
      F32MAT2X3 = 397,
      F32MAT2X4 = 398,
      F32MAT3X2 = 399,
      F32MAT3X3 = 400,
      F32MAT3X4 = 401,
      F32MAT4X2 = 402,
      F32MAT4X3 = 403,
      F32MAT4X4 = 404,
      F64MAT2X2 = 405,
      F64MAT2X3 = 406,
      F64MAT2X4 = 407,
      F64MAT3X2 = 408,
      F64MAT3X3 = 409,
      F64MAT3X4 = 410,
      F64MAT4X2 = 411,
      F64MAT4X3 = 412,
      F64MAT4X4 = 413,
      ATOMIC_UINT = 414,
      ACCSTRUCTNV = 415,
      FCOOPMATNV = 416,
      ICOOPMATNV = 417,
      UCOOPMATNV = 418,
      SAMPLERCUBEARRAY = 419,
      SAMPLERCUBEARRAYSHADOW = 420,
      ISAMPLERCUBEARRAY = 421,
      USAMPLERCUBEARRAY = 422,
      SAMPLER1D = 423,
      SAMPLER1DARRAY = 424,
      SAMPLER1DARRAYSHADOW = 425,
      ISAMPLER1D = 426,
      SAMPLER1DSHADOW = 427,
      SAMPLER2DRECT = 428,
      SAMPLER2DRECTSHADOW = 429,
      ISAMPLER2DRECT = 430,
      USAMPLER2DRECT = 431,
      SAMPLERBUFFER = 432,
      ISAMPLERBUFFER = 433,
      USAMPLERBUFFER = 434,
      SAMPLER2DMS = 435,
      ISAMPLER2DMS = 436,
      USAMPLER2DMS = 437,
      SAMPLER2DMSARRAY = 438,
      ISAMPLER2DMSARRAY = 439,
      USAMPLER2DMSARRAY = 440,
      SAMPLEREXTERNALOES = 441,
      SAMPLEREXTERNAL2DY2YEXT = 442,
      ISAMPLER1DARRAY = 443,
      USAMPLER1D = 444,
      USAMPLER1DARRAY = 445,
      F16SAMPLER1D = 446,
      F16SAMPLER2D = 447,
      F16SAMPLER3D = 448,
      F16SAMPLER2DRECT = 449,
      F16SAMPLERCUBE = 450,
      F16SAMPLER1DARRAY = 451,
      F16SAMPLER2DARRAY = 452,
      F16SAMPLERCUBEARRAY = 453,
      F16SAMPLERBUFFER = 454,
      F16SAMPLER2DMS = 455,
      F16SAMPLER2DMSARRAY = 456,
      F16SAMPLER1DSHADOW = 457,
      F16SAMPLER2DSHADOW = 458,
      F16SAMPLER1DARRAYSHADOW = 459,
      F16SAMPLER2DARRAYSHADOW = 460,
      F16SAMPLER2DRECTSHADOW = 461,
      F16SAMPLERCUBESHADOW = 462,
      F16SAMPLERCUBEARRAYSHADOW = 463,
      IMAGE1D = 464,
      IIMAGE1D = 465,
      UIMAGE1D = 466,
      IMAGE2D = 467,
      IIMAGE2D = 468,
      UIMAGE2D = 469,
      IMAGE3D = 470,
      IIMAGE3D = 471,
      UIMAGE3D = 472,
      IMAGE2DRECT = 473,
      IIMAGE2DRECT = 474,
      UIMAGE2DRECT = 475,
      IMAGECUBE = 476,
      IIMAGECUBE = 477,
      UIMAGECUBE = 478,
      IMAGEBUFFER = 479,
      IIMAGEBUFFER = 480,
      UIMAGEBUFFER = 481,
      IMAGE1DARRAY = 482,
      IIMAGE1DARRAY = 483,
      UIMAGE1DARRAY = 484,
      IMAGE2DARRAY = 485,
      IIMAGE2DARRAY = 486,
      UIMAGE2DARRAY = 487,
      IMAGECUBEARRAY = 488,
      IIMAGECUBEARRAY = 489,
      UIMAGECUBEARRAY = 490,
      IMAGE2DMS = 491,
      IIMAGE2DMS = 492,
      UIMAGE2DMS = 493,
      IMAGE2DMSARRAY = 494,
      IIMAGE2DMSARRAY = 495,
      UIMAGE2DMSARRAY = 496,
      F16IMAGE1D = 497,
      F16IMAGE2D = 498,
      F16IMAGE3D = 499,
      F16IMAGE2DRECT = 500,
      F16IMAGECUBE = 501,
      F16IMAGE1DARRAY = 502,
      F16IMAGE2DARRAY = 503,
      F16IMAGECUBEARRAY = 504,
      F16IMAGEBUFFER = 505,
      F16IMAGE2DMS = 506,
      F16IMAGE2DMSARRAY = 507,
      TEXTURECUBEARRAY = 508,
      ITEXTURECUBEARRAY = 509,
      UTEXTURECUBEARRAY = 510,
      TEXTURE1D = 511,
      ITEXTURE1D = 512,
      UTEXTURE1D = 513,
      TEXTURE1DARRAY = 514,
      ITEXTURE1DARRAY = 515,
      UTEXTURE1DARRAY = 516,
      TEXTURE2DRECT = 517,
      ITEXTURE2DRECT = 518,
      UTEXTURE2DRECT = 519,
      TEXTUREBUFFER = 520,
      ITEXTUREBUFFER = 521,
      UTEXTUREBUFFER = 522,
      TEXTURE2DMS = 523,
      ITEXTURE2DMS = 524,
      UTEXTURE2DMS = 525,
      TEXTURE2DMSARRAY = 526,
      ITEXTURE2DMSARRAY = 527,
      UTEXTURE2DMSARRAY = 528,
      F16TEXTURE1D = 529,
      F16TEXTURE2D = 530,
      F16TEXTURE3D = 531,
      F16TEXTURE2DRECT = 532,
      F16TEXTURECUBE = 533,
      F16TEXTURE1DARRAY = 534,
      F16TEXTURE2DARRAY = 535,
      F16TEXTURECUBEARRAY = 536,
      F16TEXTUREBUFFER = 537,
      F16TEXTURE2DMS = 538,
      F16TEXTURE2DMSARRAY = 539,
      SUBPASSINPUT = 540,
      SUBPASSINPUTMS = 541,
      ISUBPASSINPUT = 542,
      ISUBPASSINPUTMS = 543,
      USUBPASSINPUT = 544,
      USUBPASSINPUTMS = 545,
      F16SUBPASSINPUT = 546,
      F16SUBPASSINPUTMS = 547,
      LEFT_OP = 548,
      RIGHT_OP = 549,
      INC_OP = 550,
      DEC_OP = 551,
      LE_OP = 552,
      GE_OP = 553,
      EQ_OP = 554,
      NE_OP = 555,
      AND_OP = 556,
      OR_OP = 557,
      XOR_OP = 558,
      MUL_ASSIGN = 559,
      DIV_ASSIGN = 560,
      ADD_ASSIGN = 561,
      MOD_ASSIGN = 562,
      LEFT_ASSIGN = 563,
      RIGHT_ASSIGN = 564,
      AND_ASSIGN = 565,
      XOR_ASSIGN = 566,
      OR_ASSIGN = 567,
      SUB_ASSIGN = 568,
      LEFT_PAREN = 569,
      RIGHT_PAREN = 570,
      LEFT_BRACKET = 571,
      RIGHT_BRACKET = 572,
      LEFT_BRACE = 573,
      RIGHT_BRACE = 574,
      DOT = 575,
      COMMA = 576,
      COLON = 577,
      EQUAL = 578,
      SEMICOLON = 579,
      BANG = 580,
      DASH = 581,
      TILDE = 582,
      PLUS = 583,
      STAR = 584,
      SLASH = 585,
      PERCENT = 586,
      LEFT_ANGLE = 587,
      RIGHT_ANGLE = 588,
      VERTICAL_BAR = 589,
      CARET = 590,
      AMPERSAND = 591,
      QUESTION = 592,
      INVARIANT = 593,
      HIGH_PRECISION = 594,
      MEDIUM_PRECISION = 595,
      LOW_PRECISION = 596,
      PRECISION = 597,
      PACKED = 598,
      RESOURCE = 599,
      SUPERP = 600,
      FLOATCONSTANT = 601,
      INTCONSTANT = 602,
      UINTCONSTANT = 603,
      BOOLCONSTANT = 604,
      IDENTIFIER = 605,
      TYPE_NAME = 606,
      CENTROID = 607,
      IN = 608,
      OUT = 609,
      INOUT = 610,
      STRUCT = 611,
      VOID = 612,
      WHILE = 613,
      BREAK = 614,
      CONTINUE = 615,
      DO = 616,
      ELSE = 617,
      FOR = 618,
      IF = 619,
      DISCARD = 620,
      RETURN = 621,
      SWITCH = 622,
      CASE = 623,
      DEFAULT = 624,
      UNIFORM = 625,
      SHARED = 626,
      BUFFER = 627,
      FLAT = 628,
      SMOOTH = 629,
      LAYOUT = 630,
      DOUBLECONSTANT = 631,
      INT16CONSTANT = 632,
      UINT16CONSTANT = 633,
      FLOAT16CONSTANT = 634,
      INT32CONSTANT = 635,
      UINT32CONSTANT = 636,
      INT64CONSTANT = 637,
      UINT64CONSTANT = 638,
      SUBROUTINE = 639,
      DEMOTE = 640,
      PAYLOADNV = 641,
      PAYLOADINNV = 642,
      HITATTRNV = 643,
      CALLDATANV = 644,
      CALLDATAINNV = 645,
      PATCH = 646,
      SAMPLE = 647,
      NONUNIFORM = 648,
      COHERENT = 649,
      VOLATILE = 650,
      RESTRICT = 651,
      READONLY = 652,
      WRITEONLY = 653,
      DEVICECOHERENT = 654,
      QUEUEFAMILYCOHERENT = 655,
      WORKGROUPCOHERENT = 656,
      SUBGROUPCOHERENT = 657,
      NONPRIVATE = 658,
      NOPERSPECTIVE = 659,
      EXPLICITINTERPAMD = 660,
      PERVERTEXNV = 661,
      PERPRIMITIVENV = 662,
      PERVIEWNV = 663,
      PERTASKNV = 664,
      PRECISE = 665
    };
  #endif
  
  /* Value type.  */
  #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
  
  union YYSTYPE
  {
  #line 96 "MachineIndependent/glslang.y" /* yacc.c:355  */
  
      struct {
          glslang::TSourceLoc loc;
          union {
              glslang::TString *string;
              int i;
              unsigned int u;
              long long i64;
              unsigned long long u64;
              bool b;
              double d;
          };
          glslang::TSymbol* symbol;
      } lex;
      struct {
          glslang::TSourceLoc loc;
          glslang::TOperator op;
          union {
              TIntermNode* intermNode;
              glslang::TIntermNodePair nodePair;
              glslang::TIntermTyped* intermTypedNode;
              glslang::TAttributes* attributes;
          };
          union {
              glslang::TPublicType type;
              glslang::TFunction* function;
              glslang::TParameter param;
              glslang::TTypeLoc typeLine;
              glslang::TTypeList* typeList;
              glslang::TArraySizes* arraySizes;
              glslang::TIdentifierList* identifierList;
          };
          glslang::TArraySizes* typeParameters;
      } interm;
  
  #line 579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
  };
  
  typedef union YYSTYPE YYSTYPE;
  # define YYSTYPE_IS_TRIVIAL 1
  # define YYSTYPE_IS_DECLARED 1
  #endif
  
  
  
  int yyparse (glslang::TParseContext* pParseContext);
  
  #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
  
  /* Copy the second part of user declarations.  */
  #line 132 "MachineIndependent/glslang.y" /* yacc.c:358  */
  
  
  /* windows only pragma */
  #ifdef _MSC_VER
      #pragma warning(disable : 4065)
      #pragma warning(disable : 4127)
      #pragma warning(disable : 4244)
  #endif
  
  #define parseContext (*pParseContext)
  #define yyerror(context, msg) context->parserError(msg)
  
  extern int yylex(YYSTYPE*, TParseContext&);
  
  
  #line 610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
  
  #ifdef short
  # undef short
  #endif
  
  #ifdef YYTYPE_UINT8
  typedef YYTYPE_UINT8 yytype_uint8;
  #else
  typedef unsigned char yytype_uint8;
  #endif
  
  #ifdef YYTYPE_INT8
  typedef YYTYPE_INT8 yytype_int8;
  #else
  typedef signed char yytype_int8;
  #endif
  
  #ifdef YYTYPE_UINT16
  typedef YYTYPE_UINT16 yytype_uint16;
  #else
  typedef unsigned short int yytype_uint16;
  #endif
  
  #ifdef YYTYPE_INT16
  typedef YYTYPE_INT16 yytype_int16;
  #else
  typedef short int yytype_int16;
  #endif
  
  #ifndef YYSIZE_T
  # ifdef __SIZE_TYPE__
  #  define YYSIZE_T __SIZE_TYPE__
  # elif defined size_t
  #  define YYSIZE_T size_t
  # elif ! defined YYSIZE_T
  #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
  #  define YYSIZE_T size_t
  # else
  #  define YYSIZE_T unsigned int
  # endif
  #endif
  
  #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
  
  #ifndef YY_
  # if defined YYENABLE_NLS && YYENABLE_NLS
  #  if ENABLE_NLS
  #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
  #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
  #  endif
  # endif
  # ifndef YY_
  #  define YY_(Msgid) Msgid
  # endif
  #endif
  
  #ifndef YY_ATTRIBUTE
  # if (defined __GNUC__                                               \
        && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
       || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
  #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
  # else
  #  define YY_ATTRIBUTE(Spec) /* empty */
  # endif
  #endif
  
  #ifndef YY_ATTRIBUTE_PURE
  # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
  #endif
  
  #ifndef YY_ATTRIBUTE_UNUSED
  # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
  #endif
  
  #if !defined _Noreturn \
       && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
  # if defined _MSC_VER && 1200 <= _MSC_VER
  #  define _Noreturn __declspec (noreturn)
  # else
  #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
  # endif
  #endif
  
  /* Suppress unused-variable warnings by "using" E.  */
  #if ! defined lint || defined __GNUC__
  # define YYUSE(E) ((void) (E))
  #else
  # define YYUSE(E) /* empty */
  #endif
  
  #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
  /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
  # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
      _Pragma ("GCC diagnostic push") \
      _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
      _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
  # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
      _Pragma ("GCC diagnostic pop")
  #else
  # define YY_INITIAL_VALUE(Value) Value
  #endif
  #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  # define YY_IGNORE_MAYBE_UNINITIALIZED_END
  #endif
  #ifndef YY_INITIAL_VALUE
  # define YY_INITIAL_VALUE(Value) /* Nothing. */
  #endif
  
  
  #if ! defined yyoverflow || YYERROR_VERBOSE
  
  /* The parser invokes alloca or malloc; define the necessary symbols.  */
  
  # ifdef YYSTACK_USE_ALLOCA
  #  if YYSTACK_USE_ALLOCA
  #   ifdef __GNUC__
  #    define YYSTACK_ALLOC __builtin_alloca
  #   elif defined __BUILTIN_VA_ARG_INCR
  #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
  #   elif defined _AIX
  #    define YYSTACK_ALLOC __alloca
  #   elif defined _MSC_VER
  #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
  #    define alloca _alloca
  #   else
  #    define YYSTACK_ALLOC alloca
  #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
  #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
        /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
  #     ifndef EXIT_SUCCESS
  #      define EXIT_SUCCESS 0
  #     endif
  #    endif
  #   endif
  #  endif
  # endif
  
  # ifdef YYSTACK_ALLOC
     /* Pacify GCC's 'empty if-body' warning.  */
  #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  #  ifndef YYSTACK_ALLOC_MAXIMUM
      /* The OS might guarantee only one guard page at the bottom of the stack,
         and a page size can be as small as 4096 bytes.  So we cannot safely
         invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
         to allow for a few compiler-allocated temporary stack slots.  */
  #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
  #  endif
  # else
  #  define YYSTACK_ALLOC YYMALLOC
  #  define YYSTACK_FREE YYFREE
  #  ifndef YYSTACK_ALLOC_MAXIMUM
  #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
  #  endif
  #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
         && ! ((defined YYMALLOC || defined malloc) \
               && (defined YYFREE || defined free)))
  #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  #   ifndef EXIT_SUCCESS
  #    define EXIT_SUCCESS 0
  #   endif
  #  endif
  #  ifndef YYMALLOC
  #   define YYMALLOC malloc
  #   if ! defined malloc && ! defined EXIT_SUCCESS
  void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
  #   endif
  #  endif
  #  ifndef YYFREE
  #   define YYFREE free
  #   if ! defined free && ! defined EXIT_SUCCESS
  void free (void *); /* INFRINGES ON USER NAME SPACE */
  #   endif
  #  endif
  # endif
  #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
  
  
  #if (! defined yyoverflow \
       && (! defined __cplusplus \
           || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
  
  /* A type that is properly aligned for any stack member.  */
  union yyalloc
  {
    yytype_int16 yyss_alloc;
    YYSTYPE yyvs_alloc;
  };
  
  /* The size of the maximum gap between one aligned stack and the next.  */
  # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
  
  /* The size of an array large to enough to hold all stacks, each with
     N elements.  */
  # define YYSTACK_BYTES(N) \
       ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
        + YYSTACK_GAP_MAXIMUM)
  
  # define YYCOPY_NEEDED 1
  
  /* Relocate STACK from its old location to the new one.  The
     local variables YYSIZE and YYSTACKSIZE give the old and new number of
     elements in the stack, and YYPTR gives the new location of the
     stack.  Advance YYPTR to a properly aligned location for the next
     stack.  */
  # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
      do                                                                  \
        {                                                                 \
          YYSIZE_T yynewbytes;                                            \
          YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
          Stack = &yyptr->Stack_alloc;                                    \
          yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
          yyptr += yynewbytes / sizeof (*yyptr);                          \
        }                                                                 \
      while (0)
  
  #endif
  
  #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
  /* Copy COUNT objects from SRC to DST.  The source and destination do
     not overlap.  */
  # ifndef YYCOPY
  #  if defined __GNUC__ && 1 < __GNUC__
  #   define YYCOPY(Dst, Src, Count) \
        __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
  #  else
  #   define YYCOPY(Dst, Src, Count)              \
        do                                        \
          {                                       \
            YYSIZE_T yyi;                         \
            for (yyi = 0; yyi < (Count); yyi++)   \
              (Dst)[yyi] = (Src)[yyi];            \
          }                                       \
        while (0)
  #  endif
  # endif
  #endif /* !YYCOPY_NEEDED */
  
  /* YYFINAL -- State number of the termination state.  */
  #define YYFINAL  386
  /* YYLAST -- Last index in YYTABLE.  */
  #define YYLAST   9369
  
  /* YYNTOKENS -- Number of terminals.  */
  #define YYNTOKENS  411
  /* YYNNTS -- Number of nonterminals.  */
  #define YYNNTS  111
  /* YYNRULES -- Number of rules.  */
  #define YYNRULES  582
  /* YYNSTATES -- Number of states.  */
  #define YYNSTATES  727
  
  /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
     by yylex, with out-of-bounds checking.  */
  #define YYUNDEFTOK  2
  #define YYMAXUTOK   665
  
  #define YYTRANSLATE(YYX)                                                \
    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
  
  /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
     as returned by yylex, without out-of-bounds checking.  */
  static const yytype_uint16 yytranslate[] =
  {
         0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
         2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
         5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
        15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
        25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
        35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
        45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
        55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
        65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
        75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
        85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
        95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
       105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
       115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
       125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
       135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
       145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
       155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
       165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
       175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
       185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
       195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
       205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
       215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
       225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
       235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
       245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
       255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
       275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
       285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
       295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
       305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
       315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
       325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
       335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
       345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
       355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
       365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
       375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
       385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
       395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
       405,   406,   407,   408,   409,   410
  };
  
  #if YYDEBUG
    /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
  static const yytype_uint16 yyrline[] =
  {
         0,   352,   352,   358,   361,   366,   369,   372,   376,   380,
       384,   388,   392,   396,   400,   404,   408,   416,   419,   422,
       425,   428,   433,   441,   448,   455,   461,   465,   472,   475,
       481,   488,   498,   506,   511,   539,   548,   554,   558,   562,
       582,   583,   584,   585,   591,   592,   597,   602,   611,   612,
       617,   625,   626,   632,   641,   642,   647,   652,   657,   665,
       666,   675,   687,   688,   697,   698,   707,   708,   717,   718,
       726,   727,   735,   736,   744,   745,   745,   763,   764,   780,
       784,   788,   792,   797,   801,   805,   809,   813,   817,   821,
       828,   831,   842,   849,   854,   859,   866,   870,   874,   878,
       883,   888,   897,   897,   908,   912,   919,   926,   929,   936,
       944,   964,   987,  1002,  1027,  1038,  1048,  1058,  1068,  1077,
      1080,  1084,  1088,  1093,  1101,  1108,  1113,  1118,  1123,  1132,
      1142,  1169,  1178,  1185,  1193,  1200,  1207,  1215,  1225,  1232,
      1243,  1249,  1252,  1259,  1263,  1267,  1276,  1286,  1289,  1300,
      1303,  1306,  1310,  1314,  1319,  1323,  1330,  1334,  1339,  1345,
      1351,  1358,  1363,  1371,  1377,  1389,  1403,  1409,  1414,  1422,
      1430,  1438,  1446,  1453,  1457,  1462,  1467,  1472,  1477,  1482,
      1486,  1490,  1494,  1498,  1504,  1515,  1522,  1525,  1534,  1539,
      1549,  1554,  1562,  1566,  1576,  1579,  1585,  1591,  1598,  1608,
      1612,  1616,  1620,  1625,  1629,  1634,  1639,  1644,  1649,  1654,
      1659,  1664,  1669,  1674,  1680,  1686,  1692,  1697,  1702,  1707,
      1712,  1717,  1722,  1727,  1732,  1737,  1742,  1747,  1753,  1758,
      1763,  1768,  1773,  1778,  1783,  1788,  1793,  1798,  1803,  1808,
      1813,  1819,  1825,  1831,  1837,  1843,  1849,  1855,  1861,  1867,
      1873,  1879,  1885,  1891,  1897,  1903,  1909,  1915,  1921,  1927,
      1933,  1939,  1945,  1951,  1957,  1963,  1969,  1975,  1981,  1987,
      1993,  1999,  2005,  2011,  2017,  2023,  2029,  2035,  2041,  2047,
      2053,  2059,  2065,  2071,  2077,  2083,  2089,  2095,  2101,  2107,
      2113,  2119,  2125,  2131,  2137,  2143,  2149,  2155,  2161,  2167,
      2173,  2179,  2185,  2191,  2197,  2203,  2209,  2215,  2221,  2227,
      2233,  2239,  2245,  2251,  2257,  2263,  2269,  2275,  2281,  2287,
      2293,  2299,  2305,  2311,  2317,  2321,  2326,  2332,  2337,  2342,
      2347,  2352,  2357,  2362,  2368,  2373,  2378,  2383,  2388,  2393,
      2399,  2405,  2411,  2417,  2423,  2429,  2435,  2441,  2447,  2453,
      2459,  2465,  2471,  2477,  2482,  2487,  2492,  2497,  2502,  2507,
      2513,  2518,  2523,  2528,  2533,  2538,  2543,  2548,  2554,  2559,
      2564,  2569,  2574,  2579,  2584,  2589,  2594,  2599,  2604,  2609,
      2614,  2619,  2624,  2630,  2635,  2640,  2646,  2652,  2657,  2662,
      2667,  2673,  2678,  2683,  2688,  2694,  2699,  2704,  2709,  2715,
      2720,  2725,  2730,  2736,  2742,  2748,  2754,  2759,  2765,  2771,
      2777,  2782,  2787,  2792,  2797,  2802,  2808,  2813,  2818,  2823,
      2829,  2834,  2839,  2844,  2850,  2855,  2860,  2865,  2871,  2876,
      2881,  2886,  2892,  2897,  2902,  2907,  2913,  2918,  2923,  2928,
      2934,  2939,  2944,  2949,  2955,  2960,  2965,  2970,  2976,  2981,
      2986,  2991,  2997,  3002,  3007,  3012,  3018,  3023,  3028,  3033,
      3039,  3044,  3049,  3054,  3060,  3065,  3070,  3075,  3081,  3086,
      3091,  3096,  3102,  3107,  3112,  3118,  3124,  3130,  3136,  3143,
      3150,  3156,  3162,  3168,  3174,  3180,  3186,  3193,  3198,  3214,
      3219,  3224,  3232,  3232,  3243,  3243,  3253,  3256,  3269,  3291,
      3318,  3322,  3328,  3333,  3344,  3348,  3354,  3365,  3368,  3375,
      3379,  3380,  3386,  3387,  3388,  3389,  3390,  3391,  3392,  3394,
      3400,  3409,  3410,  3414,  3410,  3426,  3427,  3431,  3431,  3438,
      3438,  3452,  3455,  3463,  3471,  3482,  3483,  3487,  3491,  3498,
      3505,  3509,  3517,  3521,  3534,  3538,  3545,  3545,  3565,  3568,
      3574,  3586,  3598,  3602,  3609,  3609,  3624,  3624,  3640,  3640,
      3661,  3664,  3670,  3673,  3679,  3683,  3690,  3695,  3700,  3707,
      3710,  3719,  3723,  3732,  3735,  3739,  3748,  3748,  3771,  3777,
      3780,  3785,  3788
  };
  #endif
  
  #if YYDEBUG || YYERROR_VERBOSE || 1
  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
     First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
  static const char *const yytname[] =
  {
    "$end", "error", "$undefined", "CONST", "BOOL", "INT", "UINT", "FLOAT",
    "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", "UVEC2", "UVEC3",
    "UVEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "MAT2X2",
    "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3",
    "MAT4X4", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER2DSHADOW",
    "SAMPLERCUBESHADOW", "SAMPLER2DARRAY", "SAMPLER2DARRAYSHADOW",
    "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE", "ISAMPLER2DARRAY",
    "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER2DARRAY", "SAMPLER",
    "SAMPLERSHADOW", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE",
    "TEXTURE2DARRAY", "ITEXTURE2D", "ITEXTURE3D", "ITEXTURECUBE",
    "ITEXTURE2DARRAY", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE",
    "UTEXTURE2DARRAY", "ATTRIBUTE", "VARYING", "FLOAT16_T", "FLOAT32_T",
    "DOUBLE", "FLOAT64_T", "INT64_T", "UINT64_T", "INT32_T", "UINT32_T",
    "INT16_T", "UINT16_T", "INT8_T", "UINT8_T", "I64VEC2", "I64VEC3",
    "I64VEC4", "U64VEC2", "U64VEC3", "U64VEC4", "I32VEC2", "I32VEC3",
    "I32VEC4", "U32VEC2", "U32VEC3", "U32VEC4", "I16VEC2", "I16VEC3",
    "I16VEC4", "U16VEC2", "U16VEC3", "U16VEC4", "I8VEC2", "I8VEC3", "I8VEC4",
    "U8VEC2", "U8VEC3", "U8VEC4", "DVEC2", "DVEC3", "DVEC4", "DMAT2",
    "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", "F16MAT2", "F16MAT3",
    "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4", "F32MAT2", "F32MAT3",
    "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4", "F64MAT2", "F64MAT3",
    "F64MAT4", "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3",
    "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", "F16MAT2X2", "F16MAT2X3",
    "F16MAT2X4", "F16MAT3X2", "F16MAT3X3", "F16MAT3X4", "F16MAT4X2",
    "F16MAT4X3", "F16MAT4X4", "F32MAT2X2", "F32MAT2X3", "F32MAT2X4",
    "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3",
    "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2",
    "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4",
    "ATOMIC_UINT", "ACCSTRUCTNV", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV",
    "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY",
    "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY",
    "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT",
    "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT",
    "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS",
    "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY",
    "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT",
    "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D",
    "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
    "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY",
    "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY",
    "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
    "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW",
    "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "IMAGE1D",
    "IIMAGE1D", "UIMAGE1D", "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D",
    "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", "IIMAGE2DRECT", "UIMAGE2DRECT",
    "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", "IMAGEBUFFER", "IIMAGEBUFFER",
    "UIMAGEBUFFER", "IMAGE1DARRAY", "IIMAGE1DARRAY", "UIMAGE1DARRAY",
    "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBEARRAY",
    "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS",
    "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY",
    "F16IMAGE1D", "F16IMAGE2D", "F16IMAGE3D", "F16IMAGE2DRECT",
    "F16IMAGECUBE", "F16IMAGE1DARRAY", "F16IMAGE2DARRAY",
    "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS",
    "F16IMAGE2DMSARRAY", "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY",
    "UTEXTURECUBEARRAY", "TEXTURE1D", "ITEXTURE1D", "UTEXTURE1D",
    "TEXTURE1DARRAY", "ITEXTURE1DARRAY", "UTEXTURE1DARRAY", "TEXTURE2DRECT",
    "ITEXTURE2DRECT", "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER",
    "UTEXTUREBUFFER", "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS",
    "TEXTURE2DMSARRAY", "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY",
    "F16TEXTURE1D", "F16TEXTURE2D", "F16TEXTURE3D", "F16TEXTURE2DRECT",
    "F16TEXTURECUBE", "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY",
    "F16TEXTURECUBEARRAY", "F16TEXTUREBUFFER", "F16TEXTURE2DMS",
    "F16TEXTURE2DMSARRAY", "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT",
    "ISUBPASSINPUTMS", "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT",
    "F16SUBPASSINPUTMS", "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", "HIGH_PRECISION", "MEDIUM_PRECISION", "LOW_PRECISION",
    "PRECISION", "PACKED", "RESOURCE", "SUPERP", "FLOATCONSTANT",
    "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT", "IDENTIFIER", "TYPE_NAME",
    "CENTROID", "IN", "OUT", "INOUT", "STRUCT", "VOID", "WHILE", "BREAK",
    "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN", "SWITCH",
    "CASE", "DEFAULT", "UNIFORM", "SHARED", "BUFFER", "FLAT", "SMOOTH",
    "LAYOUT", "DOUBLECONSTANT", "INT16CONSTANT", "UINT16CONSTANT",
    "FLOAT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INT64CONSTANT",
    "UINT64CONSTANT", "SUBROUTINE", "DEMOTE", "PAYLOADNV", "PAYLOADINNV",
    "HITATTRNV", "CALLDATANV", "CALLDATAINNV", "PATCH", "SAMPLE",
    "NONUNIFORM", "COHERENT", "VOLATILE", "RESTRICT", "READONLY",
    "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT",
    "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", "NOPERSPECTIVE",
    "EXPLICITINTERPAMD", "PERVERTEXNV", "PERPRIMITIVENV", "PERVIEWNV",
    "PERTASKNV", "PRECISE", "$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",
    "relational_expression", "equality_expression", "and_expression",
    "exclusive_or_expression", "inclusive_or_expression",
    "logical_and_expression", "logical_xor_expression",
    "logical_or_expression", "conditional_expression", "$@1",
    "assignment_expression", "assignment_operator", "expression",
    "constant_expression", "declaration", "block_structure", "$@2",
    "identifier_list", "function_prototype", "function_declarator",
    "function_header_with_parameters", "function_header",
    "parameter_declarator", "parameter_declaration",
    "parameter_type_specifier", "init_declarator_list", "single_declaration",
    "fully_specified_type", "invariant_qualifier", "interpolation_qualifier",
    "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id",
    "precise_qualifier", "type_qualifier", "single_type_qualifier",
    "storage_qualifier", "non_uniform_qualifier", "type_name_list",
    "type_specifier", "array_specifier", "type_parameter_specifier_opt",
    "type_parameter_specifier", "type_parameter_specifier_list",
    "type_specifier_nonarray", "precision_qualifier", "struct_specifier",
    "$@3", "$@4", "struct_declaration_list", "struct_declaration",
    "struct_declarator_list", "struct_declarator", "initializer",
    "initializer_list", "declaration_statement", "statement",
    "simple_statement", "demote_statement", "compound_statement", "$@5",
    "$@6", "statement_no_new_scope", "statement_scoped", "$@7", "$@8",
    "compound_statement_no_new_scope", "statement_list",
    "expression_statement", "selection_statement",
    "selection_statement_nonattributed", "selection_rest_statement",
    "condition", "switch_statement", "switch_statement_nonattributed", "$@9",
    "switch_statement_list", "case_label", "iteration_statement",
    "iteration_statement_nonattributed", "$@10", "$@11", "$@12",
    "for_init_statement", "conditionopt", "for_rest_statement",
    "jump_statement", "translation_unit", "external_declaration",
    "function_definition", "$@13", "attribute", "attribute_list",
    "single_attribute", YY_NULLPTR
  };
  #endif
  
  # ifdef YYPRINT
  /* YYTOKNUM[NUM] -- (External) token number corresponding to the
     (internal) symbol number NUM (which must be that of a token).  */
  static const yytype_uint16 yytoknum[] =
  {
         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
       275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
       285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
       295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
       305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
       315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
       325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
       335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
       345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
       355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
       365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
       375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
       385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
       395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
       405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
       415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
       425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
       435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
       445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
       455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
       465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
       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,
       515,   516,   517,   518,   519,   520,   521,   522,   523,   524,
       525,   526,   527,   528,   529,   530,   531,   532,   533,   534,
       535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
       545,   546,   547,   548,   549,   550,   551,   552,   553,   554,
       555,   556,   557,   558,   559,   560,   561,   562,   563,   564,
       565,   566,   567,   568,   569,   570,   571,   572,   573,   574,
       575,   576,   577,   578,   579,   580,   581,   582,   583,   584,
       585,   586,   587,   588,   589,   590,   591,   592,   593,   594,
       595,   596,   597,   598,   599,   600,   601,   602,   603,   604,
       605,   606,   607,   608,   609,   610,   611,   612,   613,   614,
       615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
       625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
       635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
       645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
       655,   656,   657,   658,   659,   660,   661,   662,   663,   664,
       665
  };
  # endif
  
  #define YYPACT_NINF -453
  
  #define yypact_value_is_default(Yystate) \
    (!!((Yystate) == (-453)))
  
  #define YYTABLE_NINF -528
  
  #define yytable_value_is_error(Yytable_value) \
    0
  
    /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
       STATE-NUM.  */
  static const yytype_int16 yypact[] =
  {
      3994,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,    97,  -453,  -453,  -453,
      -453,  -453,     6,  -453,  -453,  -453,  -453,  -453,  -453,  -307,
      -241,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,    -3,    95,    36,
       125,  6034,    82,  -453,   -22,  -453,  -453,  -453,  -453,  4402,
      -453,  -453,  -453,  -453,   131,  -453,  -453,   730,  -453,  -453,
        11,  -453,   153,   -28,   127,  -453,     7,  -453,   157,  -453,
      6034,  -453,  -453,  -453,  6034,   129,   134,  -453,    13,  -453,
        73,  -453,  -453,  8391,   162,  -453,  -453,  -453,   161,  6034,
      -453,   163,  -453,  -309,  -453,  -453,    27,  6831,  -453,    16,
      1138,  -453,  -453,  -453,  -453,   162,    23,  -453,  7221,    49,
      -453,   138,  -453,    87,  8391,  8391,  8391,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,    68,  -453,  -453,  -453,
       174,    60,  8781,   176,  -453,  8391,  -453,  -453,  -320,   175,
      -453,  6034,   142,  4810,  -453,  6034,  8391,  -453,   -28,  -453,
       143,  -453,  -453,   119,   128,    32,    21,    38,   158,   160,
       165,   195,   194,    18,   183,  7611,  -453,   185,   184,  -453,
      -453,   188,   180,   181,  -453,   196,   197,   190,  8001,   198,
      8391,   187,   193,   122,  -453,  -453,    91,  -453,    95,   204,
       205,  -453,  -453,  -453,  -453,  -453,  1546,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  -453,  -353,   175,  7221,    69,
      7221,  -453,  -453,  7221,  6034,  -453,   170,  -453,  -453,  -453,
        78,  -453,  -453,  8391,   171,  -453,  -453,  8391,   207,  -453,
      -453,  -453,  8391,  -453,   142,   162,    93,  -453,  -453,  -453,
      5218,  -453,  -453,  -453,  -453,  8391,  8391,  8391,  8391,  8391,
      8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,
      8391,  8391,  8391,  8391,  -453,  -453,  -453,   206,   177,  -453,
      1954,  -453,  -453,  -453,  1954,  -453,  8391,  -453,  -453,   100,
      8391,   144,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,  8391,  8391,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  7221,  -453,   140,  -453,  5626,  -453,
      -453,   209,   208,  -453,  -453,  -453,   123,   175,   142,  -453,
      -453,  -453,  -453,  -453,   119,   119,   128,   128,    32,    32,
        32,    32,    21,    21,    38,   158,   160,   165,   195,   194,
      8391,  -453,   214,    56,  -453,  1954,  3586,   172,  3178,    80,
      -453,    81,  -453,  -453,  -453,  -453,  -453,  6441,  -453,  -453,
      -453,  -453,   146,  8391,   215,   177,   212,   208,   186,  6034,
       219,   221,  -453,  -453,  3586,   220,  -453,  -453,  -453,  8391,
       222,  -453,  -453,  -453,   216,  2362,  8391,  -453,   217,   227,
       182,   225,  2770,  -453,   229,  -453,  -453,  7221,  -453,  -453,
      -453,    89,  8391,  2362,   220,  -453,  -453,  1954,  -453,   224,
       208,  -453,  -453,  1954,   226,  -453,  -453
  };
  
    /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
       Performed when YYTABLE does not specify something else to do.  Zero
       means the default is an error.  */
  static const yytype_uint16 yydefact[] =
  {
         0,   156,   203,   201,   202,   200,   207,   208,   209,   210,
       211,   212,   213,   214,   215,   204,   205,   206,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       327,   328,   329,   330,   331,   332,   333,   353,   354,   355,
       356,   357,   358,   359,   368,   381,   382,   369,   370,   372,
       371,   373,   374,   375,   376,   377,   378,   379,   380,   164,
       165,   229,   230,   228,   231,   238,   239,   236,   237,   234,
       235,   232,   233,   261,   262,   263,   273,   274,   275,   258,
       259,   260,   270,   271,   272,   255,   256,   257,   267,   268,
       269,   252,   253,   254,   264,   265,   266,   240,   241,   242,
       276,   277,   278,   243,   244,   245,   288,   289,   290,   246,
       247,   248,   300,   301,   302,   249,   250,   251,   312,   313,
       314,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       291,   292,   293,   294,   295,   296,   297,   298,   299,   303,
       304,   305,   306,   307,   308,   309,   310,   311,   315,   316,
       317,   318,   319,   320,   321,   322,   323,   325,   324,   484,
       485,   486,   337,   338,   361,   364,   326,   335,   336,   352,
       334,   383,   384,   387,   388,   389,   391,   392,   393,   395,
       396,   397,   399,   400,   474,   475,   360,   362,   363,   339,
       340,   341,   385,   342,   346,   347,   350,   390,   394,   398,
       343,   344,   348,   349,   386,   345,   351,   430,   432,   433,
       434,   436,   437,   438,   440,   441,   442,   444,   445,   446,
       448,   449,   450,   452,   453,   454,   456,   457,   458,   460,
       461,   462,   464,   465,   466,   468,   469,   470,   472,   473,
       431,   435,   439,   443,   447,   455,   459,   463,   451,   467,
       471,   365,   366,   367,   401,   410,   412,   406,   411,   413,
       414,   416,   417,   418,   420,   421,   422,   424,   425,   426,
       428,   429,   402,   403,   404,   415,   405,   407,   408,   409,
       419,   423,   427,   476,   477,   480,   481,   482,   483,   478,
       479,   575,   131,   489,   490,   491,     0,   488,   160,   158,
       159,   157,     0,   199,   161,   162,   163,   133,   132,     0,
       183,   169,   170,   168,   171,   172,   166,   167,   185,   173,
       179,   180,   181,   182,   174,   175,   176,   177,   178,   134,
       135,   136,   137,   138,   139,   146,   574,     0,   576,     0,
       108,   107,     0,   119,   124,   153,   152,   150,   154,     0,
       147,   149,   155,   129,   195,   151,   487,     0,   571,   573,
         0,   494,     0,     0,     0,    96,     0,    93,     0,   106,
         0,   115,   109,   117,     0,   118,     0,    94,   125,    99,
         0,   148,   130,     0,   188,   194,     1,   572,     0,     0,
       492,   143,   145,     0,   141,   186,     0,     0,    97,     0,
         0,   577,   110,   114,   116,   112,   120,   111,     0,   126,
       102,     0,   100,     0,     0,     0,     0,    42,    41,    43,
        40,     5,     6,     7,     8,     2,    15,    13,    14,    16,
         9,    10,    11,    12,     3,    17,    36,    19,    24,    25,
         0,     0,    29,     0,   197,     0,    35,    33,     0,   189,
        95,     0,     0,     0,   496,     0,     0,   140,     0,   184,
         0,   190,    44,    48,    51,    54,    59,    62,    64,    66,
        68,    70,    72,    74,     0,     0,    98,     0,   522,   531,
       535,     0,     0,     0,   556,     0,     0,     0,     0,     0,
         0,     0,     0,    44,    77,    90,     0,   509,     0,   155,
       129,   512,   533,   511,   519,   510,     0,   513,   514,   537,
       515,   544,   516,   517,   552,   518,     0,   113,     0,   121,
         0,   504,   128,     0,     0,   104,     0,   101,    37,    38,
         0,    21,    22,     0,     0,    27,    26,     0,   199,    30,
        32,    39,     0,   196,     0,   502,     0,   500,   495,   497,
         0,    92,   144,   142,   187,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,    75,   191,   192,     0,     0,   521,
         0,   554,   567,   566,     0,   558,     0,   570,   568,     0,
         0,     0,   551,   520,    80,    81,    83,    82,    85,    86,
        87,    88,    89,    84,    79,     0,     0,   536,   532,   534,
       538,   545,   553,   123,     0,   507,     0,   127,     0,   105,
         4,     0,    23,    20,    31,   198,     0,   503,     0,   498,
       493,    45,    46,    47,    50,    49,    52,    53,    57,    58,
        55,    56,    60,    61,    63,    65,    67,    69,    71,    73,
         0,   193,   581,     0,   579,   523,     0,     0,     0,     0,
       569,     0,   550,    78,    91,   122,   505,     0,   103,    18,
       499,   501,     0,     0,     0,     0,     0,   542,     0,     0,
         0,     0,   561,   560,   563,   529,   546,   506,   508,     0,
         0,   578,   580,   524,     0,     0,     0,   562,     0,     0,
       541,     0,     0,   539,     0,    76,   582,     0,   526,   555,
       525,     0,   564,     0,   529,   528,   530,   548,   543,     0,
       565,   559,   540,   549,     0,   557,   547
  };
  
    /* YYPGOTO[NTERM-NUM].  */
  static const yytype_int16 yypgoto[] =
  {
      -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
      -453,  -453,  8696,  -453,   -89,   -88,  -122,   -84,   -19,   -18,
       -17,   -16,   -20,   -15,  -453,   -85,  -453,   -98,  -453,  -110,
      -119,     2,  -453,  -453,  -453,     4,  -453,  -453,  -453,   189,
       191,   192,  -453,  -453,  -339,  -453,  -453,  -453,  -453,    98,
      -453,   -37,   -44,  -453,     9,  -453,     0,   -71,  -453,  -453,
      -453,  -453,   261,  -453,  -453,  -453,  -452,  -137,    20,   -68,
      -209,  -453,   -96,  -198,  -326,  -453,  -136,  -453,  -453,  -146,
      -144,  -453,  -453,   200,  -265,   -87,  -453,    57,  -453,  -112,
      -453,    59,  -453,  -453,  -453,  -453,    61,  -453,  -453,  -453,
      -453,  -453,  -453,  -453,  -453,   228,  -453,  -453,  -453,  -453,
       -99
  };
  
    /* YYDEFGOTO[NTERM-NUM].  */
  static const yytype_int16 yydefgoto[] =
  {
        -1,   434,   435,   436,   621,   437,   438,   439,   440,   441,
       442,   443,   493,   445,   463,   464,   465,   466,   467,   468,
       469,   470,   471,   472,   473,   494,   650,   495,   605,   496,
       552,   497,   337,   524,   413,   498,   339,   340,   341,   371,
       372,   373,   342,   343,   344,   345,   346,   347,   393,   394,
       348,   349,   350,   351,   446,   396,   447,   399,   384,   385,
       448,   354,   355,   356,   455,   389,   453,   454,   546,   547,
       522,   616,   501,   502,   503,   504,   505,   580,   676,   709,
       700,   701,   702,   710,   506,   507,   508,   509,   703,   680,
       510,   511,   704,   724,   512,   513,   514,   656,   584,   658,
       684,   698,   699,   515,   357,   358,   359,   368,   516,   653,
       654
  };
  
    /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
       positive, shift that token.  If negative, reduce the rule whose
       number is the opposite.  If YYTABLE_NINF, syntax error.  */
  static const yytype_int16 yytable[] =
  {
       353,   542,   336,   550,   338,   481,   457,   363,   484,   352,
       485,   486,   458,   543,   489,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,   618,   364,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,   374,   381,   530,   409,   609,   613,
       521,   615,   474,   449,   617,   655,   549,   678,   562,   563,
       573,   365,   391,   397,   361,   560,   561,   407,   378,   397,
       381,   398,   475,   374,   517,   519,   408,   566,   567,   397,
       476,   375,   459,   392,   539,   678,   518,   366,   460,   382,
       352,   369,   451,   564,   565,   574,   362,   353,   352,   336,
       388,   338,   297,   531,   532,   475,   352,   302,   303,   708,
       375,   551,   523,   674,   375,   536,   716,   675,   589,   352,
       591,   537,   -34,   352,   533,   475,   657,   708,   534,   452,
       577,   410,   614,   620,   411,   685,   686,   412,   352,   606,
       500,   606,   606,   376,   719,   665,   377,   381,   526,   499,
       606,   527,   606,   549,   628,   607,   451,   629,   451,   367,
       521,   606,   521,   622,   660,   521,   594,   595,   596,   597,
       598,   599,   600,   601,   602,   603,   293,   294,   295,   624,
       638,   639,   640,   641,   628,   604,   370,   670,   555,   556,
       557,   544,   723,   452,   558,   452,   559,   609,   688,   666,
       352,   667,   352,   383,   352,   606,   662,   606,   689,   634,
       635,   390,   636,   637,   627,   400,   659,   395,   397,   405,
       661,   549,   642,   643,   406,   450,   456,   451,   525,   535,
       540,   475,   545,   554,   568,   569,   571,   572,   718,   570,
       575,   578,   581,   579,   582,   583,   500,   663,   664,   592,
       585,   586,   590,   451,   587,   499,   521,   593,   -35,   -33,
       619,   623,   -28,   651,   452,   609,   669,   652,   673,   606,
       681,   693,   691,   352,   695,   696,   694,   706,  -527,   707,
       672,   712,   713,   478,   714,   726,   677,   717,   725,   644,
       452,   645,   648,   646,   690,   647,   553,   360,   649,   352,
       671,   402,   682,   403,   626,   715,   404,   721,   401,   521,
       722,   683,   697,   610,   677,   611,   692,   612,     0,     0,
       500,   451,     0,     0,   500,   387,   711,     0,   551,   499,
         0,   705,     0,   499,     0,     0,     0,     0,     0,     0,
         0,     0,   720,     0,     0,     0,     0,     0,     0,   521,
         0,     0,     0,     0,     0,     0,     0,     0,   452,   679,
         0,     0,     0,     0,     0,     0,     0,   352,     0,     0,
         0,     0,     0,     0,     0,   381,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   679,     0,     0,
         0,     0,     0,     0,     0,   500,   500,     0,   500,     0,
         0,     0,     0,     0,   499,   499,     0,   499,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,   382,
         0,     0,     0,     0,   500,     0,     0,     0,   352,     0,
         0,     0,     0,   499,     0,   500,     0,     0,     0,     0,
         0,     0,   500,     0,   499,     0,     0,     0,     0,     0,
         0,   499,     0,   500,     0,     0,     0,   500,     0,     0,
         0,     0,   499,   500,     0,     0,   499,     0,     0,     0,
       386,     0,   499,     1,     2,     3,     4,     5,     6,     7,
         8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
        18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
        28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
        38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
        48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
        58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
        68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
        78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
        88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
        98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
       108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
       118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
       128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
       138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
       148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
       158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
       178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
       198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
       238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
       248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
       258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
       268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
       278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       288,   289,   290,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   291,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
       294,   295,   296,     0,     0,     0,     0,     0,     0,     0,
         0,   297,   298,   299,   300,   301,   302,   303,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       304,   305,   306,   307,   308,   309,     0,     0,     0,     0,
         0,     0,     0,     0,   310,     0,   311,   312,   313,   314,
       315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
       325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
       335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,     0,     0,   414,   415,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   416,     0,   477,     0,   478,   479,     0,     0,
         0,     0,   480,   417,   418,   419,   420,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
       296,     0,     0,     0,   421,   422,   423,   424,   425,   297,
       298,   299,   300,   301,   302,   303,   481,   482,   483,   484,
         0,   485,   486,   487,   488,   489,   490,   491,   304,   305,
       306,   307,   308,   309,   426,   427,   428,   429,   430,   431,
       432,   433,   310,   492,   311,   312,   313,   314,   315,   316,
       317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
       327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
         2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
         0,   414,   415,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       416,     0,   477,     0,   478,   608,     0,     0,     0,     0,
       480,   417,   418,   419,   420,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   292,   293,   294,   295,   296,     0,
         0,     0,   421,   422,   423,   424,   425,   297,   298,   299,
       300,   301,   302,   303,   481,   482,   483,   484,     0,   485,
       486,   487,   488,   489,   490,   491,   304,   305,   306,   307,
       308,   309,   426,   427,   428,   429,   430,   431,   432,   433,
       310,   492,   311,   312,   313,   314,   315,   316,   317,   318,
       319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
       329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,     0,     0,   414,
       415,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   416,     0,
       477,     0,   478,     0,     0,     0,     0,     0,   480,   417,
       418,   419,   420,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   292,   293,   294,   295,   296,     0,     0,     0,
       421,   422,   423,   424,   425,   297,   298,   299,   300,   301,
       302,   303,   481,   482,   483,   484,     0,   485,   486,   487,
       488,   489,   490,   491,   304,   305,   306,   307,   308,   309,
       426,   427,   428,   429,   430,   431,   432,   433,   310,   492,
       311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
       321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
       331,   332,   333,   334,   335,     1,     2,     3,     4,     5,
         6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
        26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
        36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
        56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
        66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
        76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
        86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
        96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
       106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
       116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
       126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
       136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
       146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
       156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
       166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
       176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
       196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
       206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
       216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
       226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
       236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
       246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
       256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
       266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
       276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
       286,   287,   288,   289,   290,     0,     0,   414,   415,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   416,     0,   477,     0,
       400,     0,     0,     0,     0,     0,   480,   417,   418,   419,
       420,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       292,   293,   294,   295,   296,     0,     0,     0,   421,   422,
       423,   424,   425,   297,   298,   299,   300,   301,   302,   303,
       481,   482,   483,   484,     0,   485,   486,   487,   488,   489,
       490,   491,   304,   305,   306,   307,   308,   309,   426,   427,
       428,   429,   430,   431,   432,   433,   310,   492,   311,   312,
       313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
       323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
       333,   334,   335,     1,     2,     3,     4,     5,     6,     7,
         8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
        18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
        28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
        38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
        48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
        58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
        68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
        78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
        88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
        98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
       108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
       118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
       128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
       138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
       148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
       158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
       178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
       198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
       238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
       248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
       258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
       268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
       278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       288,   289,   290,     0,     0,   414,   415,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   416,     0,   477,     0,     0,     0,
         0,     0,     0,     0,   480,   417,   418,   419,   420,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
       294,   295,   296,     0,     0,     0,   421,   422,   423,   424,
       425,   297,   298,   299,   300,   301,   302,   303,   481,   482,
       483,   484,     0,   485,   486,   487,   488,   489,   490,   491,
       304,   305,   306,   307,   308,   309,   426,   427,   428,   429,
       430,   431,   432,   433,   310,   492,   311,   312,   313,   314,
       315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
       325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
       335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,     0,     0,   414,   415,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   416,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   480,   417,   418,   419,   420,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
       296,     0,     0,     0,   421,   422,   423,   424,   425,   297,
       298,   299,   300,   301,   302,   303,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   304,   305,
       306,   307,   308,   309,   426,   427,   428,   429,   430,   431,
       432,   433,   310,     0,   311,   312,   313,   314,   315,   316,
       317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
       327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
         2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
         0,   414,   415,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       416,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,   417,   418,   419,   420,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   292,   293,   294,   295,     0,     0,
         0,     0,   421,   422,   423,   424,   425,   297,   298,   299,
       300,   301,   302,   303,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   304,   305,   306,   307,
       308,   309,   426,   427,   428,   429,   430,   431,   432,   433,
       310,     0,   311,   312,   313,   314,   315,   316,   317,   318,
       319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
       329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   291,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   292,   293,   294,   295,   296,     0,     0,     0,
         0,     0,     0,     0,     0,   297,   298,   299,   300,   301,
       302,   303,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
         0,     0,     0,     0,     0,     0,     0,     0,   310,     0,
       311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
       321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
       331,   332,   333,   334,   335,     1,     2,     3,     4,     5,
         6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
        26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
        36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
        56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
        66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
        76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
        86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
        96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
       106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
       116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
       126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
       136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
       146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
       156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
       166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
       176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
       196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
       206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
       216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
       226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
       236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
       246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
       256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
       266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
       276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
       286,   287,   288,   289,   290,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   379,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       292,   293,   294,   295,     0,     0,     0,     0,     0,     0,
         0,     0,   380,   297,   298,   299,   300,   301,   302,   303,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   304,   305,   306,   307,   308,   309,     0,     0,
         0,     0,     0,     0,     0,     0,   310,     0,   311,   312,
       313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
       323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
       333,   334,   335,     1,     2,     3,     4,     5,     6,     7,
         8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
        18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
        28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
        38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
        48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
        58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
        68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
        78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
        88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
        98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
       108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
       118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
       128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
       138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
       148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
       158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
       178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
       198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
       238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
       248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
       258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
       268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
       278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       288,   289,   290,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,   548,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
       294,   295,     0,     0,     0,     0,     0,     0,     0,     0,
         0,   297,   298,   299,   300,   301,   302,   303,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       304,   305,   306,   307,   308,   309,     0,     0,     0,     0,
         0,     0,     0,     0,   310,     0,   311,   312,   313,   314,
       315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
       325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
       335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   630,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
         0,     0,     0,     0,     0,     0,     0,     0,     0,   297,
       298,   299,   300,   301,   302,   303,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   304,   305,
       306,   307,   308,   309,     0,     0,     0,     0,     0,     0,
         0,     0,   310,     0,   311,   312,   313,   314,   315,   316,
       317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
       327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
         2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   668,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   292,   293,   294,   295,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   297,   298,   299,
       300,   301,   302,   303,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   304,   305,   306,   307,
       308,   309,     0,     0,     0,     0,     0,     0,     0,     0,
       310,     0,   311,   312,   313,   314,   315,   316,   317,   318,
       319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
       329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   292,   293,   294,   295,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   297,   298,   299,   300,   301,
       302,   303,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
         0,     0,     0,     0,     0,     0,     0,     0,   310,     0,
       311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
       321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
       331,   332,   333,   334,   335,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,     0,   520,
       687,     0,     0,     0,     0,     0,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,   461,     0,
         0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,     0,   520,
         0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,   576,     0,
         0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   588,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,   416,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
         7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
        17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
        27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
        37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
        47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
        57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
        67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
        77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
        87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
        97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
       107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
       117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
       127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
       137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
       147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
       157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
       167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
       177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
       187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
       197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
       207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
       217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
       227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
       237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
       247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
       257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
       267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
       277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
       287,   288,   289,   290,     0,     0,   414,   415,     0,   444,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,   462,     0,   416,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
       528,   529,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
       424,   425,   297,     0,     0,     0,     0,   302,   538,     0,
         0,   541,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,   462,     0,     0,     0,     0,   426,   427,   428,
       429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
         0,   462,     0,     0,   318,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,   625,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,   631,   632,   633,   462,   462,   462,   462,   462,   462,
       462,   462,   462,   462,   462,   462,   462,   462,   462,   462,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
         0,     0,     0,     0,     0,     0,     0,     0,     0,   462
  };
  
  static const yytype_int16 yycheck[] =
  {
         0,   321,     0,   455,     0,   358,   315,   314,   361,     0,
       363,   364,   321,   333,   367,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,   524,   314,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,   341,   349,   416,   378,   506,   518,
       408,   520,   397,   384,   523,   580,   453,   656,   297,   298,
       302,   324,   350,   316,   318,   293,   294,   314,   350,   316,
       374,   324,   316,   370,   405,   406,   323,   299,   300,   316,
       324,   341,   315,   371,   442,   684,   323,   350,   321,   349,
       341,   315,   389,   332,   333,   337,   350,   357,   349,   357,
       360,   357,   351,   295,   296,   316,   357,   356,   357,   695,
       370,   456,   323,   317,   374,   315,   702,   321,   488,   370,
       490,   321,   314,   374,   316,   316,   584,   713,   320,   389,
       475,   318,   323,   315,   321,   315,   315,   324,   389,   321,
       400,   321,   321,   321,   315,   614,   324,   451,   321,   400,
       321,   324,   321,   550,   321,   324,   453,   324,   455,   324,
       518,   321,   520,   533,   324,   523,   304,   305,   306,   307,
       308,   309,   310,   311,   312,   313,   339,   340,   341,   537,
       562,   563,   564,   565,   321,   323,   321,   324,   329,   330,
       331,   451,   717,   453,   326,   455,   328,   655,   667,   319,
       451,   321,   453,   332,   455,   321,   322,   321,   322,   558,
       559,   318,   560,   561,   545,   318,   586,   350,   316,   350,
       590,   618,   566,   567,   350,   324,   323,   524,   350,   315,
       314,   316,   350,   350,   336,   335,   301,   303,   707,   334,
       317,   316,   314,   319,   324,   324,   506,   605,   606,   322,
       314,   314,   314,   550,   324,   506,   614,   324,   314,   314,
       350,   350,   315,   317,   524,   723,   317,   350,   314,   321,
       358,   319,   317,   524,   315,   314,   350,   315,   318,   323,
       650,   324,   315,   318,   362,   319,   656,   318,   324,   568,
       550,   569,   572,   570,   673,   571,   458,   296,   573,   550,
       628,   370,   658,   374,   544,   701,   374,   713,   368,   667,
       714,   658,   684,   516,   684,   516,   675,   516,    -1,    -1,
       580,   618,    -1,    -1,   584,   357,   696,    -1,   673,   580,
        -1,   689,    -1,   584,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   712,    -1,    -1,    -1,    -1,    -1,    -1,   707,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   618,   656,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   618,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   679,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   684,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   655,   656,    -1,   658,    -1,
        -1,    -1,    -1,    -1,   655,   656,    -1,   658,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   679,
        -1,    -1,    -1,    -1,   684,    -1,    -1,    -1,   679,    -1,
        -1,    -1,    -1,   684,    -1,   695,    -1,    -1,    -1,    -1,
        -1,    -1,   702,    -1,   695,    -1,    -1,    -1,    -1,    -1,
        -1,   702,    -1,   713,    -1,    -1,    -1,   717,    -1,    -1,
        -1,    -1,   713,   723,    -1,    -1,   717,    -1,    -1,    -1,
         0,    -1,   723,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,   291,   292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
       340,   341,   342,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,   351,   352,   353,   354,   355,   356,   357,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       370,   371,   372,   373,   374,   375,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   384,    -1,   386,   387,   388,   389,
       390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
       400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
       410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
       292,    -1,    -1,   295,   296,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   314,    -1,   316,    -1,   318,   319,    -1,    -1,
        -1,    -1,   324,   325,   326,   327,   328,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
       342,    -1,    -1,    -1,   346,   347,   348,   349,   350,   351,
       352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
        -1,   363,   364,   365,   366,   367,   368,   369,   370,   371,
       372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
       382,   383,   384,   385,   386,   387,   388,   389,   390,   391,
       392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
       402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
        -1,   295,   296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       314,    -1,   316,    -1,   318,   319,    -1,    -1,    -1,    -1,
       324,   325,   326,   327,   328,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   338,   339,   340,   341,   342,    -1,
        -1,    -1,   346,   347,   348,   349,   350,   351,   352,   353,
       354,   355,   356,   357,   358,   359,   360,   361,    -1,   363,
       364,   365,   366,   367,   368,   369,   370,   371,   372,   373,
       374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
       384,   385,   386,   387,   388,   389,   390,   391,   392,   393,
       394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
       404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
         6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
        26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
        36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
        56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
        66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
        76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
        86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
        96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
       106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
       116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
       126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
       136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
       146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
       156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
       166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
       176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
       196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
       206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
       216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
       226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
       236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
       246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
       256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
       266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
       276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
       286,   287,   288,   289,   290,   291,   292,    -1,    -1,   295,
       296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   314,    -1,
       316,    -1,   318,    -1,    -1,    -1,    -1,    -1,   324,   325,
       326,   327,   328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   338,   339,   340,   341,   342,    -1,    -1,    -1,
       346,   347,   348,   349,   350,   351,   352,   353,   354,   355,
       356,   357,   358,   359,   360,   361,    -1,   363,   364,   365,
       366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
       376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
       386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
       396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
       406,   407,   408,   409,   410,     3,     4,     5,     6,     7,
         8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
        18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
        28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
        38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
        48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
        58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
        68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
        78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
        88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
        98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
       108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
       118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
       128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
       138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
       148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
       158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
       178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
       198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
       238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
       248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
       258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
       268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
       278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       288,   289,   290,   291,   292,    -1,    -1,   295,   296,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   314,    -1,   316,    -1,
       318,    -1,    -1,    -1,    -1,    -1,   324,   325,   326,   327,
       328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       338,   339,   340,   341,   342,    -1,    -1,    -1,   346,   347,
       348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
       358,   359,   360,   361,    -1,   363,   364,   365,   366,   367,
       368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
       378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
       388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
       398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
       408,   409,   410,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   314,    -1,   316,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   324,   325,   326,   327,   328,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
       340,   341,   342,    -1,    -1,    -1,   346,   347,   348,   349,
       350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
       360,   361,    -1,   363,   364,   365,   366,   367,   368,   369,
       370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
       380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
       390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
       400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
       410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
       292,    -1,    -1,   295,   296,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   314,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   324,   325,   326,   327,   328,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
       342,    -1,    -1,    -1,   346,   347,   348,   349,   350,   351,
       352,   353,   354,   355,   356,   357,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   370,   371,
       372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
       382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
       392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
       402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
        -1,   295,   296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       314,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,   325,   326,   327,   328,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   338,   339,   340,   341,    -1,    -1,
        -1,    -1,   346,   347,   348,   349,   350,   351,   352,   353,
       354,   355,   356,   357,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   370,   371,   372,   373,
       374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
       384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
       394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
       404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
         6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
        26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
        36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
        56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
        66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
        76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
        86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
        96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
       106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
       116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
       126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
       136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
       146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
       156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
       166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
       176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
       196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
       206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
       216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
       226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
       236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
       246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
       256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
       266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
       276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
       286,   287,   288,   289,   290,   291,   292,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   324,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   338,   339,   340,   341,   342,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   351,   352,   353,   354,   355,
       356,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   370,   371,   372,   373,   374,   375,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,
       386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
       396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
       406,   407,   408,   409,   410,     3,     4,     5,     6,     7,
         8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
        18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
        28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
        38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
        48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
        58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
        68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
        78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
        88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
        98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
       108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
       118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
       128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
       138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
       148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
       158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
       178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
       198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
       228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
       238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
       248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
       258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
       268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
       278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
       288,   289,   290,   291,   292,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       338,   339,   340,   341,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   350,   351,   352,   353,   354,   355,   356,   357,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   370,   371,   372,   373,   374,   375,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,   386,   387,
       388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
       398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
       408,   409,   410,     3,     4,     5,     6,     7,     8,     9,
        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
        20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
        30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
        40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
        50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
        60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
        70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
        80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
        90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
       100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
       110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
       120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
       130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
       140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
       150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
       160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
       170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
       180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
       190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
       200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
       210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
       220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
       230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
       240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
       250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
       260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
       270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
       280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
       290,   291,   292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   319,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
       340,   341,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,   351,   352,   353,   354,   355,   356,   357,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       370,   371,   372,   373,   374,   375,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   384,    -1,   386,   387,   388,   389,
       390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
       400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
       410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
       292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   319,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   351,
       352,   353,   354,   355,   356,   357,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   370,   371,
       372,   373,   374,   375,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   384,    -1,   386,   387,   388,   389,   390,   391,
       392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
       402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
         4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
        14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
        24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
        34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
        54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
        64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
        74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
        84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
        94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
       104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
       114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
       124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
       134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
       144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
       154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
       164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
       174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
       184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
       194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
       204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
       214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
       224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
       234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
       244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
       254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
       264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
       274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
       284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   319,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   338,   339,   340,   341,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   351,   352,   353,
       354,   355,   356,   357,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   370,   371,   372,   373,
       374,   375,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
       394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
       404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
         6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
        26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
        36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
        56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
        66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
        76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
        86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
        96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
       106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
       116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
       126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
       136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
       146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
       156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
       166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
       176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
       196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
       206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
       216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
       226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
       236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
       246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
       256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
       266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
       276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
       286,   287,   288,   289,   290,   291,   292,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   338,   339,   340,   341,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   351,   352,   353,   354,   355,
       356,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   370,   371,   372,   373,   374,   375,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,
       386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
       396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
       406,   407,   408,   409,   410,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,   318,
       319,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,   317,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,   318,
        -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,   317,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   324,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
         9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
        29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
        39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
        49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
        59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
        69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
        79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
        89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
        99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
       109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
       119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
       129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
       139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
       149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
       159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
       169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
       179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
       189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
       199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
       209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
       219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
       229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
       239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
       249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
       259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
       269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
       279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
       289,   290,   291,   292,    -1,    -1,   295,   296,    -1,   383,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,   397,    -1,   314,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
       414,   415,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
       349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
        -1,   445,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,   456,    -1,    -1,    -1,    -1,   376,   377,   378,
       379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
        -1,   475,    -1,    -1,   393,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   542,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,   555,   556,   557,   558,   559,   560,   561,   562,   563,
       564,   565,   566,   567,   568,   569,   570,   571,   572,   573,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   673
  };
  
    /* 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,    11,
        12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
        22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
        32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
        42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
        52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
        62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
        72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
        82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
        92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
       102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
       122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
       142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
       152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
       162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
       172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
       192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
       202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
       212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
       222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
       232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
       242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
       252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
       262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
       272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
       282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
       292,   324,   338,   339,   340,   341,   342,   351,   352,   353,
       354,   355,   356,   357,   370,   371,   372,   373,   374,   375,
       384,   386,   387,   388,   389,   390,   391,   392,   393,   394,
       395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
       405,   406,   407,   408,   409,   410,   442,   443,   446,   447,
       448,   449,   453,   454,   455,   456,   457,   458,   461,   462,
       463,   464,   465,   467,   472,   473,   474,   515,   516,   517,
       473,   318,   350,   314,   314,   324,   350,   324,   518,   315,
       321,   450,   451,   452,   462,   467,   321,   324,   350,   324,
       350,   463,   467,   332,   469,   470,     0,   516,   467,   476,
       318,   350,   371,   459,   460,   350,   466,   316,   324,   468,
       318,   494,   451,   450,   452,   350,   350,   314,   323,   468,
       318,   321,   324,   445,   295,   296,   314,   325,   326,   327,
       328,   346,   347,   348,   349,   350,   376,   377,   378,   379,
       380,   381,   382,   383,   412,   413,   414,   416,   417,   418,
       419,   420,   421,   422,   423,   424,   465,   467,   471,   468,
       324,   462,   467,   477,   478,   475,   323,   315,   321,   315,
       321,   317,   423,   425,   426,   427,   428,   429,   430,   431,
       432,   433,   434,   435,   436,   316,   324,   316,   318,   319,
       324,   358,   359,   360,   361,   363,   364,   365,   366,   367,
       368,   369,   385,   423,   436,   438,   440,   442,   446,   465,
       467,   483,   484,   485,   486,   487,   495,   496,   497,   498,
       501,   502,   505,   506,   507,   514,   519,   468,   323,   468,
       318,   438,   481,   323,   444,   350,   321,   324,   423,   423,
       440,   295,   296,   316,   320,   315,   315,   321,   357,   438,
       314,   423,   321,   333,   467,   350,   479,   480,   319,   478,
       477,   436,   441,   460,   350,   329,   330,   331,   326,   328,
       293,   294,   297,   298,   332,   333,   299,   300,   336,   335,
       334,   301,   303,   302,   337,   317,   317,   436,   316,   319,
       488,   314,   324,   324,   509,   314,   314,   324,   324,   440,
       314,   440,   322,   324,   304,   305,   306,   307,   308,   309,
       310,   311,   312,   313,   323,   439,   321,   324,   319,   484,
       498,   502,   507,   481,   323,   481,   482,   481,   477,   350,
       315,   415,   440,   350,   438,   423,   479,   468,   321,   324,
       319,   423,   423,   423,   425,   425,   426,   426,   427,   427,
       427,   427,   428,   428,   429,   430,   431,   432,   433,   434,
       437,   317,   350,   520,   521,   495,   508,   484,   510,   440,
       324,   440,   322,   438,   438,   481,   319,   321,   319,   317,
       324,   480,   440,   314,   317,   321,   489,   440,   455,   462,
       500,   358,   483,   496,   511,   315,   315,   319,   481,   322,
       441,   317,   521,   319,   350,   315,   314,   500,   512,   513,
       491,   492,   493,   499,   503,   438,   315,   323,   485,   490,
       494,   440,   324,   315,   362,   487,   485,   318,   481,   315,
       440,   490,   491,   495,   504,   324,   319
  };
  
    /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  static const yytype_uint16 yyr1[] =
  {
         0,   411,   412,   413,   413,   413,   413,   413,   413,   413,
       413,   413,   413,   413,   413,   413,   413,   414,   414,   414,
       414,   414,   414,   415,   416,   417,   418,   418,   419,   419,
       420,   420,   421,   422,   422,   422,   423,   423,   423,   423,
       424,   424,   424,   424,   425,   425,   425,   425,   426,   426,
       426,   427,   427,   427,   428,   428,   428,   428,   428,   429,
       429,   429,   430,   430,   431,   431,   432,   432,   433,   433,
       434,   434,   435,   435,   436,   437,   436,   438,   438,   439,
       439,   439,   439,   439,   439,   439,   439,   439,   439,   439,
       440,   440,   441,   442,   442,   442,   442,   442,   442,   442,
       442,   442,   444,   443,   445,   445,   446,   447,   447,   448,
       448,   449,   450,   450,   451,   451,   451,   451,   452,   453,
       453,   453,   453,   453,   454,   454,   454,   454,   454,   455,
       455,   456,   457,   457,   457,   457,   457,   457,   457,   457,
       458,   459,   459,   460,   460,   460,   461,   462,   462,   463,
       463,   463,   463,   463,   463,   463,   464,   464,   464,   464,
       464,   464,   464,   464,   464,   464,   464,   464,   464,   464,
       464,   464,   464,   464,   464,   464,   464,   464,   464,   464,
       464,   464,   464,   464,   464,   465,   466,   466,   467,   467,
       468,   468,   468,   468,   469,   469,   470,   471,   471,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
       472,   472,   472,   472,   472,   472,   472,   472,   472,   473,
       473,   473,   475,   474,   476,   474,   477,   477,   478,   478,
       479,   479,   480,   480,   481,   481,   481,   482,   482,   483,
       484,   484,   485,   485,   485,   485,   485,   485,   485,   485,
       486,   487,   488,   489,   487,   490,   490,   492,   491,   493,
       491,   494,   494,   495,   495,   496,   496,   497,   497,   498,
       499,   499,   500,   500,   501,   501,   503,   502,   504,   504,
       505,   505,   506,   506,   508,   507,   509,   507,   510,   507,
       511,   511,   512,   512,   513,   513,   514,   514,   514,   514,
       514,   515,   515,   516,   516,   516,   518,   517,   519,   520,
       520,   521,   521
  };
  
    /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
  static const yytype_uint8 yyr2[] =
  {
         0,     2,     1,     1,     3,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     4,     1,
         3,     2,     2,     1,     1,     1,     2,     2,     2,     1,
         2,     3,     2,     1,     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,     1,     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,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     4,     1,     1,     3,     2,     3,
         2,     3,     3,     4,     1,     0,     3,     1,     3,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         1,     1,     0,     6,     0,     5,     1,     2,     3,     4,
         1,     3,     1,     2,     1,     3,     4,     1,     3,     1,
         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
         2,     2,     0,     0,     5,     1,     1,     0,     2,     0,
         2,     2,     3,     1,     2,     1,     2,     1,     2,     5,
         3,     1,     1,     4,     1,     2,     0,     8,     0,     1,
         3,     2,     1,     2,     0,     6,     0,     8,     0,     7,
         1,     1,     1,     0,     2,     3,     2,     2,     2,     3,
         2,     1,     2,     1,     1,     1,     0,     3,     5,     1,
         3,     1,     4
  };
  
  
  #define yyerrok         (yyerrstatus = 0)
  #define yyclearin       (yychar = YYEMPTY)
  #define YYEMPTY         (-2)
  #define YYEOF           0
  
  #define YYACCEPT        goto yyacceptlab
  #define YYABORT         goto yyabortlab
  #define YYERROR         goto yyerrorlab
  
  
  #define YYRECOVERING()  (!!yyerrstatus)
  
  #define YYBACKUP(Token, Value)                                  \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (pParseContext, YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)
  
  /* Error token number */
  #define YYTERROR        1
  #define YYERRCODE       256
  
  
  
  /* Enable debugging if requested.  */
  #if YYDEBUG
  
  # ifndef YYFPRINTF
  #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  #  define YYFPRINTF fprintf
  # endif
  
  # define YYDPRINTF(Args)                        \
  do {                                            \
    if (yydebug)                                  \
      YYFPRINTF Args;                             \
  } while (0)
  
  /* This macro is provided for backward compatibility. */
  #ifndef YY_LOCATION_PRINT
  # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  #endif
  
  
  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
  do {                                                                      \
    if (yydebug)                                                            \
      {                                                                     \
        YYFPRINTF (stderr, "%s ", Title);                                   \
        yy_symbol_print (stderr,                                            \
                    Type, Value, pParseContext); \
        YYFPRINTF (stderr, "\n");                                           \
      }                                                                     \
  } while (0)
  
  
  /*----------------------------------------.
  | Print this symbol's value on YYOUTPUT.  |
  `----------------------------------------*/
  
  static void
  yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
  {
    FILE *yyo = yyoutput;
    YYUSE (yyo);
    YYUSE (pParseContext);
    if (!yyvaluep)
      return;
  # ifdef YYPRINT
    if (yytype < YYNTOKENS)
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
  # endif
    YYUSE (yytype);
  }
  
  
  /*--------------------------------.
  | Print this symbol on YYOUTPUT.  |
  `--------------------------------*/
  
  static void
  yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
  {
    YYFPRINTF (yyoutput, "%s %s (",
               yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
  
    yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParseContext);
    YYFPRINTF (yyoutput, ")");
  }
  
  /*------------------------------------------------------------------.
  | yy_stack_print -- Print the state stack from its BOTTOM up to its |
  | TOP (included).                                                   |
  `------------------------------------------------------------------*/
  
  static void
  yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
  {
    YYFPRINTF (stderr, "Stack now");
    for (; yybottom <= yytop; yybottom++)
      {
        int yybot = *yybottom;
        YYFPRINTF (stderr, " %d", yybot);
      }
    YYFPRINTF (stderr, "\n");
  }
  
  # define YY_STACK_PRINT(Bottom, Top)                            \
  do {                                                            \
    if (yydebug)                                                  \
      yy_stack_print ((Bottom), (Top));                           \
  } while (0)
  
  
  /*------------------------------------------------.
  | Report that the YYRULE is going to be reduced.  |
  `------------------------------------------------*/
  
  static void
  yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, glslang::TParseContext* pParseContext)
  {
    unsigned long int yylno = yyrline[yyrule];
    int yynrhs = yyr2[yyrule];
    int yyi;
    YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
               yyrule - 1, yylno);
    /* The symbols being reduced.  */
    for (yyi = 0; yyi < yynrhs; yyi++)
      {
        YYFPRINTF (stderr, "   $%d = ", yyi + 1);
        yy_symbol_print (stderr,
                         yystos[yyssp[yyi + 1 - yynrhs]],
                         &(yyvsp[(yyi + 1) - (yynrhs)])
                                                , pParseContext);
        YYFPRINTF (stderr, "\n");
      }
  }
  
  # define YY_REDUCE_PRINT(Rule)          \
  do {                                    \
    if (yydebug)                          \
      yy_reduce_print (yyssp, yyvsp, Rule, pParseContext); \
  } while (0)
  
  /* Nonzero means print parse trace.  It is left uninitialized so that
     multiple parsers can coexist.  */
  int yydebug;
  #else /* !YYDEBUG */
  # define YYDPRINTF(Args)
  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  # define YY_STACK_PRINT(Bottom, Top)
  # define YY_REDUCE_PRINT(Rule)
  #endif /* !YYDEBUG */
  
  
  /* YYINITDEPTH -- initial size of the parser's stacks.  */
  #ifndef YYINITDEPTH
  # define YYINITDEPTH 200
  #endif
  
  /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     if the built-in stack extension method is used).
  
     Do not make this value too large; the results are undefined if
     YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
     evaluated with infinite-precision integer arithmetic.  */
  
  #ifndef YYMAXDEPTH
  # define YYMAXDEPTH 10000
  #endif
  
  
  #if YYERROR_VERBOSE
  
  # ifndef yystrlen
  #  if defined __GLIBC__ && defined _STRING_H
  #   define yystrlen strlen
  #  else
  /* Return the length of YYSTR.  */
  static YYSIZE_T
  yystrlen (const char *yystr)
  {
    YYSIZE_T yylen;
    for (yylen = 0; yystr[yylen]; yylen++)
      continue;
    return yylen;
  }
  #  endif
  # endif
  
  # ifndef yystpcpy
  #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
  #   define yystpcpy stpcpy
  #  else
  /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
     YYDEST.  */
  static char *
  yystpcpy (char *yydest, const char *yysrc)
  {
    char *yyd = yydest;
    const char *yys = yysrc;
  
    while ((*yyd++ = *yys++) != '\0')
      continue;
  
    return yyd - 1;
  }
  #  endif
  # endif
  
  # ifndef yytnamerr
  /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
     quotes and backslashes, so that it's suitable for yyerror.  The
     heuristic is that double-quoting is unnecessary unless the string
     contains an apostrophe, a comma, or backslash (other than
     backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
     null, do not copy; instead, return the length of what the result
     would have been.  */
  static YYSIZE_T
  yytnamerr (char *yyres, const char *yystr)
  {
    if (*yystr == '"')
      {
        YYSIZE_T yyn = 0;
        char const *yyp = yystr;
  
        for (;;)
          switch (*++yyp)
            {
            case '\'':
            case ',':
              goto do_not_strip_quotes;
  
            case '\\':
              if (*++yyp != '\\')
                goto do_not_strip_quotes;
              /* Fall through.  */
            default:
              if (yyres)
                yyres[yyn] = *yyp;
              yyn++;
              break;
  
            case '"':
              if (yyres)
                yyres[yyn] = '\0';
              return yyn;
            }
      do_not_strip_quotes: ;
      }
  
    if (! yyres)
      return yystrlen (yystr);
  
    return yystpcpy (yyres, yystr) - yyres;
  }
  # endif
  
  /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
     about the unexpected token YYTOKEN for the state stack whose top is
     YYSSP.
  
     Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
     not large enough to hold the message.  In that case, also set
     *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
     required number of bytes is too large to store.  */
  static int
  yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                  yytype_int16 *yyssp, int yytoken)
  {
    YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
    YYSIZE_T yysize = yysize0;
    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    /* Internationalized format string. */
    const char *yyformat = YY_NULLPTR;
    /* Arguments of yyformat. */
    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    /* Number of reported tokens (one for the "unexpected", one per
       "expected"). */
    int yycount = 0;
  
    /* There are many possibilities here to consider:
       - If this state is a consistent state with a default action, then
         the only way this function was invoked is if the default action
         is an error action.  In that case, don't check for expected
         tokens because there are none.
       - The only way there can be no lookahead present (in yychar) is if
         this state is a consistent state with a default action.  Thus,
         detecting the absence of a lookahead is sufficient to determine
         that there is no unexpected or expected token to report.  In that
         case, just report a simple "syntax error".
       - Don't assume there isn't a lookahead just because this state is a
         consistent state with a default action.  There might have been a
         previous inconsistent state, consistent state with a non-default
         action, or user semantic action that manipulated yychar.
       - Of course, the expected token list depends on states to have
         correct lookahead information, and it depends on the parser not
         to perform extra reductions after fetching a lookahead from the
         scanner and before detecting a syntax error.  Thus, state merging
         (from LALR or IELR) and default reductions corrupt the expected
         token list.  However, the list is correct for canonical LR with
         one exception: it will still contain any token that will not be
         accepted due to an error action in a later state.
    */
    if (yytoken != YYEMPTY)
      {
        int yyn = yypact[*yyssp];
        yyarg[yycount++] = yytname[yytoken];
        if (!yypact_value_is_default (yyn))
          {
            /* Start YYX at -YYN if negative to avoid negative indexes in
               YYCHECK.  In other words, skip the first -YYN actions for
               this state because they are default actions.  */
            int yyxbegin = yyn < 0 ? -yyn : 0;
            /* Stay within bounds of both yycheck and yytname.  */
            int yychecklim = YYLAST - yyn + 1;
            int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
            int yyx;
  
            for (yyx = yyxbegin; yyx < yyxend; ++yyx)
              if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                  && !yytable_value_is_error (yytable[yyx + yyn]))
                {
                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                    {
                      yycount = 1;
                      yysize = yysize0;
                      break;
                    }
                  yyarg[yycount++] = yytname[yyx];
                  {
                    YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                    if (! (yysize <= yysize1
                           && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                      return 2;
                    yysize = yysize1;
                  }
                }
          }
      }
  
    switch (yycount)
      {
  # define YYCASE_(N, S)                      \
        case N:                               \
          yyformat = S;                       \
        break
        YYCASE_(0, YY_("syntax error"));
        YYCASE_(1, YY_("syntax error, unexpected %s"));
        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
  # undef YYCASE_
      }
  
    {
      YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
      if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
        return 2;
      yysize = yysize1;
    }
  
    if (*yymsg_alloc < yysize)
      {
        *yymsg_alloc = 2 * yysize;
        if (! (yysize <= *yymsg_alloc
               && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
          *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
        return 1;
      }
  
    /* Avoid sprintf, as that infringes on the user's name space.
       Don't have undefined behavior even if the translation
       produced a string with the wrong number of "%s"s.  */
    {
      char *yyp = *yymsg;
      int yyi = 0;
      while ((*yyp = *yyformat) != '\0')
        if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
          {
            yyp += yytnamerr (yyp, yyarg[yyi++]);
            yyformat += 2;
          }
        else
          {
            yyp++;
            yyformat++;
          }
    }
    return 0;
  }
  #endif /* YYERROR_VERBOSE */
  
  /*-----------------------------------------------.
  | Release the memory associated to this symbol.  |
  `-----------------------------------------------*/
  
  static void
  yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext)
  {
    YYUSE (yyvaluep);
    YYUSE (pParseContext);
    if (!yymsg)
      yymsg = "Deleting";
    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  
    YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    YYUSE (yytype);
    YY_IGNORE_MAYBE_UNINITIALIZED_END
  }
  
  
  
  
  /*----------.
  | yyparse.  |
  `----------*/
  
  int
  yyparse (glslang::TParseContext* pParseContext)
  {
  /* The lookahead symbol.  */
  int yychar;
  
  
  /* The semantic value of the lookahead symbol.  */
  /* Default value used for initialization, for pacifying older GCCs
     or non-GCC compilers.  */
  YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
  YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
  
      /* Number of syntax errors so far.  */
      int yynerrs;
  
      int yystate;
      /* Number of tokens to shift before error messages enabled.  */
      int yyerrstatus;
  
      /* The stacks and their tools:
         'yyss': related to states.
         'yyvs': related to semantic values.
  
         Refer to the stacks through separate pointers, to allow yyoverflow
         to reallocate them elsewhere.  */
  
      /* The state stack.  */
      yytype_int16 yyssa[YYINITDEPTH];
      yytype_int16 *yyss;
      yytype_int16 *yyssp;
  
      /* The semantic value stack.  */
      YYSTYPE yyvsa[YYINITDEPTH];
      YYSTYPE *yyvs;
      YYSTYPE *yyvsp;
  
      YYSIZE_T yystacksize;
  
    int yyn;
    int yyresult;
    /* Lookahead token as an internal (translated) token number.  */
    int yytoken = 0;
    /* The variables used to return semantic value and location from the
       action routines.  */
    YYSTYPE yyval;
  
  #if YYERROR_VERBOSE
    /* Buffer for error messages, and its allocated size.  */
    char yymsgbuf[128];
    char *yymsg = yymsgbuf;
    YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
  #endif
  
  #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  
    /* The number of symbols on the RHS of the reduced rule.
       Keep to zero when no symbol should be popped.  */
    int yylen = 0;
  
    yyssp = yyss = yyssa;
    yyvsp = yyvs = yyvsa;
    yystacksize = YYINITDEPTH;
  
    YYDPRINTF ((stderr, "Starting parse\n"));
  
    yystate = 0;
    yyerrstatus = 0;
    yynerrs = 0;
    yychar = YYEMPTY; /* Cause a token to be read.  */
    goto yysetstate;
  
  /*------------------------------------------------------------.
  | yynewstate -- Push a new state, which is found in yystate.  |
  `------------------------------------------------------------*/
   yynewstate:
    /* In all cases, when you get here, the value and location stacks
       have just been pushed.  So pushing a state here evens the stacks.  */
    yyssp++;
  
   yysetstate:
    *yyssp = yystate;
  
    if (yyss + yystacksize - 1 <= yyssp)
      {
        /* Get the current used size of the three stacks, in elements.  */
        YYSIZE_T yysize = yyssp - yyss + 1;
  
  #ifdef yyoverflow
        {
          /* Give user a chance to reallocate the stack.  Use copies of
             these so that the &'s don't force the real ones into
             memory.  */
          YYSTYPE *yyvs1 = yyvs;
          yytype_int16 *yyss1 = yyss;
  
          /* Each stack pointer address is followed by the size of the
             data in use in that stack, in bytes.  This used to be a
             conditional around just the two extra args, but that might
             be undefined if yyoverflow is a macro.  */
          yyoverflow (YY_("memory exhausted"),
                      &yyss1, yysize * sizeof (*yyssp),
                      &yyvs1, yysize * sizeof (*yyvsp),
                      &yystacksize);
  
          yyss = yyss1;
          yyvs = yyvs1;
        }
  #else /* no yyoverflow */
  # ifndef YYSTACK_RELOCATE
        goto yyexhaustedlab;
  # else
        /* Extend the stack our own way.  */
        if (YYMAXDEPTH <= yystacksize)
          goto yyexhaustedlab;
        yystacksize *= 2;
        if (YYMAXDEPTH < yystacksize)
          yystacksize = YYMAXDEPTH;
  
        {
          yytype_int16 *yyss1 = yyss;
          union yyalloc *yyptr =
            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
          if (! yyptr)
            goto yyexhaustedlab;
          YYSTACK_RELOCATE (yyss_alloc, yyss);
          YYSTACK_RELOCATE (yyvs_alloc, yyvs);
  #  undef YYSTACK_RELOCATE
          if (yyss1 != yyssa)
            YYSTACK_FREE (yyss1);
        }
  # endif
  #endif /* no yyoverflow */
  
        yyssp = yyss + yysize - 1;
        yyvsp = yyvs + yysize - 1;
  
        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                    (unsigned long int) yystacksize));
  
        if (yyss + yystacksize - 1 <= yyssp)
          YYABORT;
      }
  
    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  
    if (yystate == YYFINAL)
      YYACCEPT;
  
    goto yybackup;
  
  /*-----------.
  | yybackup.  |
  `-----------*/
  yybackup:
  
    /* Do appropriate processing given the current state.  Read a
       lookahead token if we need one and don't already have one.  */
  
    /* First try to decide what to do without reference to lookahead token.  */
    yyn = yypact[yystate];
    if (yypact_value_is_default (yyn))
      goto yydefault;
  
    /* Not known => get a lookahead token if don't already have one.  */
  
    /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
    if (yychar == YYEMPTY)
      {
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = yylex (&yylval, parseContext);
      }
  
    if (yychar <= YYEOF)
      {
        yychar = yytoken = YYEOF;
        YYDPRINTF ((stderr, "Now at end of input.\n"));
      }
    else
      {
        yytoken = YYTRANSLATE (yychar);
        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
      }
  
    /* If the proper action on seeing token YYTOKEN is to reduce or to
       detect an error, take that action.  */
    yyn += yytoken;
    if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
      goto yydefault;
    yyn = yytable[yyn];
    if (yyn <= 0)
      {
        if (yytable_value_is_error (yyn))
          goto yyerrlab;
        yyn = -yyn;
        goto yyreduce;
      }
  
    /* Count tokens shifted since error; after three, turn off error
       status.  */
    if (yyerrstatus)
      yyerrstatus--;
  
    /* Shift the lookahead token.  */
    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  
    /* Discard the shifted token.  */
    yychar = YYEMPTY;
  
    yystate = yyn;
    YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    *++yyvsp = yylval;
    YY_IGNORE_MAYBE_UNINITIALIZED_END
  
    goto yynewstate;
  
  
  /*-----------------------------------------------------------.
  | yydefault -- do the default action for the current state.  |
  `-----------------------------------------------------------*/
  yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
      goto yyerrlab;
    goto yyreduce;
  
  
  /*-----------------------------.
  | yyreduce -- Do a reduction.  |
  `-----------------------------*/
  yyreduce:
    /* yyn is the number of a rule to reduce with.  */
    yylen = yyr2[yyn];
  
    /* If YYLEN is nonzero, implement the default value of the action:
       '$$ = $1'.
  
       Otherwise, the following line sets YYVAL to garbage.
       This behavior is undocumented and Bison
       users should not rely upon it.  Assigning to YYVAL
       unconditionally makes the parser a bit smaller, and it avoids a
       GCC warning that YYVAL may be used uninitialized.  */
    yyval = yyvsp[1-yylen];
  
  
    YY_REDUCE_PRINT (yyn);
    switch (yyn)
      {
          case 2:
  #line 352 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
      }
  #line 4172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 3:
  #line 358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 4:
  #line 361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
          if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
              (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
      }
  #line 4190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 5:
  #line 366 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
      }
  #line 4198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 6:
  #line 369 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
      }
  #line 4206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 7:
  #line 372 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
      }
  #line 4215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 8:
  #line 376 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
      }
  #line 4223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 9:
  #line 380 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
      }
  #line 4232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 10:
  #line 384 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
      }
  #line 4241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 11:
  #line 388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
      }
  #line 4250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 12:
  #line 392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
      }
  #line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 13:
  #line 396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
      }
  #line 4268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 14:
  #line 400 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
      }
  #line 4277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 15:
  #line 404 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true);
      }
  #line 4286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 16:
  #line 408 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
      }
  #line 4295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 17:
  #line 416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 18:
  #line 419 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
      }
  #line 4311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 19:
  #line 422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 20:
  #line 425 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
      }
  #line 4327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 21:
  #line 428 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
          parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
      }
  #line 4337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 22:
  #line 433 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
          parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
      }
  #line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 23:
  #line 441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 24:
  #line 448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
          delete (yyvsp[0].interm).function;
      }
  #line 4365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 25:
  #line 455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
      }
  #line 4373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 26:
  #line 461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-1].interm);
          (yyval.interm).loc = (yyvsp[0].lex).loc;
      }
  #line 4382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 27:
  #line 465 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-1].interm);
          (yyval.interm).loc = (yyvsp[0].lex).loc;
      }
  #line 4391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 28:
  #line 472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-1].interm);
      }
  #line 4399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 29:
  #line 475 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
      }
  #line 4407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 30:
  #line 481 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          TParameter param = { 0, new TType };
          param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
          (yyvsp[-1].interm).function->addParameter(param);
          (yyval.interm).function = (yyvsp[-1].interm).function;
          (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 31:
  #line 488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          TParameter param = { 0, new TType };
          param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
          (yyvsp[-2].interm).function->addParameter(param);
          (yyval.interm).function = (yyvsp[-2].interm).function;
          (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
      }
  #line 4431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 32:
  #line 498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-1].interm);
      }
  #line 4439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 33:
  #line 506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // Constructor
          (yyval.interm).intermNode = 0;
          (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
      }
  #line 4449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 34:
  #line 511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          //
          // Should be a method or subroutine call, but we haven't recognized the arguments yet.
          //
          (yyval.interm).function = 0;
          (yyval.interm).intermNode = 0;
  
          TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode();
          if (method) {
              (yyval.interm).function = new TFunction(&method->getMethodName(), TType(EbtInt), EOpArrayLength);
              (yyval.interm).intermNode = method->getObject();
          } else {
              TIntermSymbol* symbol = (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode();
              if (symbol) {
                  parseContext.reservedErrorCheck(symbol->getLoc(), symbol->getName());
                  TFunction *function = new TFunction(&symbol->getName(), TType(EbtVoid));
                  (yyval.interm).function = function;
              } else
                  parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "function call, method, or subroutine call expected", "", "");
          }
  
          if ((yyval.interm).function == 0) {
              // error recover
              TString* empty = NewPoolTString("");
              (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
          }
      }
  #line 4481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 35:
  #line 539 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // Constructor
          (yyval.interm).intermNode = 0;
          (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
      }
  #line 4491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 36:
  #line 548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
          if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
              parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
      }
  #line 4502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 37:
  #line 554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
      }
  #line 4511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 38:
  #line 558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
      }
  #line 4520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 39:
  #line 562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-1].interm).op != EOpNull) {
              char errorOp[2] = {0, 0};
              switch((yyvsp[-1].interm).op) {
              case EOpNegative:   errorOp[0] = '-'; break;
              case EOpLogicalNot: errorOp[0] = '!'; break;
              case EOpBitwiseNot: errorOp[0] = '~'; break;
              default: break; // some compilers want this
              }
              (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].interm).loc, errorOp, (yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode));
          } else {
              (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
              if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
                  (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
          }
      }
  #line 4541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 40:
  #line 582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
  #line 4547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 41:
  #line 583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
  #line 4553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 42:
  #line 584 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
  #line 4559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 43:
  #line 585 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
                parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
  #line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 44:
  #line 591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 45:
  #line 592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 46:
  #line 597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4592 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 47:
  #line 602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 48:
  #line 611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 49:
  #line 612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 50:
  #line 617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 51:
  #line 625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4635 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 52:
  #line 626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 53:
  #line 632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 54:
  #line 641 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 55:
  #line 642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 56:
  #line 647 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 57:
  #line 652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 58:
  #line 657 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 59:
  #line 665 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 60:
  #line 666 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
          parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
          parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
          parseContext.referenceCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "==", EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 61:
  #line 675 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
          parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
          parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
          parseContext.referenceCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "!=", EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 62:
  #line 687 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 63:
  #line 688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 64:
  #line 697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 65:
  #line 698 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 66:
  #line 707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 67:
  #line 708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 4788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 68:
  #line 717 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 69:
  #line 718 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 70:
  #line 726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 71:
  #line 727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 72:
  #line 735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 73:
  #line 736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
          if ((yyval.interm.intermTypedNode) == 0)
              (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
      }
  #line 4836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 74:
  #line 744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 75:
  #line 745 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          ++parseContext.controlFlowNestingLevel;
      }
  #line 4850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 76:
  #line 748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          --parseContext.controlFlowNestingLevel;
          parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
          parseContext.rValueErrorCheck((yyvsp[-4].lex).loc, "?", (yyvsp[-5].interm.intermTypedNode));
          parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode));
          parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addSelection((yyvsp[-5].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-4].lex).loc);
          if ((yyval.interm.intermTypedNode) == 0) {
              parseContext.binaryOpError((yyvsp[-4].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
              (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
          }
      }
  #line 4867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 77:
  #line 763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
  #line 4873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 78:
  #line 764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
          parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
          parseContext.storage16BitAssignmentCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
          parseContext.specializationCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
          parseContext.lValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode));
          parseContext.rValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].interm).loc);
          if ((yyval.interm.intermTypedNode) == 0) {
              parseContext.assignError((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
              (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
          }
      }
  #line 4891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 79:
  #line 780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpAssign;
      }
  #line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 80:
  #line 784 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpMulAssign;
      }
  #line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 81:
  #line 788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpDivAssign;
      }
  #line 4918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 82:
  #line 792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpModAssign;
      }
  #line 4928 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 83:
  #line 797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpAddAssign;
      }
  #line 4937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 84:
  #line 801 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).op = EOpSubAssign;
      }
  #line 4946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 85:
  #line 805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
          (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
      }
  #line 4955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 86:
  #line 809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
          (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
      }
  #line 4964 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 87:
  #line 813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
          (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
      }
  #line 4973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 88:
  #line 817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
          (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
      }
  #line 4982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 89:
  #line 821 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
          (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
      }
  #line 4991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 90:
  #line 828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 4999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 91:
  #line 831 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
          (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
          if ((yyval.interm.intermTypedNode) == 0) {
              parseContext.binaryOpError((yyvsp[-1].lex).loc, ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
              (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
          }
      }
  #line 5012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 92:
  #line 842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 5021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 93:
  #line 849 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
          (yyval.interm.intermNode) = 0;
          // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
      }
  #line 5031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 94:
  #line 854 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
              (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
          (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
      }
  #line 5041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 95:
  #line 859 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
          // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope
          parseContext.symbolTable.setPreviousDefaultPrecisions(&parseContext.defaultPrecision[0]);
          parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
          (yyval.interm.intermNode) = 0;
      }
  #line 5053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 96:
  #line 866 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
          (yyval.interm.intermNode) = 0;
      }
  #line 5062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 97:
  #line 870 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
          (yyval.interm.intermNode) = 0;
      }
  #line 5071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 98:
  #line 874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
          (yyval.interm.intermNode) = 0;
      }
  #line 5080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 99:
  #line 878 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
          parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
          (yyval.interm.intermNode) = 0;
      }
  #line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 100:
  #line 883 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
          parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
          (yyval.interm.intermNode) = 0;
      }
  #line 5100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 101:
  #line 888 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers);
          (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string);
          parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
          (yyval.interm.intermNode) = 0;
      }
  #line 5111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 102:
  #line 897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
  #line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 103:
  #line 897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          --parseContext.structNestingLevel;
          parseContext.blockName = (yyvsp[-4].lex).string;
          parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier);
          parseContext.checkNoShaderLayouts((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).shaderQualifiers);
          parseContext.currentBlockQualifier = (yyvsp[-5].interm.type).qualifier;
          (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
          (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
      }
  #line 5131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 104:
  #line 908 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.identifierList) = new TIdentifierList;
          (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
      }
  #line 5140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 105:
  #line 912 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
          (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
      }
  #line 5149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 106:
  #line 919 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).function = (yyvsp[-1].interm.function);
          (yyval.interm).loc = (yyvsp[0].lex).loc;
      }
  #line 5158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 107:
  #line 926 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.function) = (yyvsp[0].interm.function);
      }
  #line 5166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 108:
  #line 929 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.function) = (yyvsp[0].interm.function);
      }
  #line 5174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 109:
  #line 936 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // Add the parameter
          (yyval.interm.function) = (yyvsp[-1].interm.function);
          if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid)
              (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param);
          else
              delete (yyvsp[0].interm).param.type;
      }
  #line 5187 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 110:
  #line 944 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          //
          // Only first parameter of one-parameter functions can be void
          // The check for named parameters not being void is done in parameter_declarator
          //
          if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) {
              //
              // This parameter > first is void
              //
              parseContext.error((yyvsp[-1].lex).loc, "cannot be an argument type except for '(void)'", "void", "");
              delete (yyvsp[0].interm).param.type;
          } else {
              // Add the parameter
              (yyval.interm.function) = (yyvsp[-2].interm.function);
              (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
          }
      }
  #line 5209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 111:
  #line 964 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
              parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
                                 GetStorageQualifierString((yyvsp[-2].interm.type).qualifier.storage), "");
          }
          if ((yyvsp[-2].interm.type).arraySizes)
              parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
  
          // Add the function as a prototype after parsing it (we do not support recursion)
          TFunction *function;
          TType type((yyvsp[-2].interm.type));
  
          // Potentially rename shader entry point function.  No-op most of the time.
          parseContext.renameShaderFunction((yyvsp[-1].lex).string);
  
          // Make the function
          function = new TFunction((yyvsp[-1].lex).string, type);
          (yyval.interm.function) = function;
      }
  #line 5233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 112:
  #line 987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-1].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[-1].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
              parseContext.arraySizeRequiredCheck((yyvsp[-1].interm.type).loc, *(yyvsp[-1].interm.type).arraySizes);
          }
          if ((yyvsp[-1].interm.type).basicType == EbtVoid) {
              parseContext.error((yyvsp[0].lex).loc, "illegal use of type 'void'", (yyvsp[0].lex).string->c_str(), "");
          }
          parseContext.reservedErrorCheck((yyvsp[0].lex).loc, *(yyvsp[0].lex).string);
  
          TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))};
          (yyval.interm).loc = (yyvsp[0].lex).loc;
          (yyval.interm).param = param;
      }
  #line 5253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 113:
  #line 1002 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-2].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
              parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
          }
          TType* type = new TType((yyvsp[-2].interm.type));
          type->transferArraySizes((yyvsp[0].interm).arraySizes);
          type->copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
  
          parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, type->getArraySizes());
          parseContext.arraySizeRequiredCheck((yyvsp[0].interm).loc, *(yyvsp[0].interm).arraySizes);
          parseContext.reservedErrorCheck((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string);
  
          TParameter param = { (yyvsp[-1].lex).string, type };
  
          (yyval.interm).loc = (yyvsp[-1].lex).loc;
          (yyval.interm).param = param;
      }
  #line 5277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 114:
  #line 1027 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
          if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
              (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
          parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
  
          parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
          parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
          parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
  
      }
  #line 5293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 115:
  #line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
  
          parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
          parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
          parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
      }
  #line 5305 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 116:
  #line 1048 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
          if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
              (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
          parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
  
          parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
          parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
          parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
      }
  #line 5320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 117:
  #line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
  
          parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
          parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
          parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
      }
  #line 5332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 118:
  #line 1068 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
          (yyval.interm).param = param;
          if ((yyvsp[0].interm.type).arraySizes)
              parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
      }
  #line 5343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 119:
  #line 1077 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[0].interm);
      }
  #line 5351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 120:
  #line 1080 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-2].interm);
          parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
      }
  #line 5360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 121:
  #line 1084 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-3].interm);
          parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
      }
  #line 5369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 122:
  #line 1088 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-5].interm).type;
          TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
          (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
      }
  #line 5379 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 123:
  #line 1093 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-4].interm).type;
          TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode));
          (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
      }
  #line 5389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 124:
  #line 1101 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[0].interm.type);
          (yyval.interm).intermNode = 0;
  
          parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
  
      }
  #line 5401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 125:
  #line 1108 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-1].interm.type);
          (yyval.interm).intermNode = 0;
          parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
      }
  #line 5411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 126:
  #line 1113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-2].interm.type);
          (yyval.interm).intermNode = 0;
          parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
      }
  #line 5421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 127:
  #line 1118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-4].interm.type);
          TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
          (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
      }
  #line 5431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 128:
  #line 1123 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).type = (yyvsp[-3].interm.type);
          TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
          (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
      }
  #line 5441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 129:
  #line 1132 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
  
          parseContext.globalQualifierTypeCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyval.interm.type));
          if ((yyvsp[0].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
          }
          parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
      }
  #line 5456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 130:
  #line 1142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
          parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
  
          if ((yyvsp[0].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
          }
  
          if ((yyvsp[0].interm.type).arraySizes && parseContext.arrayQualifierError((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).qualifier))
              (yyvsp[0].interm.type).arraySizes = nullptr;
  
          parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
          (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers);
          parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true);
          parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier);
  
          (yyval.interm.type) = (yyvsp[0].interm.type);
  
          if (! (yyval.interm.type).qualifier.isInterpolation() &&
              ((parseContext.language == EShLangVertex   && (yyval.interm.type).qualifier.storage == EvqVaryingOut) ||
               (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
              (yyval.interm.type).qualifier.smooth = true;
      }
  #line 5485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 131:
  #line 1169 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
          parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.invariant = true;
      }
  #line 5496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 132:
  #line 1178 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "smooth");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.smooth = true;
      }
  #line 5508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 133:
  #line 1185 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "flat");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.flat = true;
      }
  #line 5520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 134:
  #line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "noperspective");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.nopersp = true;
      }
  #line 5532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 135:
  #line 1200 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.explicitInterp = true;
      }
  #line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 136:
  #line 1207 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.pervertexNV = true;
      }
  #line 5557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 137:
  #line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // No need for profile version or extension check. Shader stage already checks both.
          parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangFragmentMask | EShLangMeshNVMask), "perprimitiveNV");
          // Fragment shader stage doesn't check for extension. So we explicitly add below extension check.
          if (parseContext.language == EShLangFragment)
              parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_NV_mesh_shader, "perprimitiveNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.perPrimitiveNV = true;
      }
  #line 5572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 138:
  #line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // No need for profile version or extension check. Shader stage already checks both.
          parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangMeshNV, "perviewNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.perViewNV = true;
      }
  #line 5584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 139:
  #line 1232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // No need for profile version or extension check. Shader stage already checks both.
          parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask), "taskNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.perTaskNV = true;
      }
  #line 5596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 140:
  #line 1243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[-1].interm.type);
      }
  #line 5604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 141:
  #line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 142:
  #line 1252 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[-2].interm.type);
          (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
          parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
      }
  #line 5622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 143:
  #line 1259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
      }
  #line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 144:
  #line 1263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[-2].lex).loc);
          parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
      }
  #line 5640 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 145:
  #line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { // because "shared" is both an identifier and a keyword
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          TString strShared("shared");
          parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
      }
  #line 5650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 146:
  #line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.noContraction = true;
      }
  #line 5661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 147:
  #line 1286 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 148:
  #line 1289 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[-1].interm.type);
          if ((yyval.interm.type).basicType == EbtVoid)
              (yyval.interm.type).basicType = (yyvsp[0].interm.type).basicType;
  
          (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
          parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
      }
  #line 5682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 149:
  #line 1300 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 150:
  #line 1303 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 151:
  #line 1306 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 152:
  #line 1310 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // allow inheritance of storage qualifier from block declaration
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 153:
  #line 1314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // allow inheritance of storage qualifier from block declaration
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 154:
  #line 1319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // allow inheritance of storage qualifier from block declaration
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 155:
  #line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
      }
  #line 5742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 156:
  #line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
      }
  #line 5751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 157:
  #line 1334 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqInOut;
      }
  #line 5761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 158:
  #line 1339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "in");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
          (yyval.interm.type).qualifier.storage = EvqIn;
      }
  #line 5772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 159:
  #line 1345 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "out");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
          (yyval.interm.type).qualifier.storage = EvqOut;
      }
  #line 5783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 160:
  #line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
          parseContext.globalCheck((yyvsp[0].lex).loc, "centroid");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.centroid = true;
      }
  #line 5795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 161:
  #line 1358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqUniform;
      }
  #line 5805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 162:
  #line 1363 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
          parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqShared;
      }
  #line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 163:
  #line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqBuffer;
      }
  #line 5828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 164:
  #line 1377 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
          parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
          parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "attribute");
          parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "attribute");
          parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "attribute");
  
          parseContext.globalCheck((yyvsp[0].lex).loc, "attribute");
  
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqVaryingIn;
      }
  #line 5845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 165:
  #line 1389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
          parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
          parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "varying");
          parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "varying");
  
          parseContext.globalCheck((yyvsp[0].lex).loc, "varying");
  
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          if (parseContext.language == EShLangVertex)
              (yyval.interm.type).qualifier.storage = EvqVaryingOut;
          else
              (yyval.interm.type).qualifier.storage = EvqVaryingIn;
      }
  #line 5864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 166:
  #line 1403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.patch = true;
      }
  #line 5875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 167:
  #line 1409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.sample = true;
      }
  #line 5885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 168:
  #line 1414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangClosestHitNVMask
              | EShLangAnyHitNVMask), "hitAttributeNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqHitAttrNV;
      }
  #line 5898 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 169:
  #line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask |
              EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqPayloadNV;
      }
  #line 5911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 170:
  #line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitNVMask |
              EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqPayloadInNV;
      }
  #line 5924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 171:
  #line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask |
              EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask), "callableDataNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqCallableDataNV;
      }
  #line 5937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 172:
  #line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
          parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV");
          parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.storage = EvqCallableDataInNV;
      }
  #line 5949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 173:
  #line 1453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.coherent = true;
      }
  #line 5958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 174:
  #line 1457 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
          (yyval.interm.type).qualifier.devicecoherent = true;
      }
  #line 5968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 175:
  #line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
          (yyval.interm.type).qualifier.queuefamilycoherent = true;
      }
  #line 5978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 176:
  #line 1467 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
          (yyval.interm.type).qualifier.workgroupcoherent = true;
      }
  #line 5988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 177:
  #line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
          (yyval.interm.type).qualifier.subgroupcoherent = true;
      }
  #line 5998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 178:
  #line 1477 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
          (yyval.interm.type).qualifier.nonprivate = true;
      }
  #line 6008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 179:
  #line 1482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.volatil = true;
      }
  #line 6017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 180:
  #line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.restrict = true;
      }
  #line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 181:
  #line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.readonly = true;
      }
  #line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 182:
  #line 1494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.writeonly = true;
      }
  #line 6044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 183:
  #line 1498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
          parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
          parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
          (yyval.interm.type).init((yyvsp[0].lex).loc);
      }
  #line 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 184:
  #line 1504 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
          parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
          parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
          (yyval.interm.type).init((yyvsp[-3].lex).loc);
      }
  #line 6066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 185:
  #line 1515 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc);
          (yyval.interm.type).qualifier.nonUniform = true;
      }
  #line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 186:
  #line 1522 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // TODO
      }
  #line 6083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 187:
  #line 1525 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // TODO: 4.0 semantics: subroutines
          // 1) make sure each identifier is a type declared earlier with SUBROUTINE
          // 2) save all of the identifiers for future comparison with the declared function
      }
  #line 6093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 188:
  #line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[-1].interm.type);
          (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
          (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters);
      }
  #line 6103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 189:
  #line 1539 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
          (yyval.interm.type) = (yyvsp[-2].interm.type);
          (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
          (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters);
          (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
      }
  #line 6115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 190:
  #line 1549 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[-1].lex).loc;
          (yyval.interm).arraySizes = new TArraySizes;
          (yyval.interm).arraySizes->addInnerSize();
      }
  #line 6125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 191:
  #line 1554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm).loc = (yyvsp[-2].lex).loc;
          (yyval.interm).arraySizes = new TArraySizes;
  
          TArraySize size;
          parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
          (yyval.interm).arraySizes->addInnerSize(size);
      }
  #line 6138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 192:
  #line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-2].interm);
          (yyval.interm).arraySizes->addInnerSize();
      }
  #line 6147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 193:
  #line 1566 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm) = (yyvsp[-3].interm);
  
          TArraySize size;
          parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
          (yyval.interm).arraySizes->addInnerSize(size);
      }
  #line 6159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 194:
  #line 1576 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
      }
  #line 6167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 195:
  #line 1579 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeParameters) = 0;
      }
  #line 6175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 196:
  #line 1585 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
      }
  #line 6183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 197:
  #line 1591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeParameters) = new TArraySizes;
  
          TArraySize size;
          parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
          (yyval.interm.typeParameters)->addInnerSize(size);
      }
  #line 6195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 198:
  #line 1598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
  
          TArraySize size;
          parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
          (yyval.interm.typeParameters)->addInnerSize(size);
      }
  #line 6207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 199:
  #line 1608 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtVoid;
      }
  #line 6216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 200:
  #line 1612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
      }
  #line 6225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 201:
  #line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
      }
  #line 6234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 202:
  #line 1620 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
      }
  #line 6244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 203:
  #line 1625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtBool;
      }
  #line 6253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 204:
  #line 1629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(2);
      }
  #line 6263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 205:
  #line 1634 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(3);
      }
  #line 6273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 206:
  #line 1639 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(4);
      }
  #line 6283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 207:
  #line 1644 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtBool;
          (yyval.interm.type).setVector(2);
      }
  #line 6293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 208:
  #line 1649 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtBool;
          (yyval.interm.type).setVector(3);
      }
  #line 6303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 209:
  #line 1654 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtBool;
          (yyval.interm.type).setVector(4);
      }
  #line 6313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 210:
  #line 1659 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(2);
      }
  #line 6323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 211:
  #line 1664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(3);
      }
  #line 6333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 212:
  #line 1669 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(4);
      }
  #line 6343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 213:
  #line 1674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(2);
      }
  #line 6354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 214:
  #line 1680 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(3);
      }
  #line 6365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 215:
  #line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(4);
      }
  #line 6376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 216:
  #line 1692 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 217:
  #line 1697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 218:
  #line 1702 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 219:
  #line 1707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 220:
  #line 1712 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 3);
      }
  #line 6426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 221:
  #line 1717 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 4);
      }
  #line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 222:
  #line 1722 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 2);
      }
  #line 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 223:
  #line 1727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 6456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 224:
  #line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 4);
      }
  #line 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 225:
  #line 1737 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 2);
      }
  #line 6476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 226:
  #line 1742 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 3);
      }
  #line 6486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 227:
  #line 1747 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 6496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 228:
  #line 1753 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
      }
  #line 6506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 229:
  #line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
      }
  #line 6516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 230:
  #line 1763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
      }
  #line 6526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 231:
  #line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
      }
  #line 6536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 232:
  #line 1773 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt8;
      }
  #line 6546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 233:
  #line 1778 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint8;
      }
  #line 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 234:
  #line 1783 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt16;
      }
  #line 6566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 235:
  #line 1788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint16;
      }
  #line 6576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 236:
  #line 1793 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
      }
  #line 6586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 237:
  #line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
      }
  #line 6596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 238:
  #line 1803 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt64;
      }
  #line 6606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 239:
  #line 1808 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint64;
      }
  #line 6616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 240:
  #line 1813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(2);
      }
  #line 6627 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 241:
  #line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(3);
      }
  #line 6638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 242:
  #line 1825 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(4);
      }
  #line 6649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 243:
  #line 1831 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setVector(2);
      }
  #line 6660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 244:
  #line 1837 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setVector(3);
      }
  #line 6671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 245:
  #line 1843 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setVector(4);
      }
  #line 6682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 246:
  #line 1849 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(2);
      }
  #line 6693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 247:
  #line 1855 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(3);
      }
  #line 6704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 248:
  #line 1861 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setVector(4);
      }
  #line 6715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 249:
  #line 1867 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(2);
      }
  #line 6726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 250:
  #line 1873 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(3);
      }
  #line 6737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 251:
  #line 1879 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setVector(4);
      }
  #line 6748 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 252:
  #line 1885 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt8;
          (yyval.interm.type).setVector(2);
      }
  #line 6759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 253:
  #line 1891 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt8;
          (yyval.interm.type).setVector(3);
      }
  #line 6770 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 254:
  #line 1897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt8;
          (yyval.interm.type).setVector(4);
      }
  #line 6781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 255:
  #line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt16;
          (yyval.interm.type).setVector(2);
      }
  #line 6792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 256:
  #line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt16;
          (yyval.interm.type).setVector(3);
      }
  #line 6803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 257:
  #line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt16;
          (yyval.interm.type).setVector(4);
      }
  #line 6814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 258:
  #line 1921 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(2);
      }
  #line 6825 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 259:
  #line 1927 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(3);
      }
  #line 6836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 260:
  #line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).setVector(4);
      }
  #line 6847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 261:
  #line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt64;
          (yyval.interm.type).setVector(2);
      }
  #line 6858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 262:
  #line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt64;
          (yyval.interm.type).setVector(3);
      }
  #line 6869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 263:
  #line 1951 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt64;
          (yyval.interm.type).setVector(4);
      }
  #line 6880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 264:
  #line 1957 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint8;
          (yyval.interm.type).setVector(2);
      }
  #line 6891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 265:
  #line 1963 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint8;
          (yyval.interm.type).setVector(3);
      }
  #line 6902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 266:
  #line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint8;
          (yyval.interm.type).setVector(4);
      }
  #line 6913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 267:
  #line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint16;
          (yyval.interm.type).setVector(2);
      }
  #line 6924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 268:
  #line 1981 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint16;
          (yyval.interm.type).setVector(3);
      }
  #line 6935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 269:
  #line 1987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint16;
          (yyval.interm.type).setVector(4);
      }
  #line 6946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 270:
  #line 1993 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(2);
      }
  #line 6957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 271:
  #line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(3);
      }
  #line 6968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 272:
  #line 2005 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).setVector(4);
      }
  #line 6979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 273:
  #line 2011 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint64;
          (yyval.interm.type).setVector(2);
      }
  #line 6990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 274:
  #line 2017 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint64;
          (yyval.interm.type).setVector(3);
      }
  #line 7001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 275:
  #line 2023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint64;
          (yyval.interm.type).setVector(4);
      }
  #line 7012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 276:
  #line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 277:
  #line 2035 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 278:
  #line 2041 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 279:
  #line 2047 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 280:
  #line 2053 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 3);
      }
  #line 7067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 281:
  #line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 4);
      }
  #line 7078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 282:
  #line 2065 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 2);
      }
  #line 7089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 283:
  #line 2071 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 284:
  #line 2077 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 4);
      }
  #line 7111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 285:
  #line 2083 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 2);
      }
  #line 7122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 286:
  #line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 3);
      }
  #line 7133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 287:
  #line 2095 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix");
          if (! parseContext.symbolTable.atBuiltInLevel())
              parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 288:
  #line 2101 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 289:
  #line 2107 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 290:
  #line 2113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 291:
  #line 2119 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 292:
  #line 2125 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(2, 3);
      }
  #line 7199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 293:
  #line 2131 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(2, 4);
      }
  #line 7210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 294:
  #line 2137 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(3, 2);
      }
  #line 7221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 295:
  #line 2143 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 296:
  #line 2149 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(3, 4);
      }
  #line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 297:
  #line 2155 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(4, 2);
      }
  #line 7254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 298:
  #line 2161 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(4, 3);
      }
  #line 7265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 299:
  #line 2167 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat16;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 300:
  #line 2173 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 301:
  #line 2179 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 302:
  #line 2185 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 303:
  #line 2191 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 304:
  #line 2197 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 3);
      }
  #line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 305:
  #line 2203 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(2, 4);
      }
  #line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 306:
  #line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 2);
      }
  #line 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 307:
  #line 2215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 308:
  #line 2221 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(3, 4);
      }
  #line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 309:
  #line 2227 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 2);
      }
  #line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 310:
  #line 2233 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 3);
      }
  #line 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 311:
  #line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 312:
  #line 2245 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 313:
  #line 2251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 314:
  #line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 315:
  #line 2263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 2);
      }
  #line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 316:
  #line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 3);
      }
  #line 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 317:
  #line 2275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(2, 4);
      }
  #line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 318:
  #line 2281 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 2);
      }
  #line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 319:
  #line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 3);
      }
  #line 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 320:
  #line 2293 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(3, 4);
      }
  #line 7507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 321:
  #line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 2);
      }
  #line 7518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 322:
  #line 2305 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 3);
      }
  #line 7529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 323:
  #line 2311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtDouble;
          (yyval.interm.type).setMatrix(4, 4);
      }
  #line 7540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 324:
  #line 2317 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
         (yyval.interm.type).basicType = EbtAccStructNV;
      }
  #line 7549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 325:
  #line 2321 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtAtomicUint;
      }
  #line 7559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 326:
  #line 2326 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
      }
  #line 7569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 327:
  #line 2332 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
      }
  #line 7579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 328:
  #line 2337 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
      }
  #line 7589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 329:
  #line 2342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
      }
  #line 7599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 330:
  #line 2347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
      }
  #line 7609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 331:
  #line 2352 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
      }
  #line 7619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 332:
  #line 2357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
      }
  #line 7629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 333:
  #line 2362 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
      }
  #line 7639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 334:
  #line 2368 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
      }
  #line 7649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 335:
  #line 2373 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
      }
  #line 7659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 336:
  #line 2378 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
      }
  #line 7669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 337:
  #line 2383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
      }
  #line 7679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 338:
  #line 2388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
      }
  #line 7689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 339:
  #line 2393 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
      }
  #line 7700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 340:
  #line 2399 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
      }
  #line 7711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 341:
  #line 2405 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
      }
  #line 7722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 342:
  #line 2411 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
      }
  #line 7733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 343:
  #line 2417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
      }
  #line 7744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 344:
  #line 2423 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
      }
  #line 7755 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 345:
  #line 2429 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
      }
  #line 7766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 346:
  #line 2435 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
      }
  #line 7777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 347:
  #line 2441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
      }
  #line 7788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 348:
  #line 2447 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
      }
  #line 7799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 349:
  #line 2453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
      }
  #line 7810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 350:
  #line 2459 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
      }
  #line 7821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 351:
  #line 2465 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
      }
  #line 7832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 352:
  #line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd1D);
      }
  #line 7842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 353:
  #line 2477 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd2D);
      }
  #line 7852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 354:
  #line 2482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd3D);
      }
  #line 7862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 355:
  #line 2487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, EsdCube);
      }
  #line 7872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 356:
  #line 2492 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
      }
  #line 7882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 357:
  #line 2497 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd2D);
      }
  #line 7892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 358:
  #line 2502 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd3D);
      }
  #line 7902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 359:
  #line 2507 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, EsdCube);
      }
  #line 7912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 360:
  #line 2513 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
      }
  #line 7922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 361:
  #line 2518 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
      }
  #line 7932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 362:
  #line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd1D);
      }
  #line 7942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 363:
  #line 2528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
      }
  #line 7952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 364:
  #line 2533 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
      }
  #line 7962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 365:
  #line 2538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
      }
  #line 7972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 366:
  #line 2543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true);
      }
  #line 7982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 367:
  #line 2548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
      }
  #line 7992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 368:
  #line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
      }
  #line 8002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 369:
  #line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
      }
  #line 8012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 370:
  #line 2564 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
      }
  #line 8022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 371:
  #line 2569 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
      }
  #line 8032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 372:
  #line 2574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
      }
  #line 8042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 373:
  #line 2579 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
      }
  #line 8052 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 374:
  #line 2584 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
      }
  #line 8062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 375:
  #line 2589 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
      }
  #line 8072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 376:
  #line 2594 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
      }
  #line 8082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 377:
  #line 2599 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
      }
  #line 8092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 378:
  #line 2604 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
      }
  #line 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 379:
  #line 2609 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
      }
  #line 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 380:
  #line 2614 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
      }
  #line 8122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 381:
  #line 2619 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setPureSampler(false);
      }
  #line 8132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 382:
  #line 2624 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setPureSampler(true);
      }
  #line 8142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 383:
  #line 2630 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
      }
  #line 8152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 384:
  #line 2635 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
      }
  #line 8162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 385:
  #line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
      }
  #line 8173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 386:
  #line 2646 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
      }
  #line 8184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 387:
  #line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, EsdRect);
      }
  #line 8194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 388:
  #line 2657 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, EsdRect);
      }
  #line 8204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 389:
  #line 2662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
      }
  #line 8214 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 390:
  #line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
      }
  #line 8225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 391:
  #line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
      }
  #line 8235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 392:
  #line 2678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
      }
  #line 8245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 393:
  #line 2683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
      }
  #line 8255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 394:
  #line 2688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
      }
  #line 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 395:
  #line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
      }
  #line 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 396:
  #line 2699 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
      }
  #line 8286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 397:
  #line 2704 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
      }
  #line 8296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 398:
  #line 2709 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
      }
  #line 8307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 399:
  #line 2715 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
      }
  #line 8317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 400:
  #line 2720 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
      }
  #line 8327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 401:
  #line 2725 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
      }
  #line 8337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 402:
  #line 2730 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
      }
  #line 8348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 403:
  #line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
      }
  #line 8359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 404:
  #line 2742 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
      }
  #line 8370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 405:
  #line 2748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
      }
  #line 8381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 406:
  #line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
      }
  #line 8391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 407:
  #line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
      }
  #line 8402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 408:
  #line 2765 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
      }
  #line 8413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 409:
  #line 2771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
      }
  #line 8424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 410:
  #line 2777 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
      }
  #line 8434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 411:
  #line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
      }
  #line 8444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 412:
  #line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
      }
  #line 8454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 413:
  #line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
      }
  #line 8464 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 414:
  #line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
      }
  #line 8474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 415:
  #line 2802 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
      }
  #line 8485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 416:
  #line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
      }
  #line 8495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 417:
  #line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
      }
  #line 8505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 418:
  #line 2818 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
      }
  #line 8515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 419:
  #line 2823 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
      }
  #line 8526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 420:
  #line 2829 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
      }
  #line 8536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 421:
  #line 2834 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
      }
  #line 8546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 422:
  #line 2839 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
      }
  #line 8556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 423:
  #line 2844 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
      }
  #line 8567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 424:
  #line 2850 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
      }
  #line 8577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 425:
  #line 2855 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
      }
  #line 8587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 426:
  #line 2860 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
      }
  #line 8597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 427:
  #line 2865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
      }
  #line 8608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 428:
  #line 2871 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
      }
  #line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 429:
  #line 2876 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
      }
  #line 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 430:
  #line 2881 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
      }
  #line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 431:
  #line 2886 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
      }
  #line 8649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 432:
  #line 2892 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
      }
  #line 8659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 433:
  #line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
      }
  #line 8669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 434:
  #line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
      }
  #line 8679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 435:
  #line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
      }
  #line 8690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 436:
  #line 2913 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
      }
  #line 8700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 437:
  #line 2918 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
      }
  #line 8710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 438:
  #line 2923 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
      }
  #line 8720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 439:
  #line 2928 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
      }
  #line 8731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 440:
  #line 2934 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
      }
  #line 8741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 441:
  #line 2939 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
      }
  #line 8751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 442:
  #line 2944 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
      }
  #line 8761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 443:
  #line 2949 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
      }
  #line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 444:
  #line 2955 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
      }
  #line 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 445:
  #line 2960 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
      }
  #line 8792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 446:
  #line 2965 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
      }
  #line 8802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 447:
  #line 2970 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
      }
  #line 8813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 448:
  #line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
      }
  #line 8823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 449:
  #line 2981 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
      }
  #line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 450:
  #line 2986 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
      }
  #line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 451:
  #line 2991 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
      }
  #line 8854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 452:
  #line 2997 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
      }
  #line 8864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 453:
  #line 3002 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
      }
  #line 8874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 454:
  #line 3007 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
      }
  #line 8884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 455:
  #line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
      }
  #line 8895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 456:
  #line 3018 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
      }
  #line 8905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 457:
  #line 3023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
      }
  #line 8915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 458:
  #line 3028 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
      }
  #line 8925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 459:
  #line 3033 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
      }
  #line 8936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 460:
  #line 3039 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
      }
  #line 8946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 461:
  #line 3044 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
      }
  #line 8956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 462:
  #line 3049 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true);
      }
  #line 8966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 463:
  #line 3054 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
      }
  #line 8977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 464:
  #line 3060 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
      }
  #line 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 465:
  #line 3065 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
      }
  #line 8997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 466:
  #line 3070 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
      }
  #line 9007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 467:
  #line 3075 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
      }
  #line 9018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 468:
  #line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
      }
  #line 9028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 469:
  #line 3086 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
      }
  #line 9038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 470:
  #line 3091 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
      }
  #line 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 471:
  #line 3096 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
      }
  #line 9059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 472:
  #line 3102 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
      }
  #line 9069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 473:
  #line 3107 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
      }
  #line 9079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 474:
  #line 3112 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {  // GL_OES_EGL_image_external
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
          (yyval.interm.type).sampler.external = true;
      }
  #line 9090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 475:
  #line 3118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { // GL_EXT_YUV_target
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
          (yyval.interm.type).sampler.yuv = true;
      }
  #line 9101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 476:
  #line 3124 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtFloat);
      }
  #line 9112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 477:
  #line 3130 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
      }
  #line 9123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 478:
  #line 3136 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtFloat16);
      }
  #line 9135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 479:
  #line 3143 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
      }
  #line 9147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 480:
  #line 3150 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtInt);
      }
  #line 9158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 481:
  #line 3156 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtInt, true);
      }
  #line 9169 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 482:
  #line 3162 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtUint);
      }
  #line 9180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 483:
  #line 3168 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtSampler;
          (yyval.interm.type).sampler.setSubpass(EbtUint, true);
      }
  #line 9191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 484:
  #line 3174 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtFloat;
          (yyval.interm.type).coopmat = true;
      }
  #line 9202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 485:
  #line 3180 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtInt;
          (yyval.interm.type).coopmat = true;
      }
  #line 9213 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 486:
  #line 3186 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel());
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          (yyval.interm.type).basicType = EbtUint;
          (yyval.interm.type).coopmat = true;
      }
  #line 9224 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 487:
  #line 3193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.type) = (yyvsp[0].interm.type);
          (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
          parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
      }
  #line 9234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 488:
  #line 3198 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          //
          // This is for user defined type names.  The lexical phase looked up the
          // type.
          //
          if (const TVariable* variable = ((yyvsp[0].lex).symbol)->getAsVariable()) {
              const TType& structure = variable->getType();
              (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
              (yyval.interm.type).basicType = EbtStruct;
              (yyval.interm.type).userDef = &structure;
          } else
              parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
      }
  #line 9252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 489:
  #line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
      }
  #line 9262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 490:
  #line 3219 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
      }
  #line 9272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 491:
  #line 3224 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
          (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
          parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
      }
  #line 9282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 492:
  #line 3232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
  #line 9288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 493:
  #line 3232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
          parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
          TVariable* userTypeDef = new TVariable((yyvsp[-4].lex).string, *structure, true);
          if (! parseContext.symbolTable.insert(*userTypeDef))
              parseContext.error((yyvsp[-4].lex).loc, "redefinition", (yyvsp[-4].lex).string->c_str(), "struct");
          (yyval.interm.type).init((yyvsp[-5].lex).loc);
          (yyval.interm.type).basicType = EbtStruct;
          (yyval.interm.type).userDef = structure;
          --parseContext.structNestingLevel;
      }
  #line 9304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 494:
  #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
  #line 9310 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 495:
  #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
          (yyval.interm.type).init((yyvsp[-4].lex).loc);
          (yyval.interm.type).basicType = EbtStruct;
          (yyval.interm.type).userDef = structure;
          --parseContext.structNestingLevel;
      }
  #line 9322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 496:
  #line 3253 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
      }
  #line 9330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 497:
  #line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
          for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
              for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
                  if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName())
                      parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str());
              }
              (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
          }
      }
  #line 9345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 498:
  #line 3269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-2].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
              if (parseContext.isEsProfile())
                  parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
          }
  
          (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
  
          parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
          parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
  
          for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
              TType type((yyvsp[-2].interm.type));
              type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
              type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
              type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
              parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
              (*(yyval.interm.typeList))[i].type->shallowCopy(type);
          }
      }
  #line 9372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 499:
  #line 3291 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-2].interm.type).arraySizes) {
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
              parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
              if (parseContext.isEsProfile())
                  parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
          }
  
          (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
  
          parseContext.memberQualifierCheck((yyvsp[-3].interm.type));
          parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
          parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true);
          parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
  
          for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
              TType type((yyvsp[-2].interm.type));
              type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
              type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
              type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
              parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
              (*(yyval.interm.typeList))[i].type->shallowCopy(type);
          }
      }
  #line 9401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 500:
  #line 3318 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeList) = new TTypeList;
          (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
      }
  #line 9410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 501:
  #line 3322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
      }
  #line 9418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 502:
  #line 3328 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.typeLine).type = new TType(EbtVoid);
          (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
          (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
      }
  #line 9428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 503:
  #line 3333 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
  
          (yyval.interm.typeLine).type = new TType(EbtVoid);
          (yyval.interm.typeLine).loc = (yyvsp[-1].lex).loc;
          (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
          (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
      }
  #line 9441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 504:
  #line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 9449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 505:
  #line 3348 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          const char* initFeature = "{ } style initializers";
          parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
          parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
          (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
      }
  #line 9460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 506:
  #line 3354 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          const char* initFeature = "{ } style initializers";
          parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
          parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
          (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
      }
  #line 9471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 507:
  #line 3365 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
      }
  #line 9479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 508:
  #line 3368 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
      }
  #line 9487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 509:
  #line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 510:
  #line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 511:
  #line 3380 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 512:
  #line 3386 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 513:
  #line 3387 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 514:
  #line 3388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9523 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 515:
  #line 3389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 516:
  #line 3390 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 517:
  #line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 518:
  #line 3392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 519:
  #line 3394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 520:
  #line 3400 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote");
          parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote");
          (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc);
      }
  #line 9563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 521:
  #line 3409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = 0; }
  #line 9569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 522:
  #line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.push();
          ++parseContext.statementNestingLevel;
      }
  #line 9578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 523:
  #line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          --parseContext.statementNestingLevel;
      }
  #line 9587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 524:
  #line 3418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate())
              (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
          (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
      }
  #line 9597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 525:
  #line 3426 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 526:
  #line 3427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
  #line 9609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 527:
  #line 3431 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          ++parseContext.controlFlowNestingLevel;
      }
  #line 9617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 528:
  #line 3434 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          --parseContext.controlFlowNestingLevel;
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 529:
  #line 3438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.push();
          ++parseContext.statementNestingLevel;
          ++parseContext.controlFlowNestingLevel;
      }
  #line 9636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 530:
  #line 3443 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          --parseContext.statementNestingLevel;
          --parseContext.controlFlowNestingLevel;
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 531:
  #line 3452 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = 0;
      }
  #line 9655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 532:
  #line 3455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate())
              (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
          (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
      }
  #line 9665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 533:
  #line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
          if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                              (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
              parseContext.wrapupSwitchSubsequence(0, (yyvsp[0].interm.intermNode));
              (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
          }
      }
  #line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 534:
  #line 3471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
                                              (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
              parseContext.wrapupSwitchSubsequence((yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0, (yyvsp[0].interm.intermNode));
              (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
          } else
              (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
      }
  #line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 535:
  #line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = 0; }
  #line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 536:
  #line 3483 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
  #line 9703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 537:
  #line 3487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 538:
  #line 3491 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 539:
  #line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
          (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
      }
  #line 9729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 540:
  #line 3505 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
          (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
      }
  #line 9738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 541:
  #line 3509 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
          (yyval.interm.nodePair).node2 = 0;
      }
  #line 9747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 542:
  #line 3517 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
          parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
      }
  #line 9756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 543:
  #line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
  
          TType type((yyvsp[-3].interm.type));
          TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
          if (initNode)
              (yyval.interm.intermTypedNode) = initNode->getAsTyped();
          else
              (yyval.interm.intermTypedNode) = 0;
      }
  #line 9771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 544:
  #line 3534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 545:
  #line 3538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 546:
  #line 3545 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          // start new switch sequence on the switch stack
          ++parseContext.controlFlowNestingLevel;
          ++parseContext.statementNestingLevel;
          parseContext.switchSequenceStack.push_back(new TIntermSequence);
          parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
          parseContext.symbolTable.push();
      }
  #line 9801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 547:
  #line 3553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
          delete parseContext.switchSequenceStack.back();
          parseContext.switchSequenceStack.pop_back();
          parseContext.switchLevel.pop_back();
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          --parseContext.statementNestingLevel;
          --parseContext.controlFlowNestingLevel;
      }
  #line 9815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 548:
  #line 3565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = 0;
      }
  #line 9823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 549:
  #line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 550:
  #line 3574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = 0;
          if (parseContext.switchLevel.size() == 0)
              parseContext.error((yyvsp[-2].lex).loc, "cannot appear outside switch statement", "case", "");
          else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
              parseContext.error((yyvsp[-2].lex).loc, "cannot be nested inside control flow", "case", "");
          else {
              parseContext.constantValueCheck((yyvsp[-1].interm.intermTypedNode), "case");
              parseContext.integerCheck((yyvsp[-1].interm.intermTypedNode), "case");
              (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
          }
      }
  #line 9848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 551:
  #line 3586 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = 0;
          if (parseContext.switchLevel.size() == 0)
              parseContext.error((yyvsp[-1].lex).loc, "cannot appear outside switch statement", "default", "");
          else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
              parseContext.error((yyvsp[-1].lex).loc, "cannot be nested inside control flow", "default", "");
          else
              (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
      }
  #line 9862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 552:
  #line 3598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 553:
  #line 3602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 554:
  #line 3609 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if (! parseContext.limits.whileLoops)
              parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
          parseContext.symbolTable.push();
          ++parseContext.loopNestingLevel;
          ++parseContext.statementNestingLevel;
          ++parseContext.controlFlowNestingLevel;
      }
  #line 9892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 555:
  #line 3617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc);
          --parseContext.loopNestingLevel;
          --parseContext.statementNestingLevel;
          --parseContext.controlFlowNestingLevel;
      }
  #line 9904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 556:
  #line 3624 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          ++parseContext.loopNestingLevel;
          ++parseContext.statementNestingLevel;
          ++parseContext.controlFlowNestingLevel;
      }
  #line 9914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 557:
  #line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if (! parseContext.limits.whileLoops)
              parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
  
          parseContext.boolCheck((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode));
  
          (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[-5].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, false, (yyvsp[-4].lex).loc);
          --parseContext.loopNestingLevel;
          --parseContext.statementNestingLevel;
          --parseContext.controlFlowNestingLevel;
      }
  #line 9930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 558:
  #line 3640 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.push();
          ++parseContext.loopNestingLevel;
          ++parseContext.statementNestingLevel;
          ++parseContext.controlFlowNestingLevel;
      }
  #line 9941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 559:
  #line 3646 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
          TIntermLoop* forLoop = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node2), true, (yyvsp[-6].lex).loc);
          if (! parseContext.limits.nonInductiveForLoops)
              parseContext.inductiveLoopCheck((yyvsp[-6].lex).loc, (yyvsp[-3].interm.intermNode), forLoop);
          (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyval.interm.intermNode), forLoop, (yyvsp[-6].lex).loc);
          (yyval.interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
          --parseContext.loopNestingLevel;
          --parseContext.statementNestingLevel;
          --parseContext.controlFlowNestingLevel;
      }
  #line 9958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 560:
  #line 3661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 561:
  #line 3664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 9974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 562:
  #line 3670 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
      }
  #line 9982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 563:
  #line 3673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermTypedNode) = 0;
      }
  #line 9990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 564:
  #line 3679 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
          (yyval.interm.nodePair).node2 = 0;
      }
  #line 9999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 565:
  #line 3683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
          (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
      }
  #line 10008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 566:
  #line 3690 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if (parseContext.loopNestingLevel <= 0)
              parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
          (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
      }
  #line 10018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 567:
  #line 3695 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
              parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
          (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
      }
  #line 10028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 568:
  #line 3700 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
          if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
              parseContext.error((yyvsp[-1].lex).loc, "non-void function must return a value", "return", "");
          if (parseContext.inMain)
              parseContext.postEntryPointReturn = true;
      }
  #line 10040 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 569:
  #line 3707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
      }
  #line 10048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 570:
  #line 3710 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
          (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
      }
  #line 10057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 571:
  #line 3719 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
          parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
      }
  #line 10066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 572:
  #line 3723 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          if ((yyvsp[0].interm.intermNode) != nullptr) {
              (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
              parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
          }
      }
  #line 10077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 573:
  #line 3732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 10085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 574:
  #line 3735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
      }
  #line 10093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 575:
  #line 3739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
          parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
          (yyval.interm.intermNode) = nullptr;
      }
  #line 10103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 576:
  #line 3748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
          (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
      }
  #line 10112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 577:
  #line 3752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          //   May be best done as post process phase on intermediate code
          if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
              parseContext.error((yyvsp[-2].interm).loc, "function does not return a value:", "", (yyvsp[-2].interm).function->getName().c_str());
          parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
          (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermNode));
          parseContext.intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[-2].interm).function->getType(), (yyvsp[-2].interm).loc);
          (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[-2].interm).function->getMangledName().c_str());
  
          // store the pragma information for debug and optimize and other vendor specific
          // information. This information can be queried from the parse tree
          (yyval.interm.intermNode)->getAsAggregate()->setOptimize(parseContext.contextPragma.optimize);
          (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
          (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
      }
  #line 10132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 578:
  #line 3771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
          parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute");
      }
  #line 10141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 579:
  #line 3777 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
      }
  #line 10149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 580:
  #line 3780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
      }
  #line 10157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 581:
  #line 3785 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
      }
  #line 10165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
    case 582:
  #line 3788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
      {
          (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
      }
  #line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
      break;
  
  
  #line 10177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
        default: break;
      }
    /* User semantic actions sometimes alter yychar, and that requires
       that yytoken be updated with the new translation.  We take the
       approach of translating immediately before every use of yytoken.
       One alternative is translating here after every semantic action,
       but that translation would be missed if the semantic action invokes
       YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
       if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
       incorrect destructor might then be invoked immediately.  In the
       case of YYERROR or YYBACKUP, subsequent parser actions might lead
       to an incorrect destructor call or verbose syntax error message
       before the lookahead is translated.  */
    YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
  
    YYPOPSTACK (yylen);
    yylen = 0;
    YY_STACK_PRINT (yyss, yyssp);
  
    *++yyvsp = yyval;
  
    /* Now 'shift' the result of the reduction.  Determine what state
       that goes to, based on the state we popped back to and the rule
       number reduced by.  */
  
    yyn = yyr1[yyn];
  
    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
      yystate = yytable[yystate];
    else
      yystate = yydefgoto[yyn - YYNTOKENS];
  
    goto yynewstate;
  
  
  /*--------------------------------------.
  | yyerrlab -- here on detecting error.  |
  `--------------------------------------*/
  yyerrlab:
    /* Make sure we have latest lookahead translation.  See comments at
       user semantic actions for why this is necessary.  */
    yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
  
    /* If not already recovering from an error, report this error.  */
    if (!yyerrstatus)
      {
        ++yynerrs;
  #if ! YYERROR_VERBOSE
        yyerror (pParseContext, YY_("syntax error"));
  #else
  # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                          yyssp, yytoken)
        {
          char const *yymsgp = YY_("syntax error");
          int yysyntax_error_status;
          yysyntax_error_status = YYSYNTAX_ERROR;
          if (yysyntax_error_status == 0)
            yymsgp = yymsg;
          else if (yysyntax_error_status == 1)
            {
              if (yymsg != yymsgbuf)
                YYSTACK_FREE (yymsg);
              yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
              if (!yymsg)
                {
                  yymsg = yymsgbuf;
                  yymsg_alloc = sizeof yymsgbuf;
                  yysyntax_error_status = 2;
                }
              else
                {
                  yysyntax_error_status = YYSYNTAX_ERROR;
                  yymsgp = yymsg;
                }
            }
          yyerror (pParseContext, yymsgp);
          if (yysyntax_error_status == 2)
            goto yyexhaustedlab;
        }
  # undef YYSYNTAX_ERROR
  #endif
      }
  
  
  
    if (yyerrstatus == 3)
      {
        /* If just tried and failed to reuse lookahead token after an
           error, discard it.  */
  
        if (yychar <= YYEOF)
          {
            /* Return failure if at end of input.  */
            if (yychar == YYEOF)
              YYABORT;
          }
        else
          {
            yydestruct ("Error: discarding",
                        yytoken, &yylval, pParseContext);
            yychar = YYEMPTY;
          }
      }
  
    /* Else will try to reuse lookahead token after shifting the error
       token.  */
    goto yyerrlab1;
  
  
  /*---------------------------------------------------.
  | yyerrorlab -- error raised explicitly by YYERROR.  |
  `---------------------------------------------------*/
  yyerrorlab:
  
    /* Pacify compilers like GCC when the user code never invokes
       YYERROR and the label yyerrorlab therefore never appears in user
       code.  */
    if (/*CONSTCOND*/ 0)
       goto yyerrorlab;
  
    /* Do not reclaim the symbols of the rule whose action triggered
       this YYERROR.  */
    YYPOPSTACK (yylen);
    yylen = 0;
    YY_STACK_PRINT (yyss, yyssp);
    yystate = *yyssp;
    goto yyerrlab1;
  
  
  /*-------------------------------------------------------------.
  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  `-------------------------------------------------------------*/
  yyerrlab1:
    yyerrstatus = 3;      /* Each real token shifted decrements this.  */
  
    for (;;)
      {
        yyn = yypact[yystate];
        if (!yypact_value_is_default (yyn))
          {
            yyn += YYTERROR;
            if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
              {
                yyn = yytable[yyn];
                if (0 < yyn)
                  break;
              }
          }
  
        /* Pop the current state because it cannot handle the error token.  */
        if (yyssp == yyss)
          YYABORT;
  
  
        yydestruct ("Error: popping",
                    yystos[yystate], yyvsp, pParseContext);
        YYPOPSTACK (1);
        yystate = *yyssp;
        YY_STACK_PRINT (yyss, yyssp);
      }
  
    YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
    *++yyvsp = yylval;
    YY_IGNORE_MAYBE_UNINITIALIZED_END
  
  
    /* Shift the error token.  */
    YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
  
    yystate = yyn;
    goto yynewstate;
  
  
  /*-------------------------------------.
  | yyacceptlab -- YYACCEPT comes here.  |
  `-------------------------------------*/
  yyacceptlab:
    yyresult = 0;
    goto yyreturn;
  
  /*-----------------------------------.
  | yyabortlab -- YYABORT comes here.  |
  `-----------------------------------*/
  yyabortlab:
    yyresult = 1;
    goto yyreturn;
  
  #if !defined yyoverflow || YYERROR_VERBOSE
  /*-------------------------------------------------.
  | yyexhaustedlab -- memory exhaustion comes here.  |
  `-------------------------------------------------*/
  yyexhaustedlab:
    yyerror (pParseContext, YY_("memory exhausted"));
    yyresult = 2;
    /* Fall through.  */
  #endif
  
  yyreturn:
    if (yychar != YYEMPTY)
      {
        /* Make sure we have latest lookahead translation.  See comments at
           user semantic actions for why this is necessary.  */
        yytoken = YYTRANSLATE (yychar);
        yydestruct ("Cleanup: discarding lookahead",
                    yytoken, &yylval, pParseContext);
      }
    /* Do not reclaim the symbols of the rule whose action triggered
       this YYABORT or YYACCEPT.  */
    YYPOPSTACK (yylen);
    YY_STACK_PRINT (yyss, yyssp);
    while (yyssp != yyss)
      {
        yydestruct ("Cleanup: popping",
                    yystos[*yyssp], yyvsp, pParseContext);
        YYPOPSTACK (1);
      }
  #ifndef yyoverflow
    if (yyss != yyssa)
      YYSTACK_FREE (yyss);
  #endif
  #if YYERROR_VERBOSE
    if (yymsg != yymsgbuf)
      YYSTACK_FREE (yymsg);
  #endif
    return yyresult;
  }
  #line 3793 "MachineIndependent/glslang.y" /* yacc.c:1906  */
  
  