1 /* A Bison parser, made by GNU Bison 3.0.4.  */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5    Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6 
7    This program is free software: you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation, either version 3 of the License, or
10    (at your option) any later version.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19 
20 /* As a special exception, you may create a larger work that contains
21    part or all of the Bison parser skeleton and distribute that work
22    under terms of your choice, so long as that work isn't itself a
23    parser generator using the skeleton or a modified version thereof
24    as a parser skeleton.  Alternatively, if you modify or redistribute
25    the parser skeleton itself, you may (at your option) remove this
26    special exception, which will cause the skeleton and the resulting
27    Bison output files to be licensed under the GNU General Public
28    License without this special exception.
29 
30    This special exception was added by the Free Software Foundation in
31    version 2.2 of Bison.  */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34    simplifying the original so-called "semantic" parser.  */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37    infringing on user name space.  This should be done even for local
38    variables, as they might otherwise be expanded by user macros.
39    There are some unavoidable exceptions within include files to
40    define necessary library symbols; they are noted "INFRINGES ON
41    USER NAME SPACE" below.  */
42 
43 /* Identify Bison output.  */
44 #define YYBISON 1
45 
46 /* Bison version.  */
47 #define YYBISON_VERSION "3.0.4"
48 
49 /* Skeleton name.  */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers.  */
53 #define YYPURE 1
54 
55 /* Push parsers.  */
56 #define YYPUSH 0
57 
58 /* Pull parsers.  */
59 #define YYPULL 1
60 
61 
62 
63 
64 /* Copy the first part of user declarations.  */
65 #line 68 "MachineIndependent/glslang.y" /* yacc.c:339  */
66 
67 
68 /* Based on:
69 ANSI C Yacc grammar
70 
71 In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a
72 matching Lex specification) for the April 30, 1985 draft version of the
73 ANSI C standard.  Tom Stockfisch reposted it to net.sources in 1987; that
74 original, as mentioned in the answer to question 17.25 of the comp.lang.c
75 FAQ, can be ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
76 
77 I intend to keep this version as close to the current C Standard grammar as
78 possible; please let me know if you discover discrepancies.
79 
80 Jutta Degener, 1995
81 */
82 
83 #include "SymbolTable.h"
84 #include "ParseHelper.h"
85 #include "../Public/ShaderLang.h"
86 #include "attribute.h"
87 
88 using namespace glslang;
89 
90 
91 #line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339  */
92 
93 # ifndef YY_NULLPTR
94 #  if defined __cplusplus && 201103L <= __cplusplus
95 #   define YY_NULLPTR nullptr
96 #  else
97 #   define YY_NULLPTR 0
98 #  endif
99 # endif
100 
101 /* Enabling verbose error messages.  */
102 #ifdef YYERROR_VERBOSE
103 # undef YYERROR_VERBOSE
104 # define YYERROR_VERBOSE 1
105 #else
106 # define YYERROR_VERBOSE 1
107 #endif
108 
109 /* In a future release of Bison, this section will be replaced
110    by #include "glslang_tab.cpp.h".  */
111 #ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
112 # define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
113 /* Debug traces.  */
114 #ifndef YYDEBUG
115 # define YYDEBUG 1
116 #endif
117 #if YYDEBUG
118 extern int yydebug;
119 #endif
120 
121 /* Token type.  */
122 #ifndef YYTOKENTYPE
123 # define YYTOKENTYPE
124   enum yytokentype
125   {
126     CONST = 258,
127     BOOL = 259,
128     INT = 260,
129     UINT = 261,
130     FLOAT = 262,
131     BVEC2 = 263,
132     BVEC3 = 264,
133     BVEC4 = 265,
134     IVEC2 = 266,
135     IVEC3 = 267,
136     IVEC4 = 268,
137     UVEC2 = 269,
138     UVEC3 = 270,
139     UVEC4 = 271,
140     VEC2 = 272,
141     VEC3 = 273,
142     VEC4 = 274,
143     MAT2 = 275,
144     MAT3 = 276,
145     MAT4 = 277,
146     MAT2X2 = 278,
147     MAT2X3 = 279,
148     MAT2X4 = 280,
149     MAT3X2 = 281,
150     MAT3X3 = 282,
151     MAT3X4 = 283,
152     MAT4X2 = 284,
153     MAT4X3 = 285,
154     MAT4X4 = 286,
155     SAMPLER2D = 287,
156     SAMPLER3D = 288,
157     SAMPLERCUBE = 289,
158     SAMPLER2DSHADOW = 290,
159     SAMPLERCUBESHADOW = 291,
160     SAMPLER2DARRAY = 292,
161     SAMPLER2DARRAYSHADOW = 293,
162     ISAMPLER2D = 294,
163     ISAMPLER3D = 295,
164     ISAMPLERCUBE = 296,
165     ISAMPLER2DARRAY = 297,
166     USAMPLER2D = 298,
167     USAMPLER3D = 299,
168     USAMPLERCUBE = 300,
169     USAMPLER2DARRAY = 301,
170     SAMPLER = 302,
171     SAMPLERSHADOW = 303,
172     TEXTURE2D = 304,
173     TEXTURE3D = 305,
174     TEXTURECUBE = 306,
175     TEXTURE2DARRAY = 307,
176     ITEXTURE2D = 308,
177     ITEXTURE3D = 309,
178     ITEXTURECUBE = 310,
179     ITEXTURE2DARRAY = 311,
180     UTEXTURE2D = 312,
181     UTEXTURE3D = 313,
182     UTEXTURECUBE = 314,
183     UTEXTURE2DARRAY = 315,
184     ATTRIBUTE = 316,
185     VARYING = 317,
186     FLOAT16_T = 318,
187     FLOAT32_T = 319,
188     DOUBLE = 320,
189     FLOAT64_T = 321,
190     INT64_T = 322,
191     UINT64_T = 323,
192     INT32_T = 324,
193     UINT32_T = 325,
194     INT16_T = 326,
195     UINT16_T = 327,
196     INT8_T = 328,
197     UINT8_T = 329,
198     I64VEC2 = 330,
199     I64VEC3 = 331,
200     I64VEC4 = 332,
201     U64VEC2 = 333,
202     U64VEC3 = 334,
203     U64VEC4 = 335,
204     I32VEC2 = 336,
205     I32VEC3 = 337,
206     I32VEC4 = 338,
207     U32VEC2 = 339,
208     U32VEC3 = 340,
209     U32VEC4 = 341,
210     I16VEC2 = 342,
211     I16VEC3 = 343,
212     I16VEC4 = 344,
213     U16VEC2 = 345,
214     U16VEC3 = 346,
215     U16VEC4 = 347,
216     I8VEC2 = 348,
217     I8VEC3 = 349,
218     I8VEC4 = 350,
219     U8VEC2 = 351,
220     U8VEC3 = 352,
221     U8VEC4 = 353,
222     DVEC2 = 354,
223     DVEC3 = 355,
224     DVEC4 = 356,
225     DMAT2 = 357,
226     DMAT3 = 358,
227     DMAT4 = 359,
228     F16VEC2 = 360,
229     F16VEC3 = 361,
230     F16VEC4 = 362,
231     F16MAT2 = 363,
232     F16MAT3 = 364,
233     F16MAT4 = 365,
234     F32VEC2 = 366,
235     F32VEC3 = 367,
236     F32VEC4 = 368,
237     F32MAT2 = 369,
238     F32MAT3 = 370,
239     F32MAT4 = 371,
240     F64VEC2 = 372,
241     F64VEC3 = 373,
242     F64VEC4 = 374,
243     F64MAT2 = 375,
244     F64MAT3 = 376,
245     F64MAT4 = 377,
246     DMAT2X2 = 378,
247     DMAT2X3 = 379,
248     DMAT2X4 = 380,
249     DMAT3X2 = 381,
250     DMAT3X3 = 382,
251     DMAT3X4 = 383,
252     DMAT4X2 = 384,
253     DMAT4X3 = 385,
254     DMAT4X4 = 386,
255     F16MAT2X2 = 387,
256     F16MAT2X3 = 388,
257     F16MAT2X4 = 389,
258     F16MAT3X2 = 390,
259     F16MAT3X3 = 391,
260     F16MAT3X4 = 392,
261     F16MAT4X2 = 393,
262     F16MAT4X3 = 394,
263     F16MAT4X4 = 395,
264     F32MAT2X2 = 396,
265     F32MAT2X3 = 397,
266     F32MAT2X4 = 398,
267     F32MAT3X2 = 399,
268     F32MAT3X3 = 400,
269     F32MAT3X4 = 401,
270     F32MAT4X2 = 402,
271     F32MAT4X3 = 403,
272     F32MAT4X4 = 404,
273     F64MAT2X2 = 405,
274     F64MAT2X3 = 406,
275     F64MAT2X4 = 407,
276     F64MAT3X2 = 408,
277     F64MAT3X3 = 409,
278     F64MAT3X4 = 410,
279     F64MAT4X2 = 411,
280     F64MAT4X3 = 412,
281     F64MAT4X4 = 413,
282     ATOMIC_UINT = 414,
283     ACCSTRUCTNV = 415,
284     FCOOPMATNV = 416,
285     ICOOPMATNV = 417,
286     UCOOPMATNV = 418,
287     SAMPLERCUBEARRAY = 419,
288     SAMPLERCUBEARRAYSHADOW = 420,
289     ISAMPLERCUBEARRAY = 421,
290     USAMPLERCUBEARRAY = 422,
291     SAMPLER1D = 423,
292     SAMPLER1DARRAY = 424,
293     SAMPLER1DARRAYSHADOW = 425,
294     ISAMPLER1D = 426,
295     SAMPLER1DSHADOW = 427,
296     SAMPLER2DRECT = 428,
297     SAMPLER2DRECTSHADOW = 429,
298     ISAMPLER2DRECT = 430,
299     USAMPLER2DRECT = 431,
300     SAMPLERBUFFER = 432,
301     ISAMPLERBUFFER = 433,
302     USAMPLERBUFFER = 434,
303     SAMPLER2DMS = 435,
304     ISAMPLER2DMS = 436,
305     USAMPLER2DMS = 437,
306     SAMPLER2DMSARRAY = 438,
307     ISAMPLER2DMSARRAY = 439,
308     USAMPLER2DMSARRAY = 440,
309     SAMPLEREXTERNALOES = 441,
310     SAMPLEREXTERNAL2DY2YEXT = 442,
311     ISAMPLER1DARRAY = 443,
312     USAMPLER1D = 444,
313     USAMPLER1DARRAY = 445,
314     F16SAMPLER1D = 446,
315     F16SAMPLER2D = 447,
316     F16SAMPLER3D = 448,
317     F16SAMPLER2DRECT = 449,
318     F16SAMPLERCUBE = 450,
319     F16SAMPLER1DARRAY = 451,
320     F16SAMPLER2DARRAY = 452,
321     F16SAMPLERCUBEARRAY = 453,
322     F16SAMPLERBUFFER = 454,
323     F16SAMPLER2DMS = 455,
324     F16SAMPLER2DMSARRAY = 456,
325     F16SAMPLER1DSHADOW = 457,
326     F16SAMPLER2DSHADOW = 458,
327     F16SAMPLER1DARRAYSHADOW = 459,
328     F16SAMPLER2DARRAYSHADOW = 460,
329     F16SAMPLER2DRECTSHADOW = 461,
330     F16SAMPLERCUBESHADOW = 462,
331     F16SAMPLERCUBEARRAYSHADOW = 463,
332     IMAGE1D = 464,
333     IIMAGE1D = 465,
334     UIMAGE1D = 466,
335     IMAGE2D = 467,
336     IIMAGE2D = 468,
337     UIMAGE2D = 469,
338     IMAGE3D = 470,
339     IIMAGE3D = 471,
340     UIMAGE3D = 472,
341     IMAGE2DRECT = 473,
342     IIMAGE2DRECT = 474,
343     UIMAGE2DRECT = 475,
344     IMAGECUBE = 476,
345     IIMAGECUBE = 477,
346     UIMAGECUBE = 478,
347     IMAGEBUFFER = 479,
348     IIMAGEBUFFER = 480,
349     UIMAGEBUFFER = 481,
350     IMAGE1DARRAY = 482,
351     IIMAGE1DARRAY = 483,
352     UIMAGE1DARRAY = 484,
353     IMAGE2DARRAY = 485,
354     IIMAGE2DARRAY = 486,
355     UIMAGE2DARRAY = 487,
356     IMAGECUBEARRAY = 488,
357     IIMAGECUBEARRAY = 489,
358     UIMAGECUBEARRAY = 490,
359     IMAGE2DMS = 491,
360     IIMAGE2DMS = 492,
361     UIMAGE2DMS = 493,
362     IMAGE2DMSARRAY = 494,
363     IIMAGE2DMSARRAY = 495,
364     UIMAGE2DMSARRAY = 496,
365     F16IMAGE1D = 497,
366     F16IMAGE2D = 498,
367     F16IMAGE3D = 499,
368     F16IMAGE2DRECT = 500,
369     F16IMAGECUBE = 501,
370     F16IMAGE1DARRAY = 502,
371     F16IMAGE2DARRAY = 503,
372     F16IMAGECUBEARRAY = 504,
373     F16IMAGEBUFFER = 505,
374     F16IMAGE2DMS = 506,
375     F16IMAGE2DMSARRAY = 507,
376     TEXTURECUBEARRAY = 508,
377     ITEXTURECUBEARRAY = 509,
378     UTEXTURECUBEARRAY = 510,
379     TEXTURE1D = 511,
380     ITEXTURE1D = 512,
381     UTEXTURE1D = 513,
382     TEXTURE1DARRAY = 514,
383     ITEXTURE1DARRAY = 515,
384     UTEXTURE1DARRAY = 516,
385     TEXTURE2DRECT = 517,
386     ITEXTURE2DRECT = 518,
387     UTEXTURE2DRECT = 519,
388     TEXTUREBUFFER = 520,
389     ITEXTUREBUFFER = 521,
390     UTEXTUREBUFFER = 522,
391     TEXTURE2DMS = 523,
392     ITEXTURE2DMS = 524,
393     UTEXTURE2DMS = 525,
394     TEXTURE2DMSARRAY = 526,
395     ITEXTURE2DMSARRAY = 527,
396     UTEXTURE2DMSARRAY = 528,
397     F16TEXTURE1D = 529,
398     F16TEXTURE2D = 530,
399     F16TEXTURE3D = 531,
400     F16TEXTURE2DRECT = 532,
401     F16TEXTURECUBE = 533,
402     F16TEXTURE1DARRAY = 534,
403     F16TEXTURE2DARRAY = 535,
404     F16TEXTURECUBEARRAY = 536,
405     F16TEXTUREBUFFER = 537,
406     F16TEXTURE2DMS = 538,
407     F16TEXTURE2DMSARRAY = 539,
408     SUBPASSINPUT = 540,
409     SUBPASSINPUTMS = 541,
410     ISUBPASSINPUT = 542,
411     ISUBPASSINPUTMS = 543,
412     USUBPASSINPUT = 544,
413     USUBPASSINPUTMS = 545,
414     F16SUBPASSINPUT = 546,
415     F16SUBPASSINPUTMS = 547,
416     LEFT_OP = 548,
417     RIGHT_OP = 549,
418     INC_OP = 550,
419     DEC_OP = 551,
420     LE_OP = 552,
421     GE_OP = 553,
422     EQ_OP = 554,
423     NE_OP = 555,
424     AND_OP = 556,
425     OR_OP = 557,
426     XOR_OP = 558,
427     MUL_ASSIGN = 559,
428     DIV_ASSIGN = 560,
429     ADD_ASSIGN = 561,
430     MOD_ASSIGN = 562,
431     LEFT_ASSIGN = 563,
432     RIGHT_ASSIGN = 564,
433     AND_ASSIGN = 565,
434     XOR_ASSIGN = 566,
435     OR_ASSIGN = 567,
436     SUB_ASSIGN = 568,
437     LEFT_PAREN = 569,
438     RIGHT_PAREN = 570,
439     LEFT_BRACKET = 571,
440     RIGHT_BRACKET = 572,
441     LEFT_BRACE = 573,
442     RIGHT_BRACE = 574,
443     DOT = 575,
444     COMMA = 576,
445     COLON = 577,
446     EQUAL = 578,
447     SEMICOLON = 579,
448     BANG = 580,
449     DASH = 581,
450     TILDE = 582,
451     PLUS = 583,
452     STAR = 584,
453     SLASH = 585,
454     PERCENT = 586,
455     LEFT_ANGLE = 587,
456     RIGHT_ANGLE = 588,
457     VERTICAL_BAR = 589,
458     CARET = 590,
459     AMPERSAND = 591,
460     QUESTION = 592,
461     INVARIANT = 593,
462     HIGH_PRECISION = 594,
463     MEDIUM_PRECISION = 595,
464     LOW_PRECISION = 596,
465     PRECISION = 597,
466     PACKED = 598,
467     RESOURCE = 599,
468     SUPERP = 600,
469     FLOATCONSTANT = 601,
470     INTCONSTANT = 602,
471     UINTCONSTANT = 603,
472     BOOLCONSTANT = 604,
473     IDENTIFIER = 605,
474     TYPE_NAME = 606,
475     CENTROID = 607,
476     IN = 608,
477     OUT = 609,
478     INOUT = 610,
479     STRUCT = 611,
480     VOID = 612,
481     WHILE = 613,
482     BREAK = 614,
483     CONTINUE = 615,
484     DO = 616,
485     ELSE = 617,
486     FOR = 618,
487     IF = 619,
488     DISCARD = 620,
489     RETURN = 621,
490     SWITCH = 622,
491     CASE = 623,
492     DEFAULT = 624,
493     UNIFORM = 625,
494     SHARED = 626,
495     BUFFER = 627,
496     FLAT = 628,
497     SMOOTH = 629,
498     LAYOUT = 630,
499     DOUBLECONSTANT = 631,
500     INT16CONSTANT = 632,
501     UINT16CONSTANT = 633,
502     FLOAT16CONSTANT = 634,
503     INT32CONSTANT = 635,
504     UINT32CONSTANT = 636,
505     INT64CONSTANT = 637,
506     UINT64CONSTANT = 638,
507     SUBROUTINE = 639,
508     DEMOTE = 640,
509     PAYLOADNV = 641,
510     PAYLOADINNV = 642,
511     HITATTRNV = 643,
512     CALLDATANV = 644,
513     CALLDATAINNV = 645,
514     PATCH = 646,
515     SAMPLE = 647,
516     NONUNIFORM = 648,
517     COHERENT = 649,
518     VOLATILE = 650,
519     RESTRICT = 651,
520     READONLY = 652,
521     WRITEONLY = 653,
522     DEVICECOHERENT = 654,
523     QUEUEFAMILYCOHERENT = 655,
524     WORKGROUPCOHERENT = 656,
525     SUBGROUPCOHERENT = 657,
526     NONPRIVATE = 658,
527     NOPERSPECTIVE = 659,
528     EXPLICITINTERPAMD = 660,
529     PERVERTEXNV = 661,
530     PERPRIMITIVENV = 662,
531     PERVIEWNV = 663,
532     PERTASKNV = 664,
533     PRECISE = 665
534   };
535 #endif
536 
537 /* Value type.  */
538 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
539 
540 union YYSTYPE
541 {
542 #line 96 "MachineIndependent/glslang.y" /* yacc.c:355  */
543 
544     struct {
545         glslang::TSourceLoc loc;
546         union {
547             glslang::TString *string;
548             int i;
549             unsigned int u;
550             long long i64;
551             unsigned long long u64;
552             bool b;
553             double d;
554         };
555         glslang::TSymbol* symbol;
556     } lex;
557     struct {
558         glslang::TSourceLoc loc;
559         glslang::TOperator op;
560         union {
561             TIntermNode* intermNode;
562             glslang::TIntermNodePair nodePair;
563             glslang::TIntermTyped* intermTypedNode;
564             glslang::TAttributes* attributes;
565         };
566         union {
567             glslang::TPublicType type;
568             glslang::TFunction* function;
569             glslang::TParameter param;
570             glslang::TTypeLoc typeLine;
571             glslang::TTypeList* typeList;
572             glslang::TArraySizes* arraySizes;
573             glslang::TIdentifierList* identifierList;
574         };
575         glslang::TArraySizes* typeParameters;
576     } interm;
577 
578 #line 579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355  */
579 };
580 
581 typedef union YYSTYPE YYSTYPE;
582 # define YYSTYPE_IS_TRIVIAL 1
583 # define YYSTYPE_IS_DECLARED 1
584 #endif
585 
586 
587 
588 int yyparse (glslang::TParseContext* pParseContext);
589 
590 #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
591 
592 /* Copy the second part of user declarations.  */
593 #line 132 "MachineIndependent/glslang.y" /* yacc.c:358  */
594 
595 
596 /* windows only pragma */
597 #ifdef _MSC_VER
598     #pragma warning(disable : 4065)
599     #pragma warning(disable : 4127)
600     #pragma warning(disable : 4244)
601 #endif
602 
603 #define parseContext (*pParseContext)
604 #define yyerror(context, msg) context->parserError(msg)
605 
606 extern int yylex(YYSTYPE*, TParseContext&);
607 
608 
609 #line 610 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358  */
610 
611 #ifdef short
612 # undef short
613 #endif
614 
615 #ifdef YYTYPE_UINT8
616 typedef YYTYPE_UINT8 yytype_uint8;
617 #else
618 typedef unsigned char yytype_uint8;
619 #endif
620 
621 #ifdef YYTYPE_INT8
622 typedef YYTYPE_INT8 yytype_int8;
623 #else
624 typedef signed char yytype_int8;
625 #endif
626 
627 #ifdef YYTYPE_UINT16
628 typedef YYTYPE_UINT16 yytype_uint16;
629 #else
630 typedef unsigned short int yytype_uint16;
631 #endif
632 
633 #ifdef YYTYPE_INT16
634 typedef YYTYPE_INT16 yytype_int16;
635 #else
636 typedef short int yytype_int16;
637 #endif
638 
639 #ifndef YYSIZE_T
640 # ifdef __SIZE_TYPE__
641 #  define YYSIZE_T __SIZE_TYPE__
642 # elif defined size_t
643 #  define YYSIZE_T size_t
644 # elif ! defined YYSIZE_T
645 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
646 #  define YYSIZE_T size_t
647 # else
648 #  define YYSIZE_T unsigned int
649 # endif
650 #endif
651 
652 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
653 
654 #ifndef YY_
655 # if defined YYENABLE_NLS && YYENABLE_NLS
656 #  if ENABLE_NLS
657 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
658 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
659 #  endif
660 # endif
661 # ifndef YY_
662 #  define YY_(Msgid) Msgid
663 # endif
664 #endif
665 
666 #ifndef YY_ATTRIBUTE
667 # if (defined __GNUC__                                               \
668       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
669      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
670 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
671 # else
672 #  define YY_ATTRIBUTE(Spec) /* empty */
673 # endif
674 #endif
675 
676 #ifndef YY_ATTRIBUTE_PURE
677 # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
678 #endif
679 
680 #ifndef YY_ATTRIBUTE_UNUSED
681 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
682 #endif
683 
684 #if !defined _Noreturn \
685      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
686 # if defined _MSC_VER && 1200 <= _MSC_VER
687 #  define _Noreturn __declspec (noreturn)
688 # else
689 #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
690 # endif
691 #endif
692 
693 /* Suppress unused-variable warnings by "using" E.  */
694 #if ! defined lint || defined __GNUC__
695 # define YYUSE(E) ((void) (E))
696 #else
697 # define YYUSE(E) /* empty */
698 #endif
699 
700 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
701 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
702 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
703     _Pragma ("GCC diagnostic push") \
704     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
705     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
706 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
707     _Pragma ("GCC diagnostic pop")
708 #else
709 # define YY_INITIAL_VALUE(Value) Value
710 #endif
711 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
712 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
713 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
714 #endif
715 #ifndef YY_INITIAL_VALUE
716 # define YY_INITIAL_VALUE(Value) /* Nothing. */
717 #endif
718 
719 
720 #if ! defined yyoverflow || YYERROR_VERBOSE
721 
722 /* The parser invokes alloca or malloc; define the necessary symbols.  */
723 
724 # ifdef YYSTACK_USE_ALLOCA
725 #  if YYSTACK_USE_ALLOCA
726 #   ifdef __GNUC__
727 #    define YYSTACK_ALLOC __builtin_alloca
728 #   elif defined __BUILTIN_VA_ARG_INCR
729 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
730 #   elif defined _AIX
731 #    define YYSTACK_ALLOC __alloca
732 #   elif defined _MSC_VER
733 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
734 #    define alloca _alloca
735 #   else
736 #    define YYSTACK_ALLOC alloca
737 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
738 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
739       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
740 #     ifndef EXIT_SUCCESS
741 #      define EXIT_SUCCESS 0
742 #     endif
743 #    endif
744 #   endif
745 #  endif
746 # endif
747 
748 # ifdef YYSTACK_ALLOC
749    /* Pacify GCC's 'empty if-body' warning.  */
750 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
751 #  ifndef YYSTACK_ALLOC_MAXIMUM
752     /* The OS might guarantee only one guard page at the bottom of the stack,
753        and a page size can be as small as 4096 bytes.  So we cannot safely
754        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
755        to allow for a few compiler-allocated temporary stack slots.  */
756 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
757 #  endif
758 # else
759 #  define YYSTACK_ALLOC YYMALLOC
760 #  define YYSTACK_FREE YYFREE
761 #  ifndef YYSTACK_ALLOC_MAXIMUM
762 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
763 #  endif
764 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
765        && ! ((defined YYMALLOC || defined malloc) \
766              && (defined YYFREE || defined free)))
767 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
768 #   ifndef EXIT_SUCCESS
769 #    define EXIT_SUCCESS 0
770 #   endif
771 #  endif
772 #  ifndef YYMALLOC
773 #   define YYMALLOC malloc
774 #   if ! defined malloc && ! defined EXIT_SUCCESS
775 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
776 #   endif
777 #  endif
778 #  ifndef YYFREE
779 #   define YYFREE free
780 #   if ! defined free && ! defined EXIT_SUCCESS
781 void free (void *); /* INFRINGES ON USER NAME SPACE */
782 #   endif
783 #  endif
784 # endif
785 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
786 
787 
788 #if (! defined yyoverflow \
789      && (! defined __cplusplus \
790          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
791 
792 /* A type that is properly aligned for any stack member.  */
793 union yyalloc
794 {
795   yytype_int16 yyss_alloc;
796   YYSTYPE yyvs_alloc;
797 };
798 
799 /* The size of the maximum gap between one aligned stack and the next.  */
800 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
801 
802 /* The size of an array large to enough to hold all stacks, each with
803    N elements.  */
804 # define YYSTACK_BYTES(N) \
805      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
806       + YYSTACK_GAP_MAXIMUM)
807 
808 # define YYCOPY_NEEDED 1
809 
810 /* Relocate STACK from its old location to the new one.  The
811    local variables YYSIZE and YYSTACKSIZE give the old and new number of
812    elements in the stack, and YYPTR gives the new location of the
813    stack.  Advance YYPTR to a properly aligned location for the next
814    stack.  */
815 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
816     do                                                                  \
817       {                                                                 \
818         YYSIZE_T yynewbytes;                                            \
819         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
820         Stack = &yyptr->Stack_alloc;                                    \
821         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
822         yyptr += yynewbytes / sizeof (*yyptr);                          \
823       }                                                                 \
824     while (0)
825 
826 #endif
827 
828 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
829 /* Copy COUNT objects from SRC to DST.  The source and destination do
830    not overlap.  */
831 # ifndef YYCOPY
832 #  if defined __GNUC__ && 1 < __GNUC__
833 #   define YYCOPY(Dst, Src, Count) \
834       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
835 #  else
836 #   define YYCOPY(Dst, Src, Count)              \
837       do                                        \
838         {                                       \
839           YYSIZE_T yyi;                         \
840           for (yyi = 0; yyi < (Count); yyi++)   \
841             (Dst)[yyi] = (Src)[yyi];            \
842         }                                       \
843       while (0)
844 #  endif
845 # endif
846 #endif /* !YYCOPY_NEEDED */
847 
848 /* YYFINAL -- State number of the termination state.  */
849 #define YYFINAL  386
850 /* YYLAST -- Last index in YYTABLE.  */
851 #define YYLAST   9369
852 
853 /* YYNTOKENS -- Number of terminals.  */
854 #define YYNTOKENS  411
855 /* YYNNTS -- Number of nonterminals.  */
856 #define YYNNTS  111
857 /* YYNRULES -- Number of rules.  */
858 #define YYNRULES  582
859 /* YYNSTATES -- Number of states.  */
860 #define YYNSTATES  727
861 
862 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
863    by yylex, with out-of-bounds checking.  */
864 #define YYUNDEFTOK  2
865 #define YYMAXUTOK   665
866 
867 #define YYTRANSLATE(YYX)                                                \
868   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
869 
870 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
871    as returned by yylex, without out-of-bounds checking.  */
872 static const yytype_uint16 yytranslate[] =
873 {
874        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
875        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
876        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
877        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
878        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
879        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
880        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
881        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
882        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
883        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
884        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
885        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
886        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
887        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
888        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
889        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
890        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
891        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
892        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
893        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
894        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
895        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
896        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
897        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
898        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
899        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
900        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
901       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
902       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
903       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
904       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
905       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
906       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
907       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
908       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
909       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
910      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
911      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
912      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
913      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
914      145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
915      155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
916      165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
917      175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
918      185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
919      195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
920      205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
921      215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
922      225,   226,   227,   228,   229,   230,   231,   232,   233,   234,
923      235,   236,   237,   238,   239,   240,   241,   242,   243,   244,
924      245,   246,   247,   248,   249,   250,   251,   252,   253,   254,
925      255,   256,   257,   258,   259,   260,   261,   262,   263,   264,
926      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
927      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
928      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
929      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
930      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
931      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
932      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
933      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
934      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
935      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
936      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
937      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
938      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
939      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
940      405,   406,   407,   408,   409,   410
941 };
942 
943 #if YYDEBUG
944   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
945 static const yytype_uint16 yyrline[] =
946 {
947        0,   352,   352,   358,   361,   366,   369,   372,   376,   380,
948      384,   388,   392,   396,   400,   404,   408,   416,   419,   422,
949      425,   428,   433,   441,   448,   455,   461,   465,   472,   475,
950      481,   488,   498,   506,   511,   539,   548,   554,   558,   562,
951      582,   583,   584,   585,   591,   592,   597,   602,   611,   612,
952      617,   625,   626,   632,   641,   642,   647,   652,   657,   665,
953      666,   675,   687,   688,   697,   698,   707,   708,   717,   718,
954      726,   727,   735,   736,   744,   745,   745,   763,   764,   780,
955      784,   788,   792,   797,   801,   805,   809,   813,   817,   821,
956      828,   831,   842,   849,   854,   859,   866,   870,   874,   878,
957      883,   888,   897,   897,   908,   912,   919,   926,   929,   936,
958      944,   964,   987,  1002,  1027,  1038,  1048,  1058,  1068,  1077,
959     1080,  1084,  1088,  1093,  1101,  1108,  1113,  1118,  1123,  1132,
960     1142,  1169,  1178,  1185,  1193,  1200,  1207,  1215,  1225,  1232,
961     1243,  1249,  1252,  1259,  1263,  1267,  1276,  1286,  1289,  1300,
962     1303,  1306,  1310,  1314,  1319,  1323,  1330,  1334,  1339,  1345,
963     1351,  1358,  1363,  1371,  1377,  1389,  1403,  1409,  1414,  1422,
964     1430,  1438,  1446,  1453,  1457,  1462,  1467,  1472,  1477,  1482,
965     1486,  1490,  1494,  1498,  1504,  1515,  1522,  1525,  1534,  1539,
966     1549,  1554,  1562,  1566,  1576,  1579,  1585,  1591,  1598,  1608,
967     1612,  1616,  1620,  1625,  1629,  1634,  1639,  1644,  1649,  1654,
968     1659,  1664,  1669,  1674,  1680,  1686,  1692,  1697,  1702,  1707,
969     1712,  1717,  1722,  1727,  1732,  1737,  1742,  1747,  1753,  1758,
970     1763,  1768,  1773,  1778,  1783,  1788,  1793,  1798,  1803,  1808,
971     1813,  1819,  1825,  1831,  1837,  1843,  1849,  1855,  1861,  1867,
972     1873,  1879,  1885,  1891,  1897,  1903,  1909,  1915,  1921,  1927,
973     1933,  1939,  1945,  1951,  1957,  1963,  1969,  1975,  1981,  1987,
974     1993,  1999,  2005,  2011,  2017,  2023,  2029,  2035,  2041,  2047,
975     2053,  2059,  2065,  2071,  2077,  2083,  2089,  2095,  2101,  2107,
976     2113,  2119,  2125,  2131,  2137,  2143,  2149,  2155,  2161,  2167,
977     2173,  2179,  2185,  2191,  2197,  2203,  2209,  2215,  2221,  2227,
978     2233,  2239,  2245,  2251,  2257,  2263,  2269,  2275,  2281,  2287,
979     2293,  2299,  2305,  2311,  2317,  2321,  2326,  2332,  2337,  2342,
980     2347,  2352,  2357,  2362,  2368,  2373,  2378,  2383,  2388,  2393,
981     2399,  2405,  2411,  2417,  2423,  2429,  2435,  2441,  2447,  2453,
982     2459,  2465,  2471,  2477,  2482,  2487,  2492,  2497,  2502,  2507,
983     2513,  2518,  2523,  2528,  2533,  2538,  2543,  2548,  2554,  2559,
984     2564,  2569,  2574,  2579,  2584,  2589,  2594,  2599,  2604,  2609,
985     2614,  2619,  2624,  2630,  2635,  2640,  2646,  2652,  2657,  2662,
986     2667,  2673,  2678,  2683,  2688,  2694,  2699,  2704,  2709,  2715,
987     2720,  2725,  2730,  2736,  2742,  2748,  2754,  2759,  2765,  2771,
988     2777,  2782,  2787,  2792,  2797,  2802,  2808,  2813,  2818,  2823,
989     2829,  2834,  2839,  2844,  2850,  2855,  2860,  2865,  2871,  2876,
990     2881,  2886,  2892,  2897,  2902,  2907,  2913,  2918,  2923,  2928,
991     2934,  2939,  2944,  2949,  2955,  2960,  2965,  2970,  2976,  2981,
992     2986,  2991,  2997,  3002,  3007,  3012,  3018,  3023,  3028,  3033,
993     3039,  3044,  3049,  3054,  3060,  3065,  3070,  3075,  3081,  3086,
994     3091,  3096,  3102,  3107,  3112,  3118,  3124,  3130,  3136,  3143,
995     3150,  3156,  3162,  3168,  3174,  3180,  3186,  3193,  3198,  3214,
996     3219,  3224,  3232,  3232,  3243,  3243,  3253,  3256,  3269,  3291,
997     3318,  3322,  3328,  3333,  3344,  3348,  3354,  3365,  3368,  3375,
998     3379,  3380,  3386,  3387,  3388,  3389,  3390,  3391,  3392,  3394,
999     3400,  3409,  3410,  3414,  3410,  3426,  3427,  3431,  3431,  3438,
1000     3438,  3452,  3455,  3463,  3471,  3482,  3483,  3487,  3491,  3498,
1001     3505,  3509,  3517,  3521,  3534,  3538,  3545,  3545,  3565,  3568,
1002     3574,  3586,  3598,  3602,  3609,  3609,  3624,  3624,  3640,  3640,
1003     3661,  3664,  3670,  3673,  3679,  3683,  3690,  3695,  3700,  3707,
1004     3710,  3719,  3723,  3732,  3735,  3739,  3748,  3748,  3771,  3777,
1005     3780,  3785,  3788
1006 };
1007 #endif
1008 
1009 #if YYDEBUG || YYERROR_VERBOSE || 1
1010 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1011    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1012 static const char *const yytname[] =
1013 {
1014   "$end", "error", "$undefined", "CONST", "BOOL", "INT", "UINT", "FLOAT",
1015   "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", "UVEC2", "UVEC3",
1016   "UVEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "MAT2X2",
1017   "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3",
1018   "MAT4X4", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER2DSHADOW",
1019   "SAMPLERCUBESHADOW", "SAMPLER2DARRAY", "SAMPLER2DARRAYSHADOW",
1020   "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE", "ISAMPLER2DARRAY",
1021   "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER2DARRAY", "SAMPLER",
1022   "SAMPLERSHADOW", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE",
1023   "TEXTURE2DARRAY", "ITEXTURE2D", "ITEXTURE3D", "ITEXTURECUBE",
1024   "ITEXTURE2DARRAY", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE",
1025   "UTEXTURE2DARRAY", "ATTRIBUTE", "VARYING", "FLOAT16_T", "FLOAT32_T",
1026   "DOUBLE", "FLOAT64_T", "INT64_T", "UINT64_T", "INT32_T", "UINT32_T",
1027   "INT16_T", "UINT16_T", "INT8_T", "UINT8_T", "I64VEC2", "I64VEC3",
1028   "I64VEC4", "U64VEC2", "U64VEC3", "U64VEC4", "I32VEC2", "I32VEC3",
1029   "I32VEC4", "U32VEC2", "U32VEC3", "U32VEC4", "I16VEC2", "I16VEC3",
1030   "I16VEC4", "U16VEC2", "U16VEC3", "U16VEC4", "I8VEC2", "I8VEC3", "I8VEC4",
1031   "U8VEC2", "U8VEC3", "U8VEC4", "DVEC2", "DVEC3", "DVEC4", "DMAT2",
1032   "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", "F16MAT2", "F16MAT3",
1033   "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4", "F32MAT2", "F32MAT3",
1034   "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4", "F64MAT2", "F64MAT3",
1035   "F64MAT4", "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3",
1036   "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", "F16MAT2X2", "F16MAT2X3",
1037   "F16MAT2X4", "F16MAT3X2", "F16MAT3X3", "F16MAT3X4", "F16MAT4X2",
1038   "F16MAT4X3", "F16MAT4X4", "F32MAT2X2", "F32MAT2X3", "F32MAT2X4",
1039   "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3",
1040   "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2",
1041   "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4",
1042   "ATOMIC_UINT", "ACCSTRUCTNV", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV",
1043   "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY",
1044   "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY",
1045   "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT",
1046   "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT",
1047   "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS",
1048   "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY",
1049   "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT",
1050   "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D",
1051   "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE",
1052   "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY",
1053   "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY",
1054   "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
1055   "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW",
1056   "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "IMAGE1D",
1057   "IIMAGE1D", "UIMAGE1D", "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D",
1058   "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", "IIMAGE2DRECT", "UIMAGE2DRECT",
1059   "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", "IMAGEBUFFER", "IIMAGEBUFFER",
1060   "UIMAGEBUFFER", "IMAGE1DARRAY", "IIMAGE1DARRAY", "UIMAGE1DARRAY",
1061   "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBEARRAY",
1062   "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS",
1063   "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY",
1064   "F16IMAGE1D", "F16IMAGE2D", "F16IMAGE3D", "F16IMAGE2DRECT",
1065   "F16IMAGECUBE", "F16IMAGE1DARRAY", "F16IMAGE2DARRAY",
1066   "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS",
1067   "F16IMAGE2DMSARRAY", "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY",
1068   "UTEXTURECUBEARRAY", "TEXTURE1D", "ITEXTURE1D", "UTEXTURE1D",
1069   "TEXTURE1DARRAY", "ITEXTURE1DARRAY", "UTEXTURE1DARRAY", "TEXTURE2DRECT",
1070   "ITEXTURE2DRECT", "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER",
1071   "UTEXTUREBUFFER", "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS",
1072   "TEXTURE2DMSARRAY", "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY",
1073   "F16TEXTURE1D", "F16TEXTURE2D", "F16TEXTURE3D", "F16TEXTURE2DRECT",
1074   "F16TEXTURECUBE", "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY",
1075   "F16TEXTURECUBEARRAY", "F16TEXTUREBUFFER", "F16TEXTURE2DMS",
1076   "F16TEXTURE2DMSARRAY", "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT",
1077   "ISUBPASSINPUTMS", "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT",
1078   "F16SUBPASSINPUTMS", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP",
1079   "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN",
1080   "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
1081   "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN",
1082   "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE",
1083   "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG",
1084   "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE",
1085   "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION",
1086   "INVARIANT", "HIGH_PRECISION", "MEDIUM_PRECISION", "LOW_PRECISION",
1087   "PRECISION", "PACKED", "RESOURCE", "SUPERP", "FLOATCONSTANT",
1088   "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT", "IDENTIFIER", "TYPE_NAME",
1089   "CENTROID", "IN", "OUT", "INOUT", "STRUCT", "VOID", "WHILE", "BREAK",
1090   "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN", "SWITCH",
1091   "CASE", "DEFAULT", "UNIFORM", "SHARED", "BUFFER", "FLAT", "SMOOTH",
1092   "LAYOUT", "DOUBLECONSTANT", "INT16CONSTANT", "UINT16CONSTANT",
1093   "FLOAT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INT64CONSTANT",
1094   "UINT64CONSTANT", "SUBROUTINE", "DEMOTE", "PAYLOADNV", "PAYLOADINNV",
1095   "HITATTRNV", "CALLDATANV", "CALLDATAINNV", "PATCH", "SAMPLE",
1096   "NONUNIFORM", "COHERENT", "VOLATILE", "RESTRICT", "READONLY",
1097   "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT",
1098   "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", "NOPERSPECTIVE",
1099   "EXPLICITINTERPAMD", "PERVERTEXNV", "PERPRIMITIVENV", "PERVIEWNV",
1100   "PERTASKNV", "PRECISE", "$accept", "variable_identifier",
1101   "primary_expression", "postfix_expression", "integer_expression",
1102   "function_call", "function_call_or_method", "function_call_generic",
1103   "function_call_header_no_parameters",
1104   "function_call_header_with_parameters", "function_call_header",
1105   "function_identifier", "unary_expression", "unary_operator",
1106   "multiplicative_expression", "additive_expression", "shift_expression",
1107   "relational_expression", "equality_expression", "and_expression",
1108   "exclusive_or_expression", "inclusive_or_expression",
1109   "logical_and_expression", "logical_xor_expression",
1110   "logical_or_expression", "conditional_expression", "$@1",
1111   "assignment_expression", "assignment_operator", "expression",
1112   "constant_expression", "declaration", "block_structure", "$@2",
1113   "identifier_list", "function_prototype", "function_declarator",
1114   "function_header_with_parameters", "function_header",
1115   "parameter_declarator", "parameter_declaration",
1116   "parameter_type_specifier", "init_declarator_list", "single_declaration",
1117   "fully_specified_type", "invariant_qualifier", "interpolation_qualifier",
1118   "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id",
1119   "precise_qualifier", "type_qualifier", "single_type_qualifier",
1120   "storage_qualifier", "non_uniform_qualifier", "type_name_list",
1121   "type_specifier", "array_specifier", "type_parameter_specifier_opt",
1122   "type_parameter_specifier", "type_parameter_specifier_list",
1123   "type_specifier_nonarray", "precision_qualifier", "struct_specifier",
1124   "$@3", "$@4", "struct_declaration_list", "struct_declaration",
1125   "struct_declarator_list", "struct_declarator", "initializer",
1126   "initializer_list", "declaration_statement", "statement",
1127   "simple_statement", "demote_statement", "compound_statement", "$@5",
1128   "$@6", "statement_no_new_scope", "statement_scoped", "$@7", "$@8",
1129   "compound_statement_no_new_scope", "statement_list",
1130   "expression_statement", "selection_statement",
1131   "selection_statement_nonattributed", "selection_rest_statement",
1132   "condition", "switch_statement", "switch_statement_nonattributed", "$@9",
1133   "switch_statement_list", "case_label", "iteration_statement",
1134   "iteration_statement_nonattributed", "$@10", "$@11", "$@12",
1135   "for_init_statement", "conditionopt", "for_rest_statement",
1136   "jump_statement", "translation_unit", "external_declaration",
1137   "function_definition", "$@13", "attribute", "attribute_list",
1138   "single_attribute", YY_NULLPTR
1139 };
1140 #endif
1141 
1142 # ifdef YYPRINT
1143 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1144    (internal) symbol number NUM (which must be that of a token).  */
1145 static const yytype_uint16 yytoknum[] =
1146 {
1147        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1148      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1149      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1150      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1151      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1152      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1153      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1154      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1155      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
1156      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
1157      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
1158      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
1159      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
1160      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
1161      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
1162      405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
1163      415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
1164      425,   426,   427,   428,   429,   430,   431,   432,   433,   434,
1165      435,   436,   437,   438,   439,   440,   441,   442,   443,   444,
1166      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
1167      455,   456,   457,   458,   459,   460,   461,   462,   463,   464,
1168      465,   466,   467,   468,   469,   470,   471,   472,   473,   474,
1169      475,   476,   477,   478,   479,   480,   481,   482,   483,   484,
1170      485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
1171      495,   496,   497,   498,   499,   500,   501,   502,   503,   504,
1172      505,   506,   507,   508,   509,   510,   511,   512,   513,   514,
1173      515,   516,   517,   518,   519,   520,   521,   522,   523,   524,
1174      525,   526,   527,   528,   529,   530,   531,   532,   533,   534,
1175      535,   536,   537,   538,   539,   540,   541,   542,   543,   544,
1176      545,   546,   547,   548,   549,   550,   551,   552,   553,   554,
1177      555,   556,   557,   558,   559,   560,   561,   562,   563,   564,
1178      565,   566,   567,   568,   569,   570,   571,   572,   573,   574,
1179      575,   576,   577,   578,   579,   580,   581,   582,   583,   584,
1180      585,   586,   587,   588,   589,   590,   591,   592,   593,   594,
1181      595,   596,   597,   598,   599,   600,   601,   602,   603,   604,
1182      605,   606,   607,   608,   609,   610,   611,   612,   613,   614,
1183      615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
1184      625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
1185      635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
1186      645,   646,   647,   648,   649,   650,   651,   652,   653,   654,
1187      655,   656,   657,   658,   659,   660,   661,   662,   663,   664,
1188      665
1189 };
1190 # endif
1191 
1192 #define YYPACT_NINF -453
1193 
1194 #define yypact_value_is_default(Yystate) \
1195   (!!((Yystate) == (-453)))
1196 
1197 #define YYTABLE_NINF -528
1198 
1199 #define yytable_value_is_error(Yytable_value) \
1200   0
1201 
1202   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1203      STATE-NUM.  */
1204 static const yytype_int16 yypact[] =
1205 {
1206     3994,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1207     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1208     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1209     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1210     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1211     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1212     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1213     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1214     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1215     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1216     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1217     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1218     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1219     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1220     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1221     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1222     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1223     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1224     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1225     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1226     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1227     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1228     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1229     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1230     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1231     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1232     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1233     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1234     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1235     -453,  -453,  -453,  -453,  -453,  -453,    97,  -453,  -453,  -453,
1236     -453,  -453,     6,  -453,  -453,  -453,  -453,  -453,  -453,  -307,
1237     -241,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1238     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1239     -453,  -453,  -453,  -453,  -453,  -453,  -453,    -3,    95,    36,
1240      125,  6034,    82,  -453,   -22,  -453,  -453,  -453,  -453,  4402,
1241     -453,  -453,  -453,  -453,   131,  -453,  -453,   730,  -453,  -453,
1242       11,  -453,   153,   -28,   127,  -453,     7,  -453,   157,  -453,
1243     6034,  -453,  -453,  -453,  6034,   129,   134,  -453,    13,  -453,
1244       73,  -453,  -453,  8391,   162,  -453,  -453,  -453,   161,  6034,
1245     -453,   163,  -453,  -309,  -453,  -453,    27,  6831,  -453,    16,
1246     1138,  -453,  -453,  -453,  -453,   162,    23,  -453,  7221,    49,
1247     -453,   138,  -453,    87,  8391,  8391,  8391,  -453,  -453,  -453,
1248     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1249     -453,  -453,  -453,  -453,  -453,  -453,    68,  -453,  -453,  -453,
1250      174,    60,  8781,   176,  -453,  8391,  -453,  -453,  -320,   175,
1251     -453,  6034,   142,  4810,  -453,  6034,  8391,  -453,   -28,  -453,
1252      143,  -453,  -453,   119,   128,    32,    21,    38,   158,   160,
1253      165,   195,   194,    18,   183,  7611,  -453,   185,   184,  -453,
1254     -453,   188,   180,   181,  -453,   196,   197,   190,  8001,   198,
1255     8391,   187,   193,   122,  -453,  -453,    91,  -453,    95,   204,
1256      205,  -453,  -453,  -453,  -453,  -453,  1546,  -453,  -453,  -453,
1257     -453,  -453,  -453,  -453,  -453,  -453,  -353,   175,  7221,    69,
1258     7221,  -453,  -453,  7221,  6034,  -453,   170,  -453,  -453,  -453,
1259       78,  -453,  -453,  8391,   171,  -453,  -453,  8391,   207,  -453,
1260     -453,  -453,  8391,  -453,   142,   162,    93,  -453,  -453,  -453,
1261     5218,  -453,  -453,  -453,  -453,  8391,  8391,  8391,  8391,  8391,
1262     8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,  8391,
1263     8391,  8391,  8391,  8391,  -453,  -453,  -453,   206,   177,  -453,
1264     1954,  -453,  -453,  -453,  1954,  -453,  8391,  -453,  -453,   100,
1265     8391,   144,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1266     -453,  -453,  -453,  -453,  -453,  8391,  8391,  -453,  -453,  -453,
1267     -453,  -453,  -453,  -453,  7221,  -453,   140,  -453,  5626,  -453,
1268     -453,   209,   208,  -453,  -453,  -453,   123,   175,   142,  -453,
1269     -453,  -453,  -453,  -453,   119,   119,   128,   128,    32,    32,
1270       32,    32,    21,    21,    38,   158,   160,   165,   195,   194,
1271     8391,  -453,   214,    56,  -453,  1954,  3586,   172,  3178,    80,
1272     -453,    81,  -453,  -453,  -453,  -453,  -453,  6441,  -453,  -453,
1273     -453,  -453,   146,  8391,   215,   177,   212,   208,   186,  6034,
1274      219,   221,  -453,  -453,  3586,   220,  -453,  -453,  -453,  8391,
1275      222,  -453,  -453,  -453,   216,  2362,  8391,  -453,   217,   227,
1276      182,   225,  2770,  -453,   229,  -453,  -453,  7221,  -453,  -453,
1277     -453,    89,  8391,  2362,   220,  -453,  -453,  1954,  -453,   224,
1278      208,  -453,  -453,  1954,   226,  -453,  -453
1279 };
1280 
1281   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1282      Performed when YYTABLE does not specify something else to do.  Zero
1283      means the default is an error.  */
1284 static const yytype_uint16 yydefact[] =
1285 {
1286        0,   156,   203,   201,   202,   200,   207,   208,   209,   210,
1287      211,   212,   213,   214,   215,   204,   205,   206,   216,   217,
1288      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
1289      327,   328,   329,   330,   331,   332,   333,   353,   354,   355,
1290      356,   357,   358,   359,   368,   381,   382,   369,   370,   372,
1291      371,   373,   374,   375,   376,   377,   378,   379,   380,   164,
1292      165,   229,   230,   228,   231,   238,   239,   236,   237,   234,
1293      235,   232,   233,   261,   262,   263,   273,   274,   275,   258,
1294      259,   260,   270,   271,   272,   255,   256,   257,   267,   268,
1295      269,   252,   253,   254,   264,   265,   266,   240,   241,   242,
1296      276,   277,   278,   243,   244,   245,   288,   289,   290,   246,
1297      247,   248,   300,   301,   302,   249,   250,   251,   312,   313,
1298      314,   279,   280,   281,   282,   283,   284,   285,   286,   287,
1299      291,   292,   293,   294,   295,   296,   297,   298,   299,   303,
1300      304,   305,   306,   307,   308,   309,   310,   311,   315,   316,
1301      317,   318,   319,   320,   321,   322,   323,   325,   324,   484,
1302      485,   486,   337,   338,   361,   364,   326,   335,   336,   352,
1303      334,   383,   384,   387,   388,   389,   391,   392,   393,   395,
1304      396,   397,   399,   400,   474,   475,   360,   362,   363,   339,
1305      340,   341,   385,   342,   346,   347,   350,   390,   394,   398,
1306      343,   344,   348,   349,   386,   345,   351,   430,   432,   433,
1307      434,   436,   437,   438,   440,   441,   442,   444,   445,   446,
1308      448,   449,   450,   452,   453,   454,   456,   457,   458,   460,
1309      461,   462,   464,   465,   466,   468,   469,   470,   472,   473,
1310      431,   435,   439,   443,   447,   455,   459,   463,   451,   467,
1311      471,   365,   366,   367,   401,   410,   412,   406,   411,   413,
1312      414,   416,   417,   418,   420,   421,   422,   424,   425,   426,
1313      428,   429,   402,   403,   404,   415,   405,   407,   408,   409,
1314      419,   423,   427,   476,   477,   480,   481,   482,   483,   478,
1315      479,   575,   131,   489,   490,   491,     0,   488,   160,   158,
1316      159,   157,     0,   199,   161,   162,   163,   133,   132,     0,
1317      183,   169,   170,   168,   171,   172,   166,   167,   185,   173,
1318      179,   180,   181,   182,   174,   175,   176,   177,   178,   134,
1319      135,   136,   137,   138,   139,   146,   574,     0,   576,     0,
1320      108,   107,     0,   119,   124,   153,   152,   150,   154,     0,
1321      147,   149,   155,   129,   195,   151,   487,     0,   571,   573,
1322        0,   494,     0,     0,     0,    96,     0,    93,     0,   106,
1323        0,   115,   109,   117,     0,   118,     0,    94,   125,    99,
1324        0,   148,   130,     0,   188,   194,     1,   572,     0,     0,
1325      492,   143,   145,     0,   141,   186,     0,     0,    97,     0,
1326        0,   577,   110,   114,   116,   112,   120,   111,     0,   126,
1327      102,     0,   100,     0,     0,     0,     0,    42,    41,    43,
1328       40,     5,     6,     7,     8,     2,    15,    13,    14,    16,
1329        9,    10,    11,    12,     3,    17,    36,    19,    24,    25,
1330        0,     0,    29,     0,   197,     0,    35,    33,     0,   189,
1331       95,     0,     0,     0,   496,     0,     0,   140,     0,   184,
1332        0,   190,    44,    48,    51,    54,    59,    62,    64,    66,
1333       68,    70,    72,    74,     0,     0,    98,     0,   522,   531,
1334      535,     0,     0,     0,   556,     0,     0,     0,     0,     0,
1335        0,     0,     0,    44,    77,    90,     0,   509,     0,   155,
1336      129,   512,   533,   511,   519,   510,     0,   513,   514,   537,
1337      515,   544,   516,   517,   552,   518,     0,   113,     0,   121,
1338        0,   504,   128,     0,     0,   104,     0,   101,    37,    38,
1339        0,    21,    22,     0,     0,    27,    26,     0,   199,    30,
1340       32,    39,     0,   196,     0,   502,     0,   500,   495,   497,
1341        0,    92,   144,   142,   187,     0,     0,     0,     0,     0,
1342        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1343        0,     0,     0,     0,    75,   191,   192,     0,     0,   521,
1344        0,   554,   567,   566,     0,   558,     0,   570,   568,     0,
1345        0,     0,   551,   520,    80,    81,    83,    82,    85,    86,
1346       87,    88,    89,    84,    79,     0,     0,   536,   532,   534,
1347      538,   545,   553,   123,     0,   507,     0,   127,     0,   105,
1348        4,     0,    23,    20,    31,   198,     0,   503,     0,   498,
1349      493,    45,    46,    47,    50,    49,    52,    53,    57,    58,
1350       55,    56,    60,    61,    63,    65,    67,    69,    71,    73,
1351        0,   193,   581,     0,   579,   523,     0,     0,     0,     0,
1352      569,     0,   550,    78,    91,   122,   505,     0,   103,    18,
1353      499,   501,     0,     0,     0,     0,     0,   542,     0,     0,
1354        0,     0,   561,   560,   563,   529,   546,   506,   508,     0,
1355        0,   578,   580,   524,     0,     0,     0,   562,     0,     0,
1356      541,     0,     0,   539,     0,    76,   582,     0,   526,   555,
1357      525,     0,   564,     0,   529,   528,   530,   548,   543,     0,
1358      565,   559,   540,   549,     0,   557,   547
1359 };
1360 
1361   /* YYPGOTO[NTERM-NUM].  */
1362 static const yytype_int16 yypgoto[] =
1363 {
1364     -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,  -453,
1365     -453,  -453,  8696,  -453,   -89,   -88,  -122,   -84,   -19,   -18,
1366      -17,   -16,   -20,   -15,  -453,   -85,  -453,   -98,  -453,  -110,
1367     -119,     2,  -453,  -453,  -453,     4,  -453,  -453,  -453,   189,
1368      191,   192,  -453,  -453,  -339,  -453,  -453,  -453,  -453,    98,
1369     -453,   -37,   -44,  -453,     9,  -453,     0,   -71,  -453,  -453,
1370     -453,  -453,   261,  -453,  -453,  -453,  -452,  -137,    20,   -68,
1371     -209,  -453,   -96,  -198,  -326,  -453,  -136,  -453,  -453,  -146,
1372     -144,  -453,  -453,   200,  -265,   -87,  -453,    57,  -453,  -112,
1373     -453,    59,  -453,  -453,  -453,  -453,    61,  -453,  -453,  -453,
1374     -453,  -453,  -453,  -453,  -453,   228,  -453,  -453,  -453,  -453,
1375      -99
1376 };
1377 
1378   /* YYDEFGOTO[NTERM-NUM].  */
1379 static const yytype_int16 yydefgoto[] =
1380 {
1381       -1,   434,   435,   436,   621,   437,   438,   439,   440,   441,
1382      442,   443,   493,   445,   463,   464,   465,   466,   467,   468,
1383      469,   470,   471,   472,   473,   494,   650,   495,   605,   496,
1384      552,   497,   337,   524,   413,   498,   339,   340,   341,   371,
1385      372,   373,   342,   343,   344,   345,   346,   347,   393,   394,
1386      348,   349,   350,   351,   446,   396,   447,   399,   384,   385,
1387      448,   354,   355,   356,   455,   389,   453,   454,   546,   547,
1388      522,   616,   501,   502,   503,   504,   505,   580,   676,   709,
1389      700,   701,   702,   710,   506,   507,   508,   509,   703,   680,
1390      510,   511,   704,   724,   512,   513,   514,   656,   584,   658,
1391      684,   698,   699,   515,   357,   358,   359,   368,   516,   653,
1392      654
1393 };
1394 
1395   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
1396      positive, shift that token.  If negative, reduce the rule whose
1397      number is the opposite.  If YYTABLE_NINF, syntax error.  */
1398 static const yytype_int16 yytable[] =
1399 {
1400      353,   542,   336,   550,   338,   481,   457,   363,   484,   352,
1401      485,   486,   458,   543,   489,     2,     3,     4,     5,     6,
1402        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1403       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1404       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
1405       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1406       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1407       57,    58,   618,   364,    61,    62,    63,    64,    65,    66,
1408       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
1409       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1410       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
1411       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
1412      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
1413      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
1414      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
1415      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
1416      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
1417      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
1418      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
1419      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
1420      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
1421      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
1422      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
1423      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
1424      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
1425      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
1426      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
1427      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
1428      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
1429      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
1430      287,   288,   289,   290,   374,   381,   530,   409,   609,   613,
1431      521,   615,   474,   449,   617,   655,   549,   678,   562,   563,
1432      573,   365,   391,   397,   361,   560,   561,   407,   378,   397,
1433      381,   398,   475,   374,   517,   519,   408,   566,   567,   397,
1434      476,   375,   459,   392,   539,   678,   518,   366,   460,   382,
1435      352,   369,   451,   564,   565,   574,   362,   353,   352,   336,
1436      388,   338,   297,   531,   532,   475,   352,   302,   303,   708,
1437      375,   551,   523,   674,   375,   536,   716,   675,   589,   352,
1438      591,   537,   -34,   352,   533,   475,   657,   708,   534,   452,
1439      577,   410,   614,   620,   411,   685,   686,   412,   352,   606,
1440      500,   606,   606,   376,   719,   665,   377,   381,   526,   499,
1441      606,   527,   606,   549,   628,   607,   451,   629,   451,   367,
1442      521,   606,   521,   622,   660,   521,   594,   595,   596,   597,
1443      598,   599,   600,   601,   602,   603,   293,   294,   295,   624,
1444      638,   639,   640,   641,   628,   604,   370,   670,   555,   556,
1445      557,   544,   723,   452,   558,   452,   559,   609,   688,   666,
1446      352,   667,   352,   383,   352,   606,   662,   606,   689,   634,
1447      635,   390,   636,   637,   627,   400,   659,   395,   397,   405,
1448      661,   549,   642,   643,   406,   450,   456,   451,   525,   535,
1449      540,   475,   545,   554,   568,   569,   571,   572,   718,   570,
1450      575,   578,   581,   579,   582,   583,   500,   663,   664,   592,
1451      585,   586,   590,   451,   587,   499,   521,   593,   -35,   -33,
1452      619,   623,   -28,   651,   452,   609,   669,   652,   673,   606,
1453      681,   693,   691,   352,   695,   696,   694,   706,  -527,   707,
1454      672,   712,   713,   478,   714,   726,   677,   717,   725,   644,
1455      452,   645,   648,   646,   690,   647,   553,   360,   649,   352,
1456      671,   402,   682,   403,   626,   715,   404,   721,   401,   521,
1457      722,   683,   697,   610,   677,   611,   692,   612,     0,     0,
1458      500,   451,     0,     0,   500,   387,   711,     0,   551,   499,
1459        0,   705,     0,   499,     0,     0,     0,     0,     0,     0,
1460        0,     0,   720,     0,     0,     0,     0,     0,     0,   521,
1461        0,     0,     0,     0,     0,     0,     0,     0,   452,   679,
1462        0,     0,     0,     0,     0,     0,     0,   352,     0,     0,
1463        0,     0,     0,     0,     0,   381,     0,     0,     0,     0,
1464        0,     0,     0,     0,     0,     0,     0,   679,     0,     0,
1465        0,     0,     0,     0,     0,   500,   500,     0,   500,     0,
1466        0,     0,     0,     0,   499,   499,     0,   499,     0,     0,
1467        0,     0,     0,     0,     0,     0,     0,     0,     0,   382,
1468        0,     0,     0,     0,   500,     0,     0,     0,   352,     0,
1469        0,     0,     0,   499,     0,   500,     0,     0,     0,     0,
1470        0,     0,   500,     0,   499,     0,     0,     0,     0,     0,
1471        0,   499,     0,   500,     0,     0,     0,   500,     0,     0,
1472        0,     0,   499,   500,     0,     0,   499,     0,     0,     0,
1473      386,     0,   499,     1,     2,     3,     4,     5,     6,     7,
1474        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1475       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
1476       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
1477       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1478       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
1479       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
1480       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
1481       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
1482       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
1483       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
1484      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
1485      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
1486      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
1487      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
1488      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
1489      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
1490      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
1491      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
1492      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
1493      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
1494      208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
1495      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
1496      228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
1497      238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
1498      248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
1499      258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
1500      268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
1501      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
1502      288,   289,   290,     0,     0,     0,     0,     0,     0,     0,
1503        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1504        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1505        0,     0,     0,     0,   291,     0,     0,     0,     0,     0,
1506        0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
1507      294,   295,   296,     0,     0,     0,     0,     0,     0,     0,
1508        0,   297,   298,   299,   300,   301,   302,   303,     0,     0,
1509        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1510      304,   305,   306,   307,   308,   309,     0,     0,     0,     0,
1511        0,     0,     0,     0,   310,     0,   311,   312,   313,   314,
1512      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1513      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1514      335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
1515       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1516       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
1517       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
1518       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
1519       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
1520       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
1521       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
1522       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
1523       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
1524      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
1525      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
1526      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
1527      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
1528      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
1529      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
1530      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
1531      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
1532      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
1533      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
1534      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
1535      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
1536      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
1537      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
1538      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
1539      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
1540      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
1541      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
1542      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
1543      290,     0,     0,   414,   415,     0,     0,     0,     0,     0,
1544        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1545        0,     0,   416,     0,   477,     0,   478,   479,     0,     0,
1546        0,     0,   480,   417,   418,   419,   420,     0,     0,     0,
1547        0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
1548      296,     0,     0,     0,   421,   422,   423,   424,   425,   297,
1549      298,   299,   300,   301,   302,   303,   481,   482,   483,   484,
1550        0,   485,   486,   487,   488,   489,   490,   491,   304,   305,
1551      306,   307,   308,   309,   426,   427,   428,   429,   430,   431,
1552      432,   433,   310,   492,   311,   312,   313,   314,   315,   316,
1553      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
1554      327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
1555        2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1556       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1557       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1558       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1559       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
1560       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
1561       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
1562       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
1563       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
1564       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
1565      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
1566      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
1567      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1568      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1569      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
1570      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
1571      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
1572      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
1573      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
1574      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
1575      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
1576      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
1577      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
1578      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
1579      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
1580      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
1581      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
1582      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
1583      282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
1584        0,   414,   415,     0,     0,     0,     0,     0,     0,     0,
1585        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1586      416,     0,   477,     0,   478,   608,     0,     0,     0,     0,
1587      480,   417,   418,   419,   420,     0,     0,     0,     0,     0,
1588        0,     0,     0,     0,   292,   293,   294,   295,   296,     0,
1589        0,     0,   421,   422,   423,   424,   425,   297,   298,   299,
1590      300,   301,   302,   303,   481,   482,   483,   484,     0,   485,
1591      486,   487,   488,   489,   490,   491,   304,   305,   306,   307,
1592      308,   309,   426,   427,   428,   429,   430,   431,   432,   433,
1593      310,   492,   311,   312,   313,   314,   315,   316,   317,   318,
1594      319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
1595      329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
1596        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
1597       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
1598       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
1599       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
1600       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
1601       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1602       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
1603       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
1604       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
1605       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
1606      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
1607      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
1608      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
1609      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
1610      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
1611      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
1612      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
1613      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
1614      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
1615      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
1616      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
1617      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
1618      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
1619      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
1620      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
1621      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
1622      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
1623      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
1624      284,   285,   286,   287,   288,   289,   290,     0,     0,   414,
1625      415,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1626        0,     0,     0,     0,     0,     0,     0,     0,   416,     0,
1627      477,     0,   478,     0,     0,     0,     0,     0,   480,   417,
1628      418,   419,   420,     0,     0,     0,     0,     0,     0,     0,
1629        0,     0,   292,   293,   294,   295,   296,     0,     0,     0,
1630      421,   422,   423,   424,   425,   297,   298,   299,   300,   301,
1631      302,   303,   481,   482,   483,   484,     0,   485,   486,   487,
1632      488,   489,   490,   491,   304,   305,   306,   307,   308,   309,
1633      426,   427,   428,   429,   430,   431,   432,   433,   310,   492,
1634      311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
1635      321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
1636      331,   332,   333,   334,   335,     1,     2,     3,     4,     5,
1637        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
1638       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
1639       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1640       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
1641       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
1642       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
1643       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
1644       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
1645       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
1646       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
1647      106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
1648      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
1649      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
1650      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
1651      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
1652      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
1653      166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
1654      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
1655      186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
1656      196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
1657      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
1658      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
1659      226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
1660      236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
1661      246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
1662      256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
1663      266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
1664      276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
1665      286,   287,   288,   289,   290,     0,     0,   414,   415,     0,
1666        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1667        0,     0,     0,     0,     0,     0,   416,     0,   477,     0,
1668      400,     0,     0,     0,     0,     0,   480,   417,   418,   419,
1669      420,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1670      292,   293,   294,   295,   296,     0,     0,     0,   421,   422,
1671      423,   424,   425,   297,   298,   299,   300,   301,   302,   303,
1672      481,   482,   483,   484,     0,   485,   486,   487,   488,   489,
1673      490,   491,   304,   305,   306,   307,   308,   309,   426,   427,
1674      428,   429,   430,   431,   432,   433,   310,   492,   311,   312,
1675      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
1676      323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
1677      333,   334,   335,     1,     2,     3,     4,     5,     6,     7,
1678        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1679       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
1680       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
1681       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1682       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
1683       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
1684       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
1685       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
1686       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
1687       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
1688      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
1689      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
1690      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
1691      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
1692      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
1693      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
1694      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
1695      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
1696      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
1697      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
1698      208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
1699      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
1700      228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
1701      238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
1702      248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
1703      258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
1704      268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
1705      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
1706      288,   289,   290,     0,     0,   414,   415,     0,     0,     0,
1707        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1708        0,     0,     0,     0,   416,     0,   477,     0,     0,     0,
1709        0,     0,     0,     0,   480,   417,   418,   419,   420,     0,
1710        0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
1711      294,   295,   296,     0,     0,     0,   421,   422,   423,   424,
1712      425,   297,   298,   299,   300,   301,   302,   303,   481,   482,
1713      483,   484,     0,   485,   486,   487,   488,   489,   490,   491,
1714      304,   305,   306,   307,   308,   309,   426,   427,   428,   429,
1715      430,   431,   432,   433,   310,   492,   311,   312,   313,   314,
1716      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1717      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1718      335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
1719       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1720       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
1721       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
1722       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
1723       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
1724       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
1725       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
1726       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
1727       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
1728      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
1729      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
1730      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
1731      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
1732      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
1733      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
1734      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
1735      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
1736      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
1737      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
1738      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
1739      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
1740      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
1741      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
1742      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
1743      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
1744      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
1745      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
1746      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
1747      290,     0,     0,   414,   415,     0,     0,     0,     0,     0,
1748        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1749        0,     0,   416,     0,     0,     0,     0,     0,     0,     0,
1750        0,     0,   480,   417,   418,   419,   420,     0,     0,     0,
1751        0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
1752      296,     0,     0,     0,   421,   422,   423,   424,   425,   297,
1753      298,   299,   300,   301,   302,   303,     0,     0,     0,     0,
1754        0,     0,     0,     0,     0,     0,     0,     0,   304,   305,
1755      306,   307,   308,   309,   426,   427,   428,   429,   430,   431,
1756      432,   433,   310,     0,   311,   312,   313,   314,   315,   316,
1757      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
1758      327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
1759        2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1760       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1761       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1762       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1763       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
1764       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
1765       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
1766       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
1767       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
1768       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
1769      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
1770      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
1771      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1772      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1773      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
1774      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
1775      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
1776      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
1777      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
1778      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
1779      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
1780      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
1781      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
1782      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
1783      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
1784      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
1785      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
1786      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
1787      282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
1788        0,   414,   415,     0,     0,     0,     0,     0,     0,     0,
1789        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1790      416,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1791        0,   417,   418,   419,   420,     0,     0,     0,     0,     0,
1792        0,     0,     0,     0,   292,   293,   294,   295,     0,     0,
1793        0,     0,   421,   422,   423,   424,   425,   297,   298,   299,
1794      300,   301,   302,   303,     0,     0,     0,     0,     0,     0,
1795        0,     0,     0,     0,     0,     0,   304,   305,   306,   307,
1796      308,   309,   426,   427,   428,   429,   430,   431,   432,   433,
1797      310,     0,   311,   312,   313,   314,   315,   316,   317,   318,
1798      319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
1799      329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
1800        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
1801       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
1802       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
1803       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
1804       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
1805       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1806       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
1807       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
1808       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
1809       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
1810      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
1811      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
1812      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
1813      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
1814      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
1815      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
1816      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
1817      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
1818      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
1819      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
1820      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
1821      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
1822      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
1823      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
1824      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
1825      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
1826      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
1827      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
1828      284,   285,   286,   287,   288,   289,   290,     0,     0,     0,
1829        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1830        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1831        0,     0,     0,     0,     0,     0,     0,     0,   291,     0,
1832        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1833        0,     0,   292,   293,   294,   295,   296,     0,     0,     0,
1834        0,     0,     0,     0,     0,   297,   298,   299,   300,   301,
1835      302,   303,     0,     0,     0,     0,     0,     0,     0,     0,
1836        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
1837        0,     0,     0,     0,     0,     0,     0,     0,   310,     0,
1838      311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
1839      321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
1840      331,   332,   333,   334,   335,     1,     2,     3,     4,     5,
1841        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
1842       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
1843       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1844       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
1845       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
1846       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
1847       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
1848       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
1849       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
1850       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
1851      106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
1852      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
1853      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
1854      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
1855      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
1856      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
1857      166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
1858      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
1859      186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
1860      196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
1861      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
1862      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
1863      226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
1864      236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
1865      246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
1866      256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
1867      266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
1868      276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
1869      286,   287,   288,   289,   290,     0,     0,     0,     0,     0,
1870        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1871        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1872        0,     0,     0,     0,     0,     0,   379,     0,     0,     0,
1873        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1874      292,   293,   294,   295,     0,     0,     0,     0,     0,     0,
1875        0,     0,   380,   297,   298,   299,   300,   301,   302,   303,
1876        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1877        0,     0,   304,   305,   306,   307,   308,   309,     0,     0,
1878        0,     0,     0,     0,     0,     0,   310,     0,   311,   312,
1879      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
1880      323,   324,   325,   326,   327,   328,   329,   330,   331,   332,
1881      333,   334,   335,     1,     2,     3,     4,     5,     6,     7,
1882        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1883       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
1884       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
1885       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1886       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
1887       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
1888       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
1889       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
1890       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
1891       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
1892      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
1893      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
1894      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
1895      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
1896      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
1897      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
1898      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
1899      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
1900      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
1901      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
1902      208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
1903      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
1904      228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
1905      238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
1906      248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
1907      258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
1908      268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
1909      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
1910      288,   289,   290,     0,     0,     0,     0,     0,     0,     0,
1911        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1912        0,     0,     0,     0,     0,     0,     0,     0,     0,   548,
1913        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1914        0,     0,     0,     0,     0,     0,     0,     0,   292,   293,
1915      294,   295,     0,     0,     0,     0,     0,     0,     0,     0,
1916        0,   297,   298,   299,   300,   301,   302,   303,     0,     0,
1917        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1918      304,   305,   306,   307,   308,   309,     0,     0,     0,     0,
1919        0,     0,     0,     0,   310,     0,   311,   312,   313,   314,
1920      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1921      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1922      335,     1,     2,     3,     4,     5,     6,     7,     8,     9,
1923       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1924       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
1925       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
1926       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
1927       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
1928       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
1929       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
1930       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
1931       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
1932      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
1933      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
1934      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
1935      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
1936      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
1937      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
1938      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
1939      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
1940      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
1941      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
1942      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
1943      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
1944      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
1945      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
1946      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
1947      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
1948      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
1949      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
1950      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
1951      290,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1952        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1953        0,     0,     0,     0,     0,     0,     0,   630,     0,     0,
1954        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1955        0,     0,     0,     0,     0,     0,   292,   293,   294,   295,
1956        0,     0,     0,     0,     0,     0,     0,     0,     0,   297,
1957      298,   299,   300,   301,   302,   303,     0,     0,     0,     0,
1958        0,     0,     0,     0,     0,     0,     0,     0,   304,   305,
1959      306,   307,   308,   309,     0,     0,     0,     0,     0,     0,
1960        0,     0,   310,     0,   311,   312,   313,   314,   315,   316,
1961      317,   318,   319,   320,   321,   322,   323,   324,   325,   326,
1962      327,   328,   329,   330,   331,   332,   333,   334,   335,     1,
1963        2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
1964       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1965       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1966       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1967       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
1968       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
1969       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
1970       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
1971       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
1972       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
1973      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
1974      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
1975      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
1976      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
1977      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
1978      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
1979      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
1980      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
1981      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
1982      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
1983      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
1984      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
1985      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
1986      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
1987      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
1988      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
1989      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
1990      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
1991      282,   283,   284,   285,   286,   287,   288,   289,   290,     0,
1992        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1993        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1994        0,     0,     0,     0,     0,   668,     0,     0,     0,     0,
1995        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1996        0,     0,     0,     0,   292,   293,   294,   295,     0,     0,
1997        0,     0,     0,     0,     0,     0,     0,   297,   298,   299,
1998      300,   301,   302,   303,     0,     0,     0,     0,     0,     0,
1999        0,     0,     0,     0,     0,     0,   304,   305,   306,   307,
2000      308,   309,     0,     0,     0,     0,     0,     0,     0,     0,
2001      310,     0,   311,   312,   313,   314,   315,   316,   317,   318,
2002      319,   320,   321,   322,   323,   324,   325,   326,   327,   328,
2003      329,   330,   331,   332,   333,   334,   335,     1,     2,     3,
2004        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
2005       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
2006       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
2007       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
2008       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
2009       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
2010       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
2011       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2012       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2013       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
2014      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
2015      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
2016      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
2017      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
2018      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
2019      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
2020      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
2021      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2022      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
2023      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
2024      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
2025      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
2026      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
2027      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
2028      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
2029      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
2030      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
2031      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
2032      284,   285,   286,   287,   288,   289,   290,     0,     0,     0,
2033        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2034        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2035        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2036        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2037        0,     0,   292,   293,   294,   295,     0,     0,     0,     0,
2038        0,     0,     0,     0,     0,   297,   298,   299,   300,   301,
2039      302,   303,     0,     0,     0,     0,     0,     0,     0,     0,
2040        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
2041        0,     0,     0,     0,     0,     0,     0,     0,   310,     0,
2042      311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
2043      321,   322,   323,   324,   325,   326,   327,   328,   329,   330,
2044      331,   332,   333,   334,   335,     2,     3,     4,     5,     6,
2045        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2046       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2047       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2048       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2049       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2050       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2051       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2052       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2053       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2054       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2055      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2056      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2057      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2058      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2059      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2060      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2061      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2062      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2063      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2064      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2065      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2066      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2067      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2068      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2069      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2070      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2071      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2072      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2073      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2074        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2075        0,     0,     0,     0,     0,   416,     0,     0,     0,   520,
2076      687,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2078        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2079      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2080        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2081        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2082      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2083        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2084        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2085       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2086       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2087       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2088       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2089       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2090       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2091       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2092       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2093       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2094      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2095      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2096      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2097      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2098      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2099      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2100      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2101      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2102      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2103      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2104      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2105      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2106      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2107      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2108      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2109      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2110      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2111      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2112      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2113        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2114        0,     0,     0,     0,     0,   416,     0,     0,   461,     0,
2115        0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2116        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2117        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2118      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2119        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2120        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2121      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2122        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2123        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2124       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2125       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2126       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2127       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2128       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2129       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2130       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2131       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2132       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2133      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2134      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2135      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2136      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2137      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2138      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2139      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2140      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2141      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2142      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2143      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2144      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2145      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2146      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2147      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2148      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2149      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2150      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2151      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2152        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2153        0,     0,     0,     0,     0,   416,     0,     0,     0,   520,
2154        0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2155        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2156        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2157      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2158        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2159        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2160      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2161        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2162        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2163       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2164       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2165       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2166       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2167       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2168       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2169       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2170       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2171       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2172      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2173      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2174      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2175      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2176      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2177      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2178      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2179      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2180      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2181      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2182      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2183      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2184      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2185      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2186      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2187      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2188      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2189      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2190      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2191        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2192        0,     0,     0,     0,     0,   416,     0,     0,   576,     0,
2193        0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2194        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2195        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2196      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2197        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2198        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2199      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2200        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2201        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2202       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2203       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2204       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2205       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2206       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2207       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2208       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2209       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2210       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2211      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2212      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2213      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2214      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2215      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2216      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2217      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2218      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2219      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2220      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2221      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2222      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2223      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2224      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2225      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2226      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2227      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2228      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2229      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2230        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2231        0,     0,     0,     0,     0,   416,     0,     0,     0,     0,
2232        0,     0,     0,     0,     0,   588,   417,   418,   419,   420,
2233        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2234        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2235      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2236        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2237        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2238      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2239        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2240        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2241       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2242       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2243       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2244       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2245       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2246       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2247       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2248       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2249       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2250      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2251      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2252      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2253      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2254      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2255      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2256      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2257      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2258      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2259      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2260      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2261      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2262      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2263      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2264      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2265      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2266      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2267      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2268      287,   288,   289,   290,     0,     0,   414,   415,     0,     0,
2269        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2270        0,     0,     0,     0,     0,   416,     0,     0,     0,     0,
2271        0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2272        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2273        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2274      424,   425,   297,     0,     0,     0,     0,   302,   303,     0,
2275        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2276        0,     0,     0,     0,     0,     0,     0,   426,   427,   428,
2277      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2278        0,     0,     0,     0,   318,     2,     3,     4,     5,     6,
2279        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
2280       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
2281       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
2282       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
2283       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
2284       57,    58,     0,     0,    61,    62,    63,    64,    65,    66,
2285       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2286       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2287       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
2288       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
2289      107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
2290      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2291      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
2292      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
2293      147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
2294      157,   158,   159,   160,   161,   162,   163,   164,   165,   166,
2295      167,   168,   169,   170,   171,   172,   173,   174,   175,   176,
2296      177,   178,   179,   180,   181,   182,   183,   184,   185,   186,
2297      187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
2298      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2299      207,   208,   209,   210,   211,   212,   213,   214,   215,   216,
2300      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
2301      227,   228,   229,   230,   231,   232,   233,   234,   235,   236,
2302      237,   238,   239,   240,   241,   242,   243,   244,   245,   246,
2303      247,   248,   249,   250,   251,   252,   253,   254,   255,   256,
2304      257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
2305      267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
2306      277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
2307      287,   288,   289,   290,     0,     0,   414,   415,     0,   444,
2308        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2309        0,     0,     0,   462,     0,   416,     0,     0,     0,     0,
2310        0,     0,     0,     0,     0,     0,   417,   418,   419,   420,
2311      528,   529,     0,     0,     0,     0,     0,     0,     0,     0,
2312        0,     0,     0,     0,     0,     0,     0,   421,   422,   423,
2313      424,   425,   297,     0,     0,     0,     0,   302,   538,     0,
2314        0,   541,     0,     0,     0,     0,     0,     0,     0,     0,
2315        0,     0,   462,     0,     0,     0,     0,   426,   427,   428,
2316      429,   430,   431,   432,   433,     0,     0,     0,     0,     0,
2317        0,   462,     0,     0,   318,     0,     0,     0,     0,     0,
2318        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2319        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2320        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2321        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2322        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2323        0,     0,     0,     0,     0,     0,     0,     0,   625,     0,
2324        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2325        0,   631,   632,   633,   462,   462,   462,   462,   462,   462,
2326      462,   462,   462,   462,   462,   462,   462,   462,   462,   462,
2327        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2328        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2329        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2330        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2331        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2332        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2333        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2334        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2335        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2336        0,     0,     0,     0,     0,     0,     0,     0,     0,   462
2337 };
2338 
2339 static const yytype_int16 yycheck[] =
2340 {
2341        0,   321,     0,   455,     0,   358,   315,   314,   361,     0,
2342      363,   364,   321,   333,   367,     4,     5,     6,     7,     8,
2343        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
2344       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
2345       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
2346       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
2347       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
2348       59,    60,   524,   314,    63,    64,    65,    66,    67,    68,
2349       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
2350       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
2351       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
2352       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
2353      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
2354      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
2355      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
2356      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
2357      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
2358      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
2359      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
2360      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
2361      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
2362      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
2363      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
2364      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
2365      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
2366      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
2367      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
2368      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
2369      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
2370      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
2371      289,   290,   291,   292,   341,   349,   416,   378,   506,   518,
2372      408,   520,   397,   384,   523,   580,   453,   656,   297,   298,
2373      302,   324,   350,   316,   318,   293,   294,   314,   350,   316,
2374      374,   324,   316,   370,   405,   406,   323,   299,   300,   316,
2375      324,   341,   315,   371,   442,   684,   323,   350,   321,   349,
2376      341,   315,   389,   332,   333,   337,   350,   357,   349,   357,
2377      360,   357,   351,   295,   296,   316,   357,   356,   357,   695,
2378      370,   456,   323,   317,   374,   315,   702,   321,   488,   370,
2379      490,   321,   314,   374,   316,   316,   584,   713,   320,   389,
2380      475,   318,   323,   315,   321,   315,   315,   324,   389,   321,
2381      400,   321,   321,   321,   315,   614,   324,   451,   321,   400,
2382      321,   324,   321,   550,   321,   324,   453,   324,   455,   324,
2383      518,   321,   520,   533,   324,   523,   304,   305,   306,   307,
2384      308,   309,   310,   311,   312,   313,   339,   340,   341,   537,
2385      562,   563,   564,   565,   321,   323,   321,   324,   329,   330,
2386      331,   451,   717,   453,   326,   455,   328,   655,   667,   319,
2387      451,   321,   453,   332,   455,   321,   322,   321,   322,   558,
2388      559,   318,   560,   561,   545,   318,   586,   350,   316,   350,
2389      590,   618,   566,   567,   350,   324,   323,   524,   350,   315,
2390      314,   316,   350,   350,   336,   335,   301,   303,   707,   334,
2391      317,   316,   314,   319,   324,   324,   506,   605,   606,   322,
2392      314,   314,   314,   550,   324,   506,   614,   324,   314,   314,
2393      350,   350,   315,   317,   524,   723,   317,   350,   314,   321,
2394      358,   319,   317,   524,   315,   314,   350,   315,   318,   323,
2395      650,   324,   315,   318,   362,   319,   656,   318,   324,   568,
2396      550,   569,   572,   570,   673,   571,   458,   296,   573,   550,
2397      628,   370,   658,   374,   544,   701,   374,   713,   368,   667,
2398      714,   658,   684,   516,   684,   516,   675,   516,    -1,    -1,
2399      580,   618,    -1,    -1,   584,   357,   696,    -1,   673,   580,
2400       -1,   689,    -1,   584,    -1,    -1,    -1,    -1,    -1,    -1,
2401       -1,    -1,   712,    -1,    -1,    -1,    -1,    -1,    -1,   707,
2402       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   618,   656,
2403       -1,    -1,    -1,    -1,    -1,    -1,    -1,   618,    -1,    -1,
2404       -1,    -1,    -1,    -1,    -1,   679,    -1,    -1,    -1,    -1,
2405       -1,    -1,    -1,    -1,    -1,    -1,    -1,   684,    -1,    -1,
2406       -1,    -1,    -1,    -1,    -1,   655,   656,    -1,   658,    -1,
2407       -1,    -1,    -1,    -1,   655,   656,    -1,   658,    -1,    -1,
2408       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   679,
2409       -1,    -1,    -1,    -1,   684,    -1,    -1,    -1,   679,    -1,
2410       -1,    -1,    -1,   684,    -1,   695,    -1,    -1,    -1,    -1,
2411       -1,    -1,   702,    -1,   695,    -1,    -1,    -1,    -1,    -1,
2412       -1,   702,    -1,   713,    -1,    -1,    -1,   717,    -1,    -1,
2413       -1,    -1,   713,   723,    -1,    -1,   717,    -1,    -1,    -1,
2414        0,    -1,   723,     3,     4,     5,     6,     7,     8,     9,
2415       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
2416       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
2417       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2418       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
2419       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
2420       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
2421       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
2422       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2423       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
2424      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
2425      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
2426      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
2427      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
2428      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
2429      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
2430      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
2431      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
2432      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
2433      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
2434      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
2435      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
2436      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
2437      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
2438      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
2439      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
2440      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
2441      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
2442      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
2443      290,   291,   292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2444       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2445       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2446       -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,    -1,    -1,
2447       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
2448      340,   341,   342,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2449       -1,   351,   352,   353,   354,   355,   356,   357,    -1,    -1,
2450       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2451      370,   371,   372,   373,   374,   375,    -1,    -1,    -1,    -1,
2452       -1,    -1,    -1,    -1,   384,    -1,   386,   387,   388,   389,
2453      390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
2454      400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
2455      410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
2456       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
2457       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
2458       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
2459       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
2460       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
2461       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
2462       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
2463       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
2464       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
2465      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
2466      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
2467      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
2468      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
2469      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
2470      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
2471      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
2472      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
2473      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
2474      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
2475      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
2476      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
2477      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
2478      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
2479      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
2480      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
2481      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
2482      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
2483      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
2484      292,    -1,    -1,   295,   296,    -1,    -1,    -1,    -1,    -1,
2485       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2486       -1,    -1,   314,    -1,   316,    -1,   318,   319,    -1,    -1,
2487       -1,    -1,   324,   325,   326,   327,   328,    -1,    -1,    -1,
2488       -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
2489      342,    -1,    -1,    -1,   346,   347,   348,   349,   350,   351,
2490      352,   353,   354,   355,   356,   357,   358,   359,   360,   361,
2491       -1,   363,   364,   365,   366,   367,   368,   369,   370,   371,
2492      372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
2493      382,   383,   384,   385,   386,   387,   388,   389,   390,   391,
2494      392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
2495      402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
2496        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
2497       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
2498       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
2499       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
2500       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
2501       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
2502       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
2503       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2504       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2505       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
2506      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
2507      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
2508      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
2509      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
2510      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
2511      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
2512      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
2513      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2514      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
2515      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
2516      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
2517      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
2518      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
2519      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
2520      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
2521      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
2522      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
2523      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
2524      284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
2525       -1,   295,   296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2526       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2527      314,    -1,   316,    -1,   318,   319,    -1,    -1,    -1,    -1,
2528      324,   325,   326,   327,   328,    -1,    -1,    -1,    -1,    -1,
2529       -1,    -1,    -1,    -1,   338,   339,   340,   341,   342,    -1,
2530       -1,    -1,   346,   347,   348,   349,   350,   351,   352,   353,
2531      354,   355,   356,   357,   358,   359,   360,   361,    -1,   363,
2532      364,   365,   366,   367,   368,   369,   370,   371,   372,   373,
2533      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
2534      384,   385,   386,   387,   388,   389,   390,   391,   392,   393,
2535      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
2536      404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
2537        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
2538       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
2539       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
2540       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
2541       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
2542       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
2543       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
2544       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2545       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
2546       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
2547      106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
2548      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
2549      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
2550      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
2551      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
2552      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
2553      166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
2554      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
2555      186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
2556      196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
2557      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
2558      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
2559      226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
2560      236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
2561      246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
2562      256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
2563      266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
2564      276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
2565      286,   287,   288,   289,   290,   291,   292,    -1,    -1,   295,
2566      296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2567       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   314,    -1,
2568      316,    -1,   318,    -1,    -1,    -1,    -1,    -1,   324,   325,
2569      326,   327,   328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2570       -1,    -1,   338,   339,   340,   341,   342,    -1,    -1,    -1,
2571      346,   347,   348,   349,   350,   351,   352,   353,   354,   355,
2572      356,   357,   358,   359,   360,   361,    -1,   363,   364,   365,
2573      366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
2574      376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
2575      386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
2576      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2577      406,   407,   408,   409,   410,     3,     4,     5,     6,     7,
2578        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
2579       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
2580       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
2581       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
2582       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
2583       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
2584       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
2585       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
2586       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
2587       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
2588      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
2589      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
2590      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
2591      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
2592      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
2593      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
2594      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
2595      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
2596      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
2597      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
2598      208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
2599      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
2600      228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
2601      238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
2602      248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
2603      258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
2604      268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
2605      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
2606      288,   289,   290,   291,   292,    -1,    -1,   295,   296,    -1,
2607       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2608       -1,    -1,    -1,    -1,    -1,    -1,   314,    -1,   316,    -1,
2609      318,    -1,    -1,    -1,    -1,    -1,   324,   325,   326,   327,
2610      328,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2611      338,   339,   340,   341,   342,    -1,    -1,    -1,   346,   347,
2612      348,   349,   350,   351,   352,   353,   354,   355,   356,   357,
2613      358,   359,   360,   361,    -1,   363,   364,   365,   366,   367,
2614      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
2615      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
2616      388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
2617      398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
2618      408,   409,   410,     3,     4,     5,     6,     7,     8,     9,
2619       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
2620       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
2621       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2622       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
2623       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
2624       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
2625       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
2626       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2627       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
2628      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
2629      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
2630      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
2631      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
2632      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
2633      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
2634      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
2635      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
2636      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
2637      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
2638      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
2639      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
2640      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
2641      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
2642      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
2643      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
2644      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
2645      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
2646      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
2647      290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,    -1,
2648       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2649       -1,    -1,    -1,    -1,   314,    -1,   316,    -1,    -1,    -1,
2650       -1,    -1,    -1,    -1,   324,   325,   326,   327,   328,    -1,
2651       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
2652      340,   341,   342,    -1,    -1,    -1,   346,   347,   348,   349,
2653      350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
2654      360,   361,    -1,   363,   364,   365,   366,   367,   368,   369,
2655      370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
2656      380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
2657      390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
2658      400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
2659      410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
2660       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
2661       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
2662       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
2663       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
2664       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
2665       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
2666       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
2667       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
2668       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
2669      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
2670      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
2671      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
2672      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
2673      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
2674      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
2675      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
2676      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
2677      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
2678      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
2679      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
2680      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
2681      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
2682      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
2683      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
2684      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
2685      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
2686      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
2687      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
2688      292,    -1,    -1,   295,   296,    -1,    -1,    -1,    -1,    -1,
2689       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2690       -1,    -1,   314,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2691       -1,    -1,   324,   325,   326,   327,   328,    -1,    -1,    -1,
2692       -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
2693      342,    -1,    -1,    -1,   346,   347,   348,   349,   350,   351,
2694      352,   353,   354,   355,   356,   357,    -1,    -1,    -1,    -1,
2695       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   370,   371,
2696      372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
2697      382,   383,   384,    -1,   386,   387,   388,   389,   390,   391,
2698      392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
2699      402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
2700        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
2701       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
2702       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
2703       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
2704       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
2705       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
2706       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
2707       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2708       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2709       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
2710      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
2711      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
2712      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
2713      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
2714      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
2715      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
2716      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
2717      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2718      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
2719      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
2720      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
2721      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
2722      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
2723      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
2724      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
2725      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
2726      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
2727      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
2728      284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
2729       -1,   295,   296,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2730       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2731      314,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2732       -1,   325,   326,   327,   328,    -1,    -1,    -1,    -1,    -1,
2733       -1,    -1,    -1,    -1,   338,   339,   340,   341,    -1,    -1,
2734       -1,    -1,   346,   347,   348,   349,   350,   351,   352,   353,
2735      354,   355,   356,   357,    -1,    -1,    -1,    -1,    -1,    -1,
2736       -1,    -1,    -1,    -1,    -1,    -1,   370,   371,   372,   373,
2737      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
2738      384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
2739      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
2740      404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
2741        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
2742       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
2743       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
2744       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
2745       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
2746       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
2747       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
2748       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2749       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
2750       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
2751      106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
2752      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
2753      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
2754      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
2755      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
2756      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
2757      166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
2758      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
2759      186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
2760      196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
2761      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
2762      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
2763      226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
2764      236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
2765      246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
2766      256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
2767      266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
2768      276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
2769      286,   287,   288,   289,   290,   291,   292,    -1,    -1,    -1,
2770       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2771       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2772       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   324,    -1,
2773       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2774       -1,    -1,   338,   339,   340,   341,   342,    -1,    -1,    -1,
2775       -1,    -1,    -1,    -1,    -1,   351,   352,   353,   354,   355,
2776      356,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2777       -1,    -1,    -1,    -1,   370,   371,   372,   373,   374,   375,
2778       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,
2779      386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
2780      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2781      406,   407,   408,   409,   410,     3,     4,     5,     6,     7,
2782        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
2783       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
2784       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
2785       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
2786       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
2787       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
2788       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
2789       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
2790       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
2791       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
2792      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
2793      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
2794      128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
2795      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
2796      148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
2797      158,   159,   160,   161,   162,   163,   164,   165,   166,   167,
2798      168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
2799      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
2800      188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
2801      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
2802      208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
2803      218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
2804      228,   229,   230,   231,   232,   233,   234,   235,   236,   237,
2805      238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
2806      248,   249,   250,   251,   252,   253,   254,   255,   256,   257,
2807      258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
2808      268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
2809      278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
2810      288,   289,   290,   291,   292,    -1,    -1,    -1,    -1,    -1,
2811       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2812       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2813       -1,    -1,    -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,
2814       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2815      338,   339,   340,   341,    -1,    -1,    -1,    -1,    -1,    -1,
2816       -1,    -1,   350,   351,   352,   353,   354,   355,   356,   357,
2817       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2818       -1,    -1,   370,   371,   372,   373,   374,   375,    -1,    -1,
2819       -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,   386,   387,
2820      388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
2821      398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
2822      408,   409,   410,     3,     4,     5,     6,     7,     8,     9,
2823       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
2824       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
2825       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2826       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
2827       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
2828       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
2829       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
2830       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2831       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
2832      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
2833      110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
2834      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
2835      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
2836      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
2837      150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
2838      160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
2839      170,   171,   172,   173,   174,   175,   176,   177,   178,   179,
2840      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
2841      190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
2842      200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
2843      210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
2844      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
2845      230,   231,   232,   233,   234,   235,   236,   237,   238,   239,
2846      240,   241,   242,   243,   244,   245,   246,   247,   248,   249,
2847      250,   251,   252,   253,   254,   255,   256,   257,   258,   259,
2848      260,   261,   262,   263,   264,   265,   266,   267,   268,   269,
2849      270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
2850      280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
2851      290,   291,   292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2852       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2853       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   319,
2854       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2855       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   338,   339,
2856      340,   341,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2857       -1,   351,   352,   353,   354,   355,   356,   357,    -1,    -1,
2858       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2859      370,   371,   372,   373,   374,   375,    -1,    -1,    -1,    -1,
2860       -1,    -1,    -1,    -1,   384,    -1,   386,   387,   388,   389,
2861      390,   391,   392,   393,   394,   395,   396,   397,   398,   399,
2862      400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
2863      410,     3,     4,     5,     6,     7,     8,     9,    10,    11,
2864       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
2865       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
2866       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
2867       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
2868       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
2869       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
2870       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
2871       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
2872       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
2873      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
2874      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
2875      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
2876      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
2877      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
2878      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
2879      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
2880      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
2881      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
2882      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
2883      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
2884      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
2885      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
2886      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
2887      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
2888      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
2889      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
2890      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
2891      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
2892      292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2893       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2894       -1,    -1,    -1,    -1,    -1,    -1,    -1,   319,    -1,    -1,
2895       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2896       -1,    -1,    -1,    -1,    -1,    -1,   338,   339,   340,   341,
2897       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   351,
2898      352,   353,   354,   355,   356,   357,    -1,    -1,    -1,    -1,
2899       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   370,   371,
2900      372,   373,   374,   375,    -1,    -1,    -1,    -1,    -1,    -1,
2901       -1,    -1,   384,    -1,   386,   387,   388,   389,   390,   391,
2902      392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
2903      402,   403,   404,   405,   406,   407,   408,   409,   410,     3,
2904        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
2905       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
2906       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
2907       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
2908       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
2909       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
2910       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
2911       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2912       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2913       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
2914      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
2915      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
2916      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
2917      134,   135,   136,   137,   138,   139,   140,   141,   142,   143,
2918      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
2919      154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
2920      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
2921      174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2922      184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
2923      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
2924      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
2925      214,   215,   216,   217,   218,   219,   220,   221,   222,   223,
2926      224,   225,   226,   227,   228,   229,   230,   231,   232,   233,
2927      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
2928      244,   245,   246,   247,   248,   249,   250,   251,   252,   253,
2929      254,   255,   256,   257,   258,   259,   260,   261,   262,   263,
2930      264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
2931      274,   275,   276,   277,   278,   279,   280,   281,   282,   283,
2932      284,   285,   286,   287,   288,   289,   290,   291,   292,    -1,
2933       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2934       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2935       -1,    -1,    -1,    -1,    -1,   319,    -1,    -1,    -1,    -1,
2936       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2937       -1,    -1,    -1,    -1,   338,   339,   340,   341,    -1,    -1,
2938       -1,    -1,    -1,    -1,    -1,    -1,    -1,   351,   352,   353,
2939      354,   355,   356,   357,    -1,    -1,    -1,    -1,    -1,    -1,
2940       -1,    -1,    -1,    -1,    -1,    -1,   370,   371,   372,   373,
2941      374,   375,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2942      384,    -1,   386,   387,   388,   389,   390,   391,   392,   393,
2943      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
2944      404,   405,   406,   407,   408,   409,   410,     3,     4,     5,
2945        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
2946       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
2947       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
2948       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
2949       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
2950       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
2951       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
2952       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2953       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
2954       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
2955      106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
2956      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
2957      126,   127,   128,   129,   130,   131,   132,   133,   134,   135,
2958      136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
2959      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
2960      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
2961      166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
2962      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
2963      186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
2964      196,   197,   198,   199,   200,   201,   202,   203,   204,   205,
2965      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
2966      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
2967      226,   227,   228,   229,   230,   231,   232,   233,   234,   235,
2968      236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
2969      246,   247,   248,   249,   250,   251,   252,   253,   254,   255,
2970      256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
2971      266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
2972      276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
2973      286,   287,   288,   289,   290,   291,   292,    -1,    -1,    -1,
2974       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2975       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2976       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2977       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2978       -1,    -1,   338,   339,   340,   341,    -1,    -1,    -1,    -1,
2979       -1,    -1,    -1,    -1,    -1,   351,   352,   353,   354,   355,
2980      356,   357,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2981       -1,    -1,    -1,    -1,   370,   371,   372,   373,   374,   375,
2982       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   384,    -1,
2983      386,   387,   388,   389,   390,   391,   392,   393,   394,   395,
2984      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2985      406,   407,   408,   409,   410,     4,     5,     6,     7,     8,
2986        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
2987       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
2988       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
2989       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
2990       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
2991       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
2992       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
2993       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
2994       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
2995       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
2996      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
2997      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
2998      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
2999      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3000      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3001      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3002      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3003      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3004      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3005      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3006      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3007      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3008      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3009      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3010      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3011      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3012      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3013      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3014      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3015       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3016       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,   318,
3017      319,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3018       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3019       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3020      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3021       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3022       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3023      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3024       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3025        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3026       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3027       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3028       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3029       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3030       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3031       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3032       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3033       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3034       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3035      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3036      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3037      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3038      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3039      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3040      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3041      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3042      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3043      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3044      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3045      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3046      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3047      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3048      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3049      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3050      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3051      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3052      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3053      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3054       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3055       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,   317,    -1,
3056       -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3057       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3058       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3059      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3060       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3061       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3062      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3063       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3064        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3065       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3066       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3067       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3068       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3069       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3070       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3071       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3072       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3073       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3074      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3075      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3076      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3077      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3078      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3079      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3080      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3081      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3082      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3083      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3084      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3085      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3086      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3087      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3088      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3089      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3090      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3091      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3092      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3093       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3094       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,   318,
3095       -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3096       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3097       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3098      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3099       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3100       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3101      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3102       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3103        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3104       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3105       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3106       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3107       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3108       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3109       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3110       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3111       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3112       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3113      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3114      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3115      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3116      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3117      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3118      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3119      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3120      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3121      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3122      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3123      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3124      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3125      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3126      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3127      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3128      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3129      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3130      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3131      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3132       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3133       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,   317,    -1,
3134       -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3135       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3136       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3137      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3138       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3139       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3140      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3141       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3142        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3143       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3144       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3145       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3146       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3147       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3148       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3149       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3150       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3151       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3152      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3153      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3154      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3155      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3156      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3157      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3158      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3159      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3160      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3161      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3162      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3163      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3164      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3165      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3166      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3167      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3168      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3169      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3170      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3171       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3172       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,    -1,
3173       -1,    -1,    -1,    -1,    -1,   324,   325,   326,   327,   328,
3174       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3175       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3176      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3177       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3178       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3179      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3180       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3181        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3182       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3183       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3184       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3185       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3186       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3187       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3188       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3189       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3190       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3191      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3192      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3193      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3194      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3195      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3196      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3197      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3198      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3199      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3200      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3201      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3202      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3203      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3204      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3205      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3206      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3207      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3208      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3209      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,    -1,
3210       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3211       -1,    -1,    -1,    -1,    -1,   314,    -1,    -1,    -1,    -1,
3212       -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3213       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3214       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3215      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3216       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3217       -1,    -1,    -1,    -1,    -1,    -1,    -1,   376,   377,   378,
3218      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3219       -1,    -1,    -1,    -1,   393,     4,     5,     6,     7,     8,
3220        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
3221       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
3222       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
3223       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3224       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3225       59,    60,    -1,    -1,    63,    64,    65,    66,    67,    68,
3226       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
3227       79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
3228       89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
3229       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
3230      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
3231      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
3232      129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
3233      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
3234      149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
3235      159,   160,   161,   162,   163,   164,   165,   166,   167,   168,
3236      169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
3237      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
3238      189,   190,   191,   192,   193,   194,   195,   196,   197,   198,
3239      199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
3240      209,   210,   211,   212,   213,   214,   215,   216,   217,   218,
3241      219,   220,   221,   222,   223,   224,   225,   226,   227,   228,
3242      229,   230,   231,   232,   233,   234,   235,   236,   237,   238,
3243      239,   240,   241,   242,   243,   244,   245,   246,   247,   248,
3244      249,   250,   251,   252,   253,   254,   255,   256,   257,   258,
3245      259,   260,   261,   262,   263,   264,   265,   266,   267,   268,
3246      269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
3247      279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
3248      289,   290,   291,   292,    -1,    -1,   295,   296,    -1,   383,
3249       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3250       -1,    -1,    -1,   397,    -1,   314,    -1,    -1,    -1,    -1,
3251       -1,    -1,    -1,    -1,    -1,    -1,   325,   326,   327,   328,
3252      414,   415,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3253       -1,    -1,    -1,    -1,    -1,    -1,    -1,   346,   347,   348,
3254      349,   350,   351,    -1,    -1,    -1,    -1,   356,   357,    -1,
3255       -1,   445,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3256       -1,    -1,   456,    -1,    -1,    -1,    -1,   376,   377,   378,
3257      379,   380,   381,   382,   383,    -1,    -1,    -1,    -1,    -1,
3258       -1,   475,    -1,    -1,   393,    -1,    -1,    -1,    -1,    -1,
3259       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3260       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3261       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3262       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3263       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3264       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   542,    -1,
3265       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3266       -1,   555,   556,   557,   558,   559,   560,   561,   562,   563,
3267      564,   565,   566,   567,   568,   569,   570,   571,   572,   573,
3268       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3269       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3270       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3271       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3272       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3273       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3274       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3275       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3276       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3277       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   673
3278 };
3279 
3280   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3281      symbol of state STATE-NUM.  */
3282 static const yytype_uint16 yystos[] =
3283 {
3284        0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
3285       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
3286       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
3287       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
3288       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
3289       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
3290       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
3291       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
3292       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
3293       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
3294      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
3295      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
3296      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
3297      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
3298      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
3299      152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
3300      162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
3301      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
3302      182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
3303      192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
3304      202,   203,   204,   205,   206,   207,   208,   209,   210,   211,
3305      212,   213,   214,   215,   216,   217,   218,   219,   220,   221,
3306      222,   223,   224,   225,   226,   227,   228,   229,   230,   231,
3307      232,   233,   234,   235,   236,   237,   238,   239,   240,   241,
3308      242,   243,   244,   245,   246,   247,   248,   249,   250,   251,
3309      252,   253,   254,   255,   256,   257,   258,   259,   260,   261,
3310      262,   263,   264,   265,   266,   267,   268,   269,   270,   271,
3311      272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
3312      282,   283,   284,   285,   286,   287,   288,   289,   290,   291,
3313      292,   324,   338,   339,   340,   341,   342,   351,   352,   353,
3314      354,   355,   356,   357,   370,   371,   372,   373,   374,   375,
3315      384,   386,   387,   388,   389,   390,   391,   392,   393,   394,
3316      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
3317      405,   406,   407,   408,   409,   410,   442,   443,   446,   447,
3318      448,   449,   453,   454,   455,   456,   457,   458,   461,   462,
3319      463,   464,   465,   467,   472,   473,   474,   515,   516,   517,
3320      473,   318,   350,   314,   314,   324,   350,   324,   518,   315,
3321      321,   450,   451,   452,   462,   467,   321,   324,   350,   324,
3322      350,   463,   467,   332,   469,   470,     0,   516,   467,   476,
3323      318,   350,   371,   459,   460,   350,   466,   316,   324,   468,
3324      318,   494,   451,   450,   452,   350,   350,   314,   323,   468,
3325      318,   321,   324,   445,   295,   296,   314,   325,   326,   327,
3326      328,   346,   347,   348,   349,   350,   376,   377,   378,   379,
3327      380,   381,   382,   383,   412,   413,   414,   416,   417,   418,
3328      419,   420,   421,   422,   423,   424,   465,   467,   471,   468,
3329      324,   462,   467,   477,   478,   475,   323,   315,   321,   315,
3330      321,   317,   423,   425,   426,   427,   428,   429,   430,   431,
3331      432,   433,   434,   435,   436,   316,   324,   316,   318,   319,
3332      324,   358,   359,   360,   361,   363,   364,   365,   366,   367,
3333      368,   369,   385,   423,   436,   438,   440,   442,   446,   465,
3334      467,   483,   484,   485,   486,   487,   495,   496,   497,   498,
3335      501,   502,   505,   506,   507,   514,   519,   468,   323,   468,
3336      318,   438,   481,   323,   444,   350,   321,   324,   423,   423,
3337      440,   295,   296,   316,   320,   315,   315,   321,   357,   438,
3338      314,   423,   321,   333,   467,   350,   479,   480,   319,   478,
3339      477,   436,   441,   460,   350,   329,   330,   331,   326,   328,
3340      293,   294,   297,   298,   332,   333,   299,   300,   336,   335,
3341      334,   301,   303,   302,   337,   317,   317,   436,   316,   319,
3342      488,   314,   324,   324,   509,   314,   314,   324,   324,   440,
3343      314,   440,   322,   324,   304,   305,   306,   307,   308,   309,
3344      310,   311,   312,   313,   323,   439,   321,   324,   319,   484,
3345      498,   502,   507,   481,   323,   481,   482,   481,   477,   350,
3346      315,   415,   440,   350,   438,   423,   479,   468,   321,   324,
3347      319,   423,   423,   423,   425,   425,   426,   426,   427,   427,
3348      427,   427,   428,   428,   429,   430,   431,   432,   433,   434,
3349      437,   317,   350,   520,   521,   495,   508,   484,   510,   440,
3350      324,   440,   322,   438,   438,   481,   319,   321,   319,   317,
3351      324,   480,   440,   314,   317,   321,   489,   440,   455,   462,
3352      500,   358,   483,   496,   511,   315,   315,   319,   481,   322,
3353      441,   317,   521,   319,   350,   315,   314,   500,   512,   513,
3354      491,   492,   493,   499,   503,   438,   315,   323,   485,   490,
3355      494,   440,   324,   315,   362,   487,   485,   318,   481,   315,
3356      440,   490,   491,   495,   504,   324,   319
3357 };
3358 
3359   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
3360 static const yytype_uint16 yyr1[] =
3361 {
3362        0,   411,   412,   413,   413,   413,   413,   413,   413,   413,
3363      413,   413,   413,   413,   413,   413,   413,   414,   414,   414,
3364      414,   414,   414,   415,   416,   417,   418,   418,   419,   419,
3365      420,   420,   421,   422,   422,   422,   423,   423,   423,   423,
3366      424,   424,   424,   424,   425,   425,   425,   425,   426,   426,
3367      426,   427,   427,   427,   428,   428,   428,   428,   428,   429,
3368      429,   429,   430,   430,   431,   431,   432,   432,   433,   433,
3369      434,   434,   435,   435,   436,   437,   436,   438,   438,   439,
3370      439,   439,   439,   439,   439,   439,   439,   439,   439,   439,
3371      440,   440,   441,   442,   442,   442,   442,   442,   442,   442,
3372      442,   442,   444,   443,   445,   445,   446,   447,   447,   448,
3373      448,   449,   450,   450,   451,   451,   451,   451,   452,   453,
3374      453,   453,   453,   453,   454,   454,   454,   454,   454,   455,
3375      455,   456,   457,   457,   457,   457,   457,   457,   457,   457,
3376      458,   459,   459,   460,   460,   460,   461,   462,   462,   463,
3377      463,   463,   463,   463,   463,   463,   464,   464,   464,   464,
3378      464,   464,   464,   464,   464,   464,   464,   464,   464,   464,
3379      464,   464,   464,   464,   464,   464,   464,   464,   464,   464,
3380      464,   464,   464,   464,   464,   465,   466,   466,   467,   467,
3381      468,   468,   468,   468,   469,   469,   470,   471,   471,   472,
3382      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3383      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3384      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3385      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3386      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3387      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3388      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3389      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3390      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3391      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3392      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3393      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3394      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3395      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3396      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3397      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3398      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3399      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3400      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3401      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3402      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3403      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3404      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3405      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3406      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3407      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3408      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3409      472,   472,   472,   472,   472,   472,   472,   472,   472,   472,
3410      472,   472,   472,   472,   472,   472,   472,   472,   472,   473,
3411      473,   473,   475,   474,   476,   474,   477,   477,   478,   478,
3412      479,   479,   480,   480,   481,   481,   481,   482,   482,   483,
3413      484,   484,   485,   485,   485,   485,   485,   485,   485,   485,
3414      486,   487,   488,   489,   487,   490,   490,   492,   491,   493,
3415      491,   494,   494,   495,   495,   496,   496,   497,   497,   498,
3416      499,   499,   500,   500,   501,   501,   503,   502,   504,   504,
3417      505,   505,   506,   506,   508,   507,   509,   507,   510,   507,
3418      511,   511,   512,   512,   513,   513,   514,   514,   514,   514,
3419      514,   515,   515,   516,   516,   516,   518,   517,   519,   520,
3420      520,   521,   521
3421 };
3422 
3423   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
3424 static const yytype_uint8 yyr2[] =
3425 {
3426        0,     2,     1,     1,     3,     1,     1,     1,     1,     1,
3427        1,     1,     1,     1,     1,     1,     1,     1,     4,     1,
3428        3,     2,     2,     1,     1,     1,     2,     2,     2,     1,
3429        2,     3,     2,     1,     1,     1,     1,     2,     2,     2,
3430        1,     1,     1,     1,     1,     3,     3,     3,     1,     3,
3431        3,     1,     3,     3,     1,     3,     3,     3,     3,     1,
3432        3,     3,     1,     3,     1,     3,     1,     3,     1,     3,
3433        1,     3,     1,     3,     1,     0,     6,     1,     3,     1,
3434        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3435        1,     3,     1,     2,     2,     4,     2,     3,     4,     2,
3436        3,     4,     0,     6,     2,     3,     2,     1,     1,     2,
3437        3,     3,     2,     3,     2,     1,     2,     1,     1,     1,
3438        3,     4,     6,     5,     1,     2,     3,     5,     4,     1,
3439        2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3440        4,     1,     3,     1,     3,     1,     1,     1,     2,     1,
3441        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3442        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3443        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3444        1,     1,     1,     1,     4,     1,     1,     3,     2,     3,
3445        2,     3,     3,     4,     1,     0,     3,     1,     3,     1,
3446        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3447        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3448        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3449        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3450        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3451        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3452        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3453        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3454        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3455        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3456        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3457        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3458        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3459        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3460        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3461        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3462        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3463        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3464        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3465        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3466        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3467        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3468        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3469        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3470        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3471        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3472        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3473        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3474        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3475        1,     1,     0,     6,     0,     5,     1,     2,     3,     4,
3476        1,     3,     1,     2,     1,     3,     4,     1,     3,     1,
3477        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3478        2,     2,     0,     0,     5,     1,     1,     0,     2,     0,
3479        2,     2,     3,     1,     2,     1,     2,     1,     2,     5,
3480        3,     1,     1,     4,     1,     2,     0,     8,     0,     1,
3481        3,     2,     1,     2,     0,     6,     0,     8,     0,     7,
3482        1,     1,     1,     0,     2,     3,     2,     2,     2,     3,
3483        2,     1,     2,     1,     1,     1,     0,     3,     5,     1,
3484        3,     1,     4
3485 };
3486 
3487 
3488 #define yyerrok         (yyerrstatus = 0)
3489 #define yyclearin       (yychar = YYEMPTY)
3490 #define YYEMPTY         (-2)
3491 #define YYEOF           0
3492 
3493 #define YYACCEPT        goto yyacceptlab
3494 #define YYABORT         goto yyabortlab
3495 #define YYERROR         goto yyerrorlab
3496 
3497 
3498 #define YYRECOVERING()  (!!yyerrstatus)
3499 
3500 #define YYBACKUP(Token, Value)                                  \
3501 do                                                              \
3502   if (yychar == YYEMPTY)                                        \
3503     {                                                           \
3504       yychar = (Token);                                         \
3505       yylval = (Value);                                         \
3506       YYPOPSTACK (yylen);                                       \
3507       yystate = *yyssp;                                         \
3508       goto yybackup;                                            \
3509     }                                                           \
3510   else                                                          \
3511     {                                                           \
3512       yyerror (pParseContext, YY_("syntax error: cannot back up")); \
3513       YYERROR;                                                  \
3514     }                                                           \
3515 while (0)
3516 
3517 /* Error token number */
3518 #define YYTERROR        1
3519 #define YYERRCODE       256
3520 
3521 
3522 
3523 /* Enable debugging if requested.  */
3524 #if YYDEBUG
3525 
3526 # ifndef YYFPRINTF
3527 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3528 #  define YYFPRINTF fprintf
3529 # endif
3530 
3531 # define YYDPRINTF(Args)                        \
3532 do {                                            \
3533   if (yydebug)                                  \
3534     YYFPRINTF Args;                             \
3535 } while (0)
3536 
3537 /* This macro is provided for backward compatibility. */
3538 #ifndef YY_LOCATION_PRINT
3539 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3540 #endif
3541 
3542 
3543 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
3544 do {                                                                      \
3545   if (yydebug)                                                            \
3546     {                                                                     \
3547       YYFPRINTF (stderr, "%s ", Title);                                   \
3548       yy_symbol_print (stderr,                                            \
3549                   Type, Value, pParseContext); \
3550       YYFPRINTF (stderr, "\n");                                           \
3551     }                                                                     \
3552 } while (0)
3553 
3554 
3555 /*----------------------------------------.
3556 | Print this symbol's value on YYOUTPUT.  |
3557 `----------------------------------------*/
3558 
3559 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,glslang::TParseContext * pParseContext)3560 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
3561 {
3562   FILE *yyo = yyoutput;
3563   YYUSE (yyo);
3564   YYUSE (pParseContext);
3565   if (!yyvaluep)
3566     return;
3567 # ifdef YYPRINT
3568   if (yytype < YYNTOKENS)
3569     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3570 # endif
3571   YYUSE (yytype);
3572 }
3573 
3574 
3575 /*--------------------------------.
3576 | Print this symbol on YYOUTPUT.  |
3577 `--------------------------------*/
3578 
3579 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,glslang::TParseContext * pParseContext)3580 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
3581 {
3582   YYFPRINTF (yyoutput, "%s %s (",
3583              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
3584 
3585   yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParseContext);
3586   YYFPRINTF (yyoutput, ")");
3587 }
3588 
3589 /*------------------------------------------------------------------.
3590 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3591 | TOP (included).                                                   |
3592 `------------------------------------------------------------------*/
3593 
3594 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)3595 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
3596 {
3597   YYFPRINTF (stderr, "Stack now");
3598   for (; yybottom <= yytop; yybottom++)
3599     {
3600       int yybot = *yybottom;
3601       YYFPRINTF (stderr, " %d", yybot);
3602     }
3603   YYFPRINTF (stderr, "\n");
3604 }
3605 
3606 # define YY_STACK_PRINT(Bottom, Top)                            \
3607 do {                                                            \
3608   if (yydebug)                                                  \
3609     yy_stack_print ((Bottom), (Top));                           \
3610 } while (0)
3611 
3612 
3613 /*------------------------------------------------.
3614 | Report that the YYRULE is going to be reduced.  |
3615 `------------------------------------------------*/
3616 
3617 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule,glslang::TParseContext * pParseContext)3618 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, glslang::TParseContext* pParseContext)
3619 {
3620   unsigned long int yylno = yyrline[yyrule];
3621   int yynrhs = yyr2[yyrule];
3622   int yyi;
3623   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
3624              yyrule - 1, yylno);
3625   /* The symbols being reduced.  */
3626   for (yyi = 0; yyi < yynrhs; yyi++)
3627     {
3628       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
3629       yy_symbol_print (stderr,
3630                        yystos[yyssp[yyi + 1 - yynrhs]],
3631                        &(yyvsp[(yyi + 1) - (yynrhs)])
3632                                               , pParseContext);
3633       YYFPRINTF (stderr, "\n");
3634     }
3635 }
3636 
3637 # define YY_REDUCE_PRINT(Rule)          \
3638 do {                                    \
3639   if (yydebug)                          \
3640     yy_reduce_print (yyssp, yyvsp, Rule, pParseContext); \
3641 } while (0)
3642 
3643 /* Nonzero means print parse trace.  It is left uninitialized so that
3644    multiple parsers can coexist.  */
3645 int yydebug;
3646 #else /* !YYDEBUG */
3647 # define YYDPRINTF(Args)
3648 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3649 # define YY_STACK_PRINT(Bottom, Top)
3650 # define YY_REDUCE_PRINT(Rule)
3651 #endif /* !YYDEBUG */
3652 
3653 
3654 /* YYINITDEPTH -- initial size of the parser's stacks.  */
3655 #ifndef YYINITDEPTH
3656 # define YYINITDEPTH 200
3657 #endif
3658 
3659 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3660    if the built-in stack extension method is used).
3661 
3662    Do not make this value too large; the results are undefined if
3663    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3664    evaluated with infinite-precision integer arithmetic.  */
3665 
3666 #ifndef YYMAXDEPTH
3667 # define YYMAXDEPTH 10000
3668 #endif
3669 
3670 
3671 #if YYERROR_VERBOSE
3672 
3673 # ifndef yystrlen
3674 #  if defined __GLIBC__ && defined _STRING_H
3675 #   define yystrlen strlen
3676 #  else
3677 /* Return the length of YYSTR.  */
3678 static YYSIZE_T
yystrlen(const char * yystr)3679 yystrlen (const char *yystr)
3680 {
3681   YYSIZE_T yylen;
3682   for (yylen = 0; yystr[yylen]; yylen++)
3683     continue;
3684   return yylen;
3685 }
3686 #  endif
3687 # endif
3688 
3689 # ifndef yystpcpy
3690 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
3691 #   define yystpcpy stpcpy
3692 #  else
3693 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3694    YYDEST.  */
3695 static char *
yystpcpy(char * yydest,const char * yysrc)3696 yystpcpy (char *yydest, const char *yysrc)
3697 {
3698   char *yyd = yydest;
3699   const char *yys = yysrc;
3700 
3701   while ((*yyd++ = *yys++) != '\0')
3702     continue;
3703 
3704   return yyd - 1;
3705 }
3706 #  endif
3707 # endif
3708 
3709 # ifndef yytnamerr
3710 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3711    quotes and backslashes, so that it's suitable for yyerror.  The
3712    heuristic is that double-quoting is unnecessary unless the string
3713    contains an apostrophe, a comma, or backslash (other than
3714    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
3715    null, do not copy; instead, return the length of what the result
3716    would have been.  */
3717 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)3718 yytnamerr (char *yyres, const char *yystr)
3719 {
3720   if (*yystr == '"')
3721     {
3722       YYSIZE_T yyn = 0;
3723       char const *yyp = yystr;
3724 
3725       for (;;)
3726         switch (*++yyp)
3727           {
3728           case '\'':
3729           case ',':
3730             goto do_not_strip_quotes;
3731 
3732           case '\\':
3733             if (*++yyp != '\\')
3734               goto do_not_strip_quotes;
3735             /* Fall through.  */
3736           default:
3737             if (yyres)
3738               yyres[yyn] = *yyp;
3739             yyn++;
3740             break;
3741 
3742           case '"':
3743             if (yyres)
3744               yyres[yyn] = '\0';
3745             return yyn;
3746           }
3747     do_not_strip_quotes: ;
3748     }
3749 
3750   if (! yyres)
3751     return yystrlen (yystr);
3752 
3753   return yystpcpy (yyres, yystr) - yyres;
3754 }
3755 # endif
3756 
3757 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
3758    about the unexpected token YYTOKEN for the state stack whose top is
3759    YYSSP.
3760 
3761    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
3762    not large enough to hold the message.  In that case, also set
3763    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
3764    required number of bytes is too large to store.  */
3765 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)3766 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
3767                 yytype_int16 *yyssp, int yytoken)
3768 {
3769   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
3770   YYSIZE_T yysize = yysize0;
3771   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3772   /* Internationalized format string. */
3773   const char *yyformat = YY_NULLPTR;
3774   /* Arguments of yyformat. */
3775   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3776   /* Number of reported tokens (one for the "unexpected", one per
3777      "expected"). */
3778   int yycount = 0;
3779 
3780   /* There are many possibilities here to consider:
3781      - If this state is a consistent state with a default action, then
3782        the only way this function was invoked is if the default action
3783        is an error action.  In that case, don't check for expected
3784        tokens because there are none.
3785      - The only way there can be no lookahead present (in yychar) is if
3786        this state is a consistent state with a default action.  Thus,
3787        detecting the absence of a lookahead is sufficient to determine
3788        that there is no unexpected or expected token to report.  In that
3789        case, just report a simple "syntax error".
3790      - Don't assume there isn't a lookahead just because this state is a
3791        consistent state with a default action.  There might have been a
3792        previous inconsistent state, consistent state with a non-default
3793        action, or user semantic action that manipulated yychar.
3794      - Of course, the expected token list depends on states to have
3795        correct lookahead information, and it depends on the parser not
3796        to perform extra reductions after fetching a lookahead from the
3797        scanner and before detecting a syntax error.  Thus, state merging
3798        (from LALR or IELR) and default reductions corrupt the expected
3799        token list.  However, the list is correct for canonical LR with
3800        one exception: it will still contain any token that will not be
3801        accepted due to an error action in a later state.
3802   */
3803   if (yytoken != YYEMPTY)
3804     {
3805       int yyn = yypact[*yyssp];
3806       yyarg[yycount++] = yytname[yytoken];
3807       if (!yypact_value_is_default (yyn))
3808         {
3809           /* Start YYX at -YYN if negative to avoid negative indexes in
3810              YYCHECK.  In other words, skip the first -YYN actions for
3811              this state because they are default actions.  */
3812           int yyxbegin = yyn < 0 ? -yyn : 0;
3813           /* Stay within bounds of both yycheck and yytname.  */
3814           int yychecklim = YYLAST - yyn + 1;
3815           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3816           int yyx;
3817 
3818           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3819             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
3820                 && !yytable_value_is_error (yytable[yyx + yyn]))
3821               {
3822                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3823                   {
3824                     yycount = 1;
3825                     yysize = yysize0;
3826                     break;
3827                   }
3828                 yyarg[yycount++] = yytname[yyx];
3829                 {
3830                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
3831                   if (! (yysize <= yysize1
3832                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
3833                     return 2;
3834                   yysize = yysize1;
3835                 }
3836               }
3837         }
3838     }
3839 
3840   switch (yycount)
3841     {
3842 # define YYCASE_(N, S)                      \
3843       case N:                               \
3844         yyformat = S;                       \
3845       break
3846       YYCASE_(0, YY_("syntax error"));
3847       YYCASE_(1, YY_("syntax error, unexpected %s"));
3848       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
3849       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
3850       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
3851       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
3852 # undef YYCASE_
3853     }
3854 
3855   {
3856     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
3857     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
3858       return 2;
3859     yysize = yysize1;
3860   }
3861 
3862   if (*yymsg_alloc < yysize)
3863     {
3864       *yymsg_alloc = 2 * yysize;
3865       if (! (yysize <= *yymsg_alloc
3866              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
3867         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
3868       return 1;
3869     }
3870 
3871   /* Avoid sprintf, as that infringes on the user's name space.
3872      Don't have undefined behavior even if the translation
3873      produced a string with the wrong number of "%s"s.  */
3874   {
3875     char *yyp = *yymsg;
3876     int yyi = 0;
3877     while ((*yyp = *yyformat) != '\0')
3878       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
3879         {
3880           yyp += yytnamerr (yyp, yyarg[yyi++]);
3881           yyformat += 2;
3882         }
3883       else
3884         {
3885           yyp++;
3886           yyformat++;
3887         }
3888   }
3889   return 0;
3890 }
3891 #endif /* YYERROR_VERBOSE */
3892 
3893 /*-----------------------------------------------.
3894 | Release the memory associated to this symbol.  |
3895 `-----------------------------------------------*/
3896 
3897 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,glslang::TParseContext * pParseContext)3898 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext)
3899 {
3900   YYUSE (yyvaluep);
3901   YYUSE (pParseContext);
3902   if (!yymsg)
3903     yymsg = "Deleting";
3904   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3905 
3906   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3907   YYUSE (yytype);
3908   YY_IGNORE_MAYBE_UNINITIALIZED_END
3909 }
3910 
3911 
3912 
3913 
3914 /*----------.
3915 | yyparse.  |
3916 `----------*/
3917 
3918 int
yyparse(glslang::TParseContext * pParseContext)3919 yyparse (glslang::TParseContext* pParseContext)
3920 {
3921 /* The lookahead symbol.  */
3922 int yychar;
3923 
3924 
3925 /* The semantic value of the lookahead symbol.  */
3926 /* Default value used for initialization, for pacifying older GCCs
3927    or non-GCC compilers.  */
3928 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
3929 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
3930 
3931     /* Number of syntax errors so far.  */
3932     int yynerrs;
3933 
3934     int yystate;
3935     /* Number of tokens to shift before error messages enabled.  */
3936     int yyerrstatus;
3937 
3938     /* The stacks and their tools:
3939        'yyss': related to states.
3940        'yyvs': related to semantic values.
3941 
3942        Refer to the stacks through separate pointers, to allow yyoverflow
3943        to reallocate them elsewhere.  */
3944 
3945     /* The state stack.  */
3946     yytype_int16 yyssa[YYINITDEPTH];
3947     yytype_int16 *yyss;
3948     yytype_int16 *yyssp;
3949 
3950     /* The semantic value stack.  */
3951     YYSTYPE yyvsa[YYINITDEPTH];
3952     YYSTYPE *yyvs;
3953     YYSTYPE *yyvsp;
3954 
3955     YYSIZE_T yystacksize;
3956 
3957   int yyn;
3958   int yyresult;
3959   /* Lookahead token as an internal (translated) token number.  */
3960   int yytoken = 0;
3961   /* The variables used to return semantic value and location from the
3962      action routines.  */
3963   YYSTYPE yyval;
3964 
3965 #if YYERROR_VERBOSE
3966   /* Buffer for error messages, and its allocated size.  */
3967   char yymsgbuf[128];
3968   char *yymsg = yymsgbuf;
3969   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3970 #endif
3971 
3972 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
3973 
3974   /* The number of symbols on the RHS of the reduced rule.
3975      Keep to zero when no symbol should be popped.  */
3976   int yylen = 0;
3977 
3978   yyssp = yyss = yyssa;
3979   yyvsp = yyvs = yyvsa;
3980   yystacksize = YYINITDEPTH;
3981 
3982   YYDPRINTF ((stderr, "Starting parse\n"));
3983 
3984   yystate = 0;
3985   yyerrstatus = 0;
3986   yynerrs = 0;
3987   yychar = YYEMPTY; /* Cause a token to be read.  */
3988   goto yysetstate;
3989 
3990 /*------------------------------------------------------------.
3991 | yynewstate -- Push a new state, which is found in yystate.  |
3992 `------------------------------------------------------------*/
3993  yynewstate:
3994   /* In all cases, when you get here, the value and location stacks
3995      have just been pushed.  So pushing a state here evens the stacks.  */
3996   yyssp++;
3997 
3998  yysetstate:
3999   *yyssp = yystate;
4000 
4001   if (yyss + yystacksize - 1 <= yyssp)
4002     {
4003       /* Get the current used size of the three stacks, in elements.  */
4004       YYSIZE_T yysize = yyssp - yyss + 1;
4005 
4006 #ifdef yyoverflow
4007       {
4008         /* Give user a chance to reallocate the stack.  Use copies of
4009            these so that the &'s don't force the real ones into
4010            memory.  */
4011         YYSTYPE *yyvs1 = yyvs;
4012         yytype_int16 *yyss1 = yyss;
4013 
4014         /* Each stack pointer address is followed by the size of the
4015            data in use in that stack, in bytes.  This used to be a
4016            conditional around just the two extra args, but that might
4017            be undefined if yyoverflow is a macro.  */
4018         yyoverflow (YY_("memory exhausted"),
4019                     &yyss1, yysize * sizeof (*yyssp),
4020                     &yyvs1, yysize * sizeof (*yyvsp),
4021                     &yystacksize);
4022 
4023         yyss = yyss1;
4024         yyvs = yyvs1;
4025       }
4026 #else /* no yyoverflow */
4027 # ifndef YYSTACK_RELOCATE
4028       goto yyexhaustedlab;
4029 # else
4030       /* Extend the stack our own way.  */
4031       if (YYMAXDEPTH <= yystacksize)
4032         goto yyexhaustedlab;
4033       yystacksize *= 2;
4034       if (YYMAXDEPTH < yystacksize)
4035         yystacksize = YYMAXDEPTH;
4036 
4037       {
4038         yytype_int16 *yyss1 = yyss;
4039         union yyalloc *yyptr =
4040           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4041         if (! yyptr)
4042           goto yyexhaustedlab;
4043         YYSTACK_RELOCATE (yyss_alloc, yyss);
4044         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4045 #  undef YYSTACK_RELOCATE
4046         if (yyss1 != yyssa)
4047           YYSTACK_FREE (yyss1);
4048       }
4049 # endif
4050 #endif /* no yyoverflow */
4051 
4052       yyssp = yyss + yysize - 1;
4053       yyvsp = yyvs + yysize - 1;
4054 
4055       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4056                   (unsigned long int) yystacksize));
4057 
4058       if (yyss + yystacksize - 1 <= yyssp)
4059         YYABORT;
4060     }
4061 
4062   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4063 
4064   if (yystate == YYFINAL)
4065     YYACCEPT;
4066 
4067   goto yybackup;
4068 
4069 /*-----------.
4070 | yybackup.  |
4071 `-----------*/
4072 yybackup:
4073 
4074   /* Do appropriate processing given the current state.  Read a
4075      lookahead token if we need one and don't already have one.  */
4076 
4077   /* First try to decide what to do without reference to lookahead token.  */
4078   yyn = yypact[yystate];
4079   if (yypact_value_is_default (yyn))
4080     goto yydefault;
4081 
4082   /* Not known => get a lookahead token if don't already have one.  */
4083 
4084   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
4085   if (yychar == YYEMPTY)
4086     {
4087       YYDPRINTF ((stderr, "Reading a token: "));
4088       yychar = yylex (&yylval, parseContext);
4089     }
4090 
4091   if (yychar <= YYEOF)
4092     {
4093       yychar = yytoken = YYEOF;
4094       YYDPRINTF ((stderr, "Now at end of input.\n"));
4095     }
4096   else
4097     {
4098       yytoken = YYTRANSLATE (yychar);
4099       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4100     }
4101 
4102   /* If the proper action on seeing token YYTOKEN is to reduce or to
4103      detect an error, take that action.  */
4104   yyn += yytoken;
4105   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4106     goto yydefault;
4107   yyn = yytable[yyn];
4108   if (yyn <= 0)
4109     {
4110       if (yytable_value_is_error (yyn))
4111         goto yyerrlab;
4112       yyn = -yyn;
4113       goto yyreduce;
4114     }
4115 
4116   /* Count tokens shifted since error; after three, turn off error
4117      status.  */
4118   if (yyerrstatus)
4119     yyerrstatus--;
4120 
4121   /* Shift the lookahead token.  */
4122   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4123 
4124   /* Discard the shifted token.  */
4125   yychar = YYEMPTY;
4126 
4127   yystate = yyn;
4128   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4129   *++yyvsp = yylval;
4130   YY_IGNORE_MAYBE_UNINITIALIZED_END
4131 
4132   goto yynewstate;
4133 
4134 
4135 /*-----------------------------------------------------------.
4136 | yydefault -- do the default action for the current state.  |
4137 `-----------------------------------------------------------*/
4138 yydefault:
4139   yyn = yydefact[yystate];
4140   if (yyn == 0)
4141     goto yyerrlab;
4142   goto yyreduce;
4143 
4144 
4145 /*-----------------------------.
4146 | yyreduce -- Do a reduction.  |
4147 `-----------------------------*/
4148 yyreduce:
4149   /* yyn is the number of a rule to reduce with.  */
4150   yylen = yyr2[yyn];
4151 
4152   /* If YYLEN is nonzero, implement the default value of the action:
4153      '$$ = $1'.
4154 
4155      Otherwise, the following line sets YYVAL to garbage.
4156      This behavior is undocumented and Bison
4157      users should not rely upon it.  Assigning to YYVAL
4158      unconditionally makes the parser a bit smaller, and it avoids a
4159      GCC warning that YYVAL may be used uninitialized.  */
4160   yyval = yyvsp[1-yylen];
4161 
4162 
4163   YY_REDUCE_PRINT (yyn);
4164   switch (yyn)
4165     {
4166         case 2:
4167 #line 352 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4168     {
4169         (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
4170     }
4171 #line 4172 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4172     break;
4173 
4174   case 3:
4175 #line 358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4176     {
4177         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4178     }
4179 #line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4180     break;
4181 
4182   case 4:
4183 #line 361 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4184     {
4185         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
4186         if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
4187             (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
4188     }
4189 #line 4190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4190     break;
4191 
4192   case 5:
4193 #line 366 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4194     {
4195         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
4196     }
4197 #line 4198 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4198     break;
4199 
4200   case 6:
4201 #line 369 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4202     {
4203         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4204     }
4205 #line 4206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4206     break;
4207 
4208   case 7:
4209 #line 372 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4210     {
4211         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
4212         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4213     }
4214 #line 4215 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4215     break;
4216 
4217   case 8:
4218 #line 376 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4219     {
4220         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
4221     }
4222 #line 4223 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4223     break;
4224 
4225   case 9:
4226 #line 380 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4227     {
4228         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
4229         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4230     }
4231 #line 4232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4232     break;
4233 
4234   case 10:
4235 #line 384 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4236     {
4237         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
4238         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4239     }
4240 #line 4241 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4241     break;
4242 
4243   case 11:
4244 #line 388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4245     {
4246         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
4247         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
4248     }
4249 #line 4250 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4250     break;
4251 
4252   case 12:
4253 #line 392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4254     {
4255         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
4256         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
4257     }
4258 #line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4259     break;
4260 
4261   case 13:
4262 #line 396 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4263     {
4264         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
4265         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4266     }
4267 #line 4268 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4268     break;
4269 
4270   case 14:
4271 #line 400 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4272     {
4273         parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
4274         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4275     }
4276 #line 4277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4277     break;
4278 
4279   case 15:
4280 #line 404 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4281     {
4282         parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal");
4283         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true);
4284     }
4285 #line 4286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4286     break;
4287 
4288   case 16:
4289 #line 408 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4290     {
4291         parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
4292         (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
4293     }
4294 #line 4295 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4295     break;
4296 
4297   case 17:
4298 #line 416 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4299     {
4300         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4301     }
4302 #line 4303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4303     break;
4304 
4305   case 18:
4306 #line 419 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4307     {
4308         (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
4309     }
4310 #line 4311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4311     break;
4312 
4313   case 19:
4314 #line 422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4315     {
4316         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4317     }
4318 #line 4319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4319     break;
4320 
4321   case 20:
4322 #line 425 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4323     {
4324         (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
4325     }
4326 #line 4327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4327     break;
4328 
4329   case 21:
4330 #line 428 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4331     {
4332         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
4333         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
4334         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
4335     }
4336 #line 4337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4337     break;
4338 
4339   case 22:
4340 #line 433 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4341     {
4342         parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
4343         parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
4344         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
4345     }
4346 #line 4347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4347     break;
4348 
4349   case 23:
4350 #line 441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4351     {
4352         parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
4353         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4354     }
4355 #line 4356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4356     break;
4357 
4358   case 24:
4359 #line 448 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4360     {
4361         (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
4362         delete (yyvsp[0].interm).function;
4363     }
4364 #line 4365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4365     break;
4366 
4367   case 25:
4368 #line 455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4369     {
4370         (yyval.interm) = (yyvsp[0].interm);
4371     }
4372 #line 4373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4373     break;
4374 
4375   case 26:
4376 #line 461 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4377     {
4378         (yyval.interm) = (yyvsp[-1].interm);
4379         (yyval.interm).loc = (yyvsp[0].lex).loc;
4380     }
4381 #line 4382 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4382     break;
4383 
4384   case 27:
4385 #line 465 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4386     {
4387         (yyval.interm) = (yyvsp[-1].interm);
4388         (yyval.interm).loc = (yyvsp[0].lex).loc;
4389     }
4390 #line 4391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4391     break;
4392 
4393   case 28:
4394 #line 472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4395     {
4396         (yyval.interm) = (yyvsp[-1].interm);
4397     }
4398 #line 4399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4399     break;
4400 
4401   case 29:
4402 #line 475 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4403     {
4404         (yyval.interm) = (yyvsp[0].interm);
4405     }
4406 #line 4407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4407     break;
4408 
4409   case 30:
4410 #line 481 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4411     {
4412         TParameter param = { 0, new TType };
4413         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
4414         (yyvsp[-1].interm).function->addParameter(param);
4415         (yyval.interm).function = (yyvsp[-1].interm).function;
4416         (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
4417     }
4418 #line 4419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4419     break;
4420 
4421   case 31:
4422 #line 488 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4423     {
4424         TParameter param = { 0, new TType };
4425         param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
4426         (yyvsp[-2].interm).function->addParameter(param);
4427         (yyval.interm).function = (yyvsp[-2].interm).function;
4428         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
4429     }
4430 #line 4431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4431     break;
4432 
4433   case 32:
4434 #line 498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4435     {
4436         (yyval.interm) = (yyvsp[-1].interm);
4437     }
4438 #line 4439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4439     break;
4440 
4441   case 33:
4442 #line 506 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4443     {
4444         // Constructor
4445         (yyval.interm).intermNode = 0;
4446         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
4447     }
4448 #line 4449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4449     break;
4450 
4451   case 34:
4452 #line 511 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4453     {
4454         //
4455         // Should be a method or subroutine call, but we haven't recognized the arguments yet.
4456         //
4457         (yyval.interm).function = 0;
4458         (yyval.interm).intermNode = 0;
4459 
4460         TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode();
4461         if (method) {
4462             (yyval.interm).function = new TFunction(&method->getMethodName(), TType(EbtInt), EOpArrayLength);
4463             (yyval.interm).intermNode = method->getObject();
4464         } else {
4465             TIntermSymbol* symbol = (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode();
4466             if (symbol) {
4467                 parseContext.reservedErrorCheck(symbol->getLoc(), symbol->getName());
4468                 TFunction *function = new TFunction(&symbol->getName(), TType(EbtVoid));
4469                 (yyval.interm).function = function;
4470             } else
4471                 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "function call, method, or subroutine call expected", "", "");
4472         }
4473 
4474         if ((yyval.interm).function == 0) {
4475             // error recover
4476             TString* empty = NewPoolTString("");
4477             (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull);
4478         }
4479     }
4480 #line 4481 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4481     break;
4482 
4483   case 35:
4484 #line 539 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4485     {
4486         // Constructor
4487         (yyval.interm).intermNode = 0;
4488         (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
4489     }
4490 #line 4491 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4491     break;
4492 
4493   case 36:
4494 #line 548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4495     {
4496         parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
4497         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4498         if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
4499             parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
4500     }
4501 #line 4502 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4502     break;
4503 
4504   case 37:
4505 #line 554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4506     {
4507         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
4508         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
4509     }
4510 #line 4511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4511     break;
4512 
4513   case 38:
4514 #line 558 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4515     {
4516         parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
4517         (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
4518     }
4519 #line 4520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4520     break;
4521 
4522   case 39:
4523 #line 562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4524     {
4525         if ((yyvsp[-1].interm).op != EOpNull) {
4526             char errorOp[2] = {0, 0};
4527             switch((yyvsp[-1].interm).op) {
4528             case EOpNegative:   errorOp[0] = '-'; break;
4529             case EOpLogicalNot: errorOp[0] = '!'; break;
4530             case EOpBitwiseNot: errorOp[0] = '~'; break;
4531             default: break; // some compilers want this
4532             }
4533             (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].interm).loc, errorOp, (yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode));
4534         } else {
4535             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4536             if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
4537                 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
4538         }
4539     }
4540 #line 4541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4541     break;
4542 
4543   case 40:
4544 #line 582 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4545     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
4546 #line 4547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4547     break;
4548 
4549   case 41:
4550 #line 583 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4551     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
4552 #line 4553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4553     break;
4554 
4555   case 42:
4556 #line 584 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4557     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
4558 #line 4559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4559     break;
4560 
4561   case 43:
4562 #line 585 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4563     { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
4564               parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
4565 #line 4566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4566     break;
4567 
4568   case 44:
4569 #line 591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4570     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4571 #line 4572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4572     break;
4573 
4574   case 45:
4575 #line 592 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4576     {
4577         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4578         if ((yyval.interm.intermTypedNode) == 0)
4579             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4580     }
4581 #line 4582 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4582     break;
4583 
4584   case 46:
4585 #line 597 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4586     {
4587         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4588         if ((yyval.interm.intermTypedNode) == 0)
4589             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4590     }
4591 #line 4592 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4592     break;
4593 
4594   case 47:
4595 #line 602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4596     {
4597         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
4598         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4599         if ((yyval.interm.intermTypedNode) == 0)
4600             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4601     }
4602 #line 4603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4603     break;
4604 
4605   case 48:
4606 #line 611 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4607     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4608 #line 4609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4609     break;
4610 
4611   case 49:
4612 #line 612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4613     {
4614         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4615         if ((yyval.interm.intermTypedNode) == 0)
4616             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4617     }
4618 #line 4619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4619     break;
4620 
4621   case 50:
4622 #line 617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4623     {
4624         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4625         if ((yyval.interm.intermTypedNode) == 0)
4626             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4627     }
4628 #line 4629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4629     break;
4630 
4631   case 51:
4632 #line 625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4633     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4634 #line 4635 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4635     break;
4636 
4637   case 52:
4638 #line 626 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4639     {
4640         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
4641         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4642         if ((yyval.interm.intermTypedNode) == 0)
4643             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4644     }
4645 #line 4646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4646     break;
4647 
4648   case 53:
4649 #line 632 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4650     {
4651         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
4652         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4653         if ((yyval.interm.intermTypedNode) == 0)
4654             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4655     }
4656 #line 4657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4657     break;
4658 
4659   case 54:
4660 #line 641 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4661     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4662 #line 4663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4663     break;
4664 
4665   case 55:
4666 #line 642 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4667     {
4668         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4669         if ((yyval.interm.intermTypedNode) == 0)
4670             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4671     }
4672 #line 4673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4673     break;
4674 
4675   case 56:
4676 #line 647 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4677     {
4678         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4679         if ((yyval.interm.intermTypedNode) == 0)
4680             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4681     }
4682 #line 4683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4683     break;
4684 
4685   case 57:
4686 #line 652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4687     {
4688         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4689         if ((yyval.interm.intermTypedNode) == 0)
4690             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4691     }
4692 #line 4693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4693     break;
4694 
4695   case 58:
4696 #line 657 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4697     {
4698         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4699         if ((yyval.interm.intermTypedNode) == 0)
4700             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4701     }
4702 #line 4703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4703     break;
4704 
4705   case 59:
4706 #line 665 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4707     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4708 #line 4709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4709     break;
4710 
4711   case 60:
4712 #line 666 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4713     {
4714         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
4715         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
4716         parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
4717         parseContext.referenceCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
4718         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "==", EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4719         if ((yyval.interm.intermTypedNode) == 0)
4720             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4721     }
4722 #line 4723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4723     break;
4724 
4725   case 61:
4726 #line 675 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4727     {
4728         parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
4729         parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
4730         parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
4731         parseContext.referenceCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
4732         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "!=", EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4733         if ((yyval.interm.intermTypedNode) == 0)
4734             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4735     }
4736 #line 4737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4737     break;
4738 
4739   case 62:
4740 #line 687 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4741     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4742 #line 4743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4743     break;
4744 
4745   case 63:
4746 #line 688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4747     {
4748         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
4749         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4750         if ((yyval.interm.intermTypedNode) == 0)
4751             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4752     }
4753 #line 4754 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4754     break;
4755 
4756   case 64:
4757 #line 697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4758     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4759 #line 4760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4760     break;
4761 
4762   case 65:
4763 #line 698 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4764     {
4765         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
4766         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4767         if ((yyval.interm.intermTypedNode) == 0)
4768             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4769     }
4770 #line 4771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4771     break;
4772 
4773   case 66:
4774 #line 707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4775     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4776 #line 4777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4777     break;
4778 
4779   case 67:
4780 #line 708 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4781     {
4782         parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
4783         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4784         if ((yyval.interm.intermTypedNode) == 0)
4785             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4786     }
4787 #line 4788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4788     break;
4789 
4790   case 68:
4791 #line 717 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4792     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4793 #line 4794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4794     break;
4795 
4796   case 69:
4797 #line 718 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4798     {
4799         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4800         if ((yyval.interm.intermTypedNode) == 0)
4801             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4802     }
4803 #line 4804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4804     break;
4805 
4806   case 70:
4807 #line 726 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4808     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4809 #line 4810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4810     break;
4811 
4812   case 71:
4813 #line 727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4814     {
4815         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4816         if ((yyval.interm.intermTypedNode) == 0)
4817             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4818     }
4819 #line 4820 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4820     break;
4821 
4822   case 72:
4823 #line 735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4824     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4825 #line 4826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4826     break;
4827 
4828   case 73:
4829 #line 736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4830     {
4831         (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4832         if ((yyval.interm.intermTypedNode) == 0)
4833             (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4834     }
4835 #line 4836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4836     break;
4837 
4838   case 74:
4839 #line 744 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4840     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4841 #line 4842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4842     break;
4843 
4844   case 75:
4845 #line 745 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4846     {
4847         ++parseContext.controlFlowNestingLevel;
4848     }
4849 #line 4850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4850     break;
4851 
4852   case 76:
4853 #line 748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4854     {
4855         --parseContext.controlFlowNestingLevel;
4856         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
4857         parseContext.rValueErrorCheck((yyvsp[-4].lex).loc, "?", (yyvsp[-5].interm.intermTypedNode));
4858         parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode));
4859         parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[0].interm.intermTypedNode));
4860         (yyval.interm.intermTypedNode) = parseContext.intermediate.addSelection((yyvsp[-5].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-4].lex).loc);
4861         if ((yyval.interm.intermTypedNode) == 0) {
4862             parseContext.binaryOpError((yyvsp[-4].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
4863             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4864         }
4865     }
4866 #line 4867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4867     break;
4868 
4869   case 77:
4870 #line 763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4871     { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4872 #line 4873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4873     break;
4874 
4875   case 78:
4876 #line 764 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4877     {
4878         parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
4879         parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4880         parseContext.storage16BitAssignmentCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4881         parseContext.specializationCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4882         parseContext.lValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode));
4883         parseContext.rValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[0].interm.intermTypedNode));
4884         (yyval.interm.intermTypedNode) = parseContext.intermediate.addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].interm).loc);
4885         if ((yyval.interm.intermTypedNode) == 0) {
4886             parseContext.assignError((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
4887             (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4888         }
4889     }
4890 #line 4891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4891     break;
4892 
4893   case 79:
4894 #line 780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4895     {
4896         (yyval.interm).loc = (yyvsp[0].lex).loc;
4897         (yyval.interm).op = EOpAssign;
4898     }
4899 #line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4900     break;
4901 
4902   case 80:
4903 #line 784 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4904     {
4905         (yyval.interm).loc = (yyvsp[0].lex).loc;
4906         (yyval.interm).op = EOpMulAssign;
4907     }
4908 #line 4909 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4909     break;
4910 
4911   case 81:
4912 #line 788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4913     {
4914         (yyval.interm).loc = (yyvsp[0].lex).loc;
4915         (yyval.interm).op = EOpDivAssign;
4916     }
4917 #line 4918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4918     break;
4919 
4920   case 82:
4921 #line 792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4922     {
4923         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
4924         (yyval.interm).loc = (yyvsp[0].lex).loc;
4925         (yyval.interm).op = EOpModAssign;
4926     }
4927 #line 4928 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4928     break;
4929 
4930   case 83:
4931 #line 797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4932     {
4933         (yyval.interm).loc = (yyvsp[0].lex).loc;
4934         (yyval.interm).op = EOpAddAssign;
4935     }
4936 #line 4937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4937     break;
4938 
4939   case 84:
4940 #line 801 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4941     {
4942         (yyval.interm).loc = (yyvsp[0].lex).loc;
4943         (yyval.interm).op = EOpSubAssign;
4944     }
4945 #line 4946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4946     break;
4947 
4948   case 85:
4949 #line 805 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4950     {
4951         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
4952         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
4953     }
4954 #line 4955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4955     break;
4956 
4957   case 86:
4958 #line 809 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4959     {
4960         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
4961         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
4962     }
4963 #line 4964 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4964     break;
4965 
4966   case 87:
4967 #line 813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4968     {
4969         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
4970         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
4971     }
4972 #line 4973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4973     break;
4974 
4975   case 88:
4976 #line 817 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4977     {
4978         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
4979         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
4980     }
4981 #line 4982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4982     break;
4983 
4984   case 89:
4985 #line 821 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4986     {
4987         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
4988         (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
4989     }
4990 #line 4991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4991     break;
4992 
4993   case 90:
4994 #line 828 "MachineIndependent/glslang.y" /* yacc.c:1646  */
4995     {
4996         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4997     }
4998 #line 4999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
4999     break;
5000 
5001   case 91:
5002 #line 831 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5003     {
5004         parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
5005         (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
5006         if ((yyval.interm.intermTypedNode) == 0) {
5007             parseContext.binaryOpError((yyvsp[-1].lex).loc, ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
5008             (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
5009         }
5010     }
5011 #line 5012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5012     break;
5013 
5014   case 92:
5015 #line 842 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5016     {
5017         parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
5018         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
5019     }
5020 #line 5021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5021     break;
5022 
5023   case 93:
5024 #line 849 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5025     {
5026         parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
5027         (yyval.interm.intermNode) = 0;
5028         // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
5029     }
5030 #line 5031 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5031     break;
5032 
5033   case 94:
5034 #line 854 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5035     {
5036         if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
5037             (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
5038         (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
5039     }
5040 #line 5041 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5041     break;
5042 
5043   case 95:
5044 #line 859 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5045     {
5046         parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
5047         // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope
5048         parseContext.symbolTable.setPreviousDefaultPrecisions(&parseContext.defaultPrecision[0]);
5049         parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
5050         (yyval.interm.intermNode) = 0;
5051     }
5052 #line 5053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5053     break;
5054 
5055   case 96:
5056 #line 866 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5057     {
5058         parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
5059         (yyval.interm.intermNode) = 0;
5060     }
5061 #line 5062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5062     break;
5063 
5064   case 97:
5065 #line 870 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5066     {
5067         parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
5068         (yyval.interm.intermNode) = 0;
5069     }
5070 #line 5071 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5071     break;
5072 
5073   case 98:
5074 #line 874 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5075     {
5076         parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
5077         (yyval.interm.intermNode) = 0;
5078     }
5079 #line 5080 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5080     break;
5081 
5082   case 99:
5083 #line 878 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5084     {
5085         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
5086         parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
5087         (yyval.interm.intermNode) = 0;
5088     }
5089 #line 5090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5090     break;
5091 
5092   case 100:
5093 #line 883 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5094     {
5095         parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
5096         parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
5097         (yyval.interm.intermNode) = 0;
5098     }
5099 #line 5100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5100     break;
5101 
5102   case 101:
5103 #line 888 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5104     {
5105         parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers);
5106         (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string);
5107         parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
5108         (yyval.interm.intermNode) = 0;
5109     }
5110 #line 5111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5111     break;
5112 
5113   case 102:
5114 #line 897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5115     { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
5116 #line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5117     break;
5118 
5119   case 103:
5120 #line 897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5121     {
5122         --parseContext.structNestingLevel;
5123         parseContext.blockName = (yyvsp[-4].lex).string;
5124         parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier);
5125         parseContext.checkNoShaderLayouts((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).shaderQualifiers);
5126         parseContext.currentBlockQualifier = (yyvsp[-5].interm.type).qualifier;
5127         (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
5128         (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
5129     }
5130 #line 5131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5131     break;
5132 
5133   case 104:
5134 #line 908 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5135     {
5136         (yyval.interm.identifierList) = new TIdentifierList;
5137         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
5138     }
5139 #line 5140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5140     break;
5141 
5142   case 105:
5143 #line 912 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5144     {
5145         (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
5146         (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
5147     }
5148 #line 5149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5149     break;
5150 
5151   case 106:
5152 #line 919 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5153     {
5154         (yyval.interm).function = (yyvsp[-1].interm.function);
5155         (yyval.interm).loc = (yyvsp[0].lex).loc;
5156     }
5157 #line 5158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5158     break;
5159 
5160   case 107:
5161 #line 926 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5162     {
5163         (yyval.interm.function) = (yyvsp[0].interm.function);
5164     }
5165 #line 5166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5166     break;
5167 
5168   case 108:
5169 #line 929 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5170     {
5171         (yyval.interm.function) = (yyvsp[0].interm.function);
5172     }
5173 #line 5174 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5174     break;
5175 
5176   case 109:
5177 #line 936 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5178     {
5179         // Add the parameter
5180         (yyval.interm.function) = (yyvsp[-1].interm.function);
5181         if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid)
5182             (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param);
5183         else
5184             delete (yyvsp[0].interm).param.type;
5185     }
5186 #line 5187 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5187     break;
5188 
5189   case 110:
5190 #line 944 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5191     {
5192         //
5193         // Only first parameter of one-parameter functions can be void
5194         // The check for named parameters not being void is done in parameter_declarator
5195         //
5196         if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) {
5197             //
5198             // This parameter > first is void
5199             //
5200             parseContext.error((yyvsp[-1].lex).loc, "cannot be an argument type except for '(void)'", "void", "");
5201             delete (yyvsp[0].interm).param.type;
5202         } else {
5203             // Add the parameter
5204             (yyval.interm.function) = (yyvsp[-2].interm.function);
5205             (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
5206         }
5207     }
5208 #line 5209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5209     break;
5210 
5211   case 111:
5212 #line 964 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5213     {
5214         if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
5215             parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
5216                                GetStorageQualifierString((yyvsp[-2].interm.type).qualifier.storage), "");
5217         }
5218         if ((yyvsp[-2].interm.type).arraySizes)
5219             parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
5220 
5221         // Add the function as a prototype after parsing it (we do not support recursion)
5222         TFunction *function;
5223         TType type((yyvsp[-2].interm.type));
5224 
5225         // Potentially rename shader entry point function.  No-op most of the time.
5226         parseContext.renameShaderFunction((yyvsp[-1].lex).string);
5227 
5228         // Make the function
5229         function = new TFunction((yyvsp[-1].lex).string, type);
5230         (yyval.interm.function) = function;
5231     }
5232 #line 5233 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5233     break;
5234 
5235   case 112:
5236 #line 987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5237     {
5238         if ((yyvsp[-1].interm.type).arraySizes) {
5239             parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5240             parseContext.profileRequires((yyvsp[-1].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5241             parseContext.arraySizeRequiredCheck((yyvsp[-1].interm.type).loc, *(yyvsp[-1].interm.type).arraySizes);
5242         }
5243         if ((yyvsp[-1].interm.type).basicType == EbtVoid) {
5244             parseContext.error((yyvsp[0].lex).loc, "illegal use of type 'void'", (yyvsp[0].lex).string->c_str(), "");
5245         }
5246         parseContext.reservedErrorCheck((yyvsp[0].lex).loc, *(yyvsp[0].lex).string);
5247 
5248         TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))};
5249         (yyval.interm).loc = (yyvsp[0].lex).loc;
5250         (yyval.interm).param = param;
5251     }
5252 #line 5253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5253     break;
5254 
5255   case 113:
5256 #line 1002 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5257     {
5258         if ((yyvsp[-2].interm.type).arraySizes) {
5259             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5260             parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5261             parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
5262         }
5263         TType* type = new TType((yyvsp[-2].interm.type));
5264         type->transferArraySizes((yyvsp[0].interm).arraySizes);
5265         type->copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
5266 
5267         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, type->getArraySizes());
5268         parseContext.arraySizeRequiredCheck((yyvsp[0].interm).loc, *(yyvsp[0].interm).arraySizes);
5269         parseContext.reservedErrorCheck((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string);
5270 
5271         TParameter param = { (yyvsp[-1].lex).string, type };
5272 
5273         (yyval.interm).loc = (yyvsp[-1].lex).loc;
5274         (yyval.interm).param = param;
5275     }
5276 #line 5277 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5277     break;
5278 
5279   case 114:
5280 #line 1027 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5281     {
5282         (yyval.interm) = (yyvsp[0].interm);
5283         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
5284             (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
5285         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5286 
5287         parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5288         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
5289         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
5290 
5291     }
5292 #line 5293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5293     break;
5294 
5295   case 115:
5296 #line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5297     {
5298         (yyval.interm) = (yyvsp[0].interm);
5299 
5300         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
5301         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
5302         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5303     }
5304 #line 5305 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5305     break;
5306 
5307   case 116:
5308 #line 1048 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5309     {
5310         (yyval.interm) = (yyvsp[0].interm);
5311         if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
5312             (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
5313         parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5314 
5315         parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5316         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
5317         parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
5318     }
5319 #line 5320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5320     break;
5321 
5322   case 117:
5323 #line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5324     {
5325         (yyval.interm) = (yyvsp[0].interm);
5326 
5327         parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
5328         parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
5329         parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5330     }
5331 #line 5332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5332     break;
5333 
5334   case 118:
5335 #line 1068 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5336     {
5337         TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
5338         (yyval.interm).param = param;
5339         if ((yyvsp[0].interm.type).arraySizes)
5340             parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
5341     }
5342 #line 5343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5343     break;
5344 
5345   case 119:
5346 #line 1077 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5347     {
5348         (yyval.interm) = (yyvsp[0].interm);
5349     }
5350 #line 5351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5351     break;
5352 
5353   case 120:
5354 #line 1080 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5355     {
5356         (yyval.interm) = (yyvsp[-2].interm);
5357         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
5358     }
5359 #line 5360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5360     break;
5361 
5362   case 121:
5363 #line 1084 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5364     {
5365         (yyval.interm) = (yyvsp[-3].interm);
5366         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
5367     }
5368 #line 5369 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5369     break;
5370 
5371   case 122:
5372 #line 1088 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5373     {
5374         (yyval.interm).type = (yyvsp[-5].interm).type;
5375         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
5376         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
5377     }
5378 #line 5379 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5379     break;
5380 
5381   case 123:
5382 #line 1093 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5383     {
5384         (yyval.interm).type = (yyvsp[-4].interm).type;
5385         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode));
5386         (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
5387     }
5388 #line 5389 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5389     break;
5390 
5391   case 124:
5392 #line 1101 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5393     {
5394         (yyval.interm).type = (yyvsp[0].interm.type);
5395         (yyval.interm).intermNode = 0;
5396 
5397         parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
5398 
5399     }
5400 #line 5401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5401     break;
5402 
5403   case 125:
5404 #line 1108 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5405     {
5406         (yyval.interm).type = (yyvsp[-1].interm.type);
5407         (yyval.interm).intermNode = 0;
5408         parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
5409     }
5410 #line 5411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5411     break;
5412 
5413   case 126:
5414 #line 1113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5415     {
5416         (yyval.interm).type = (yyvsp[-2].interm.type);
5417         (yyval.interm).intermNode = 0;
5418         parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
5419     }
5420 #line 5421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5421     break;
5422 
5423   case 127:
5424 #line 1118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5425     {
5426         (yyval.interm).type = (yyvsp[-4].interm.type);
5427         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
5428         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
5429     }
5430 #line 5431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5431     break;
5432 
5433   case 128:
5434 #line 1123 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5435     {
5436         (yyval.interm).type = (yyvsp[-3].interm.type);
5437         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
5438         (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
5439     }
5440 #line 5441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5441     break;
5442 
5443   case 129:
5444 #line 1132 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5445     {
5446         (yyval.interm.type) = (yyvsp[0].interm.type);
5447 
5448         parseContext.globalQualifierTypeCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyval.interm.type));
5449         if ((yyvsp[0].interm.type).arraySizes) {
5450             parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5451             parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5452         }
5453         parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
5454     }
5455 #line 5456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5456     break;
5457 
5458   case 130:
5459 #line 1142 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5460     {
5461         parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
5462         parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
5463 
5464         if ((yyvsp[0].interm.type).arraySizes) {
5465             parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5466             parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5467         }
5468 
5469         if ((yyvsp[0].interm.type).arraySizes && parseContext.arrayQualifierError((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).qualifier))
5470             (yyvsp[0].interm.type).arraySizes = nullptr;
5471 
5472         parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5473         (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers);
5474         parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true);
5475         parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier);
5476 
5477         (yyval.interm.type) = (yyvsp[0].interm.type);
5478 
5479         if (! (yyval.interm.type).qualifier.isInterpolation() &&
5480             ((parseContext.language == EShLangVertex   && (yyval.interm.type).qualifier.storage == EvqVaryingOut) ||
5481              (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
5482             (yyval.interm.type).qualifier.smooth = true;
5483     }
5484 #line 5485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5485     break;
5486 
5487   case 131:
5488 #line 1169 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5489     {
5490         parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
5491         parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
5492         (yyval.interm.type).init((yyvsp[0].lex).loc);
5493         (yyval.interm.type).qualifier.invariant = true;
5494     }
5495 #line 5496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5496     break;
5497 
5498   case 132:
5499 #line 1178 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5500     {
5501         parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
5502         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
5503         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "smooth");
5504         (yyval.interm.type).init((yyvsp[0].lex).loc);
5505         (yyval.interm.type).qualifier.smooth = true;
5506     }
5507 #line 5508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5508     break;
5509 
5510   case 133:
5511 #line 1185 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5512     {
5513         parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
5514         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
5515         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "flat");
5516         (yyval.interm.type).init((yyvsp[0].lex).loc);
5517         (yyval.interm.type).qualifier.flat = true;
5518     }
5519 #line 5520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5520     break;
5521 
5522   case 134:
5523 #line 1193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5524     {
5525         parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
5526         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
5527         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "noperspective");
5528         (yyval.interm.type).init((yyvsp[0].lex).loc);
5529         (yyval.interm.type).qualifier.nopersp = true;
5530     }
5531 #line 5532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5532     break;
5533 
5534   case 135:
5535 #line 1200 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5536     {
5537         parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
5538         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
5539         parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
5540         (yyval.interm.type).init((yyvsp[0].lex).loc);
5541         (yyval.interm.type).qualifier.explicitInterp = true;
5542     }
5543 #line 5544 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5544     break;
5545 
5546   case 136:
5547 #line 1207 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5548     {
5549         parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
5550         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5551         parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5552         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5553         (yyval.interm.type).init((yyvsp[0].lex).loc);
5554         (yyval.interm.type).qualifier.pervertexNV = true;
5555     }
5556 #line 5557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5557     break;
5558 
5559   case 137:
5560 #line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5561     {
5562         // No need for profile version or extension check. Shader stage already checks both.
5563         parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
5564         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangFragmentMask | EShLangMeshNVMask), "perprimitiveNV");
5565         // Fragment shader stage doesn't check for extension. So we explicitly add below extension check.
5566         if (parseContext.language == EShLangFragment)
5567             parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_NV_mesh_shader, "perprimitiveNV");
5568         (yyval.interm.type).init((yyvsp[0].lex).loc);
5569         (yyval.interm.type).qualifier.perPrimitiveNV = true;
5570     }
5571 #line 5572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5572     break;
5573 
5574   case 138:
5575 #line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5576     {
5577         // No need for profile version or extension check. Shader stage already checks both.
5578         parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
5579         parseContext.requireStage((yyvsp[0].lex).loc, EShLangMeshNV, "perviewNV");
5580         (yyval.interm.type).init((yyvsp[0].lex).loc);
5581         (yyval.interm.type).qualifier.perViewNV = true;
5582     }
5583 #line 5584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5584     break;
5585 
5586   case 139:
5587 #line 1232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5588     {
5589         // No need for profile version or extension check. Shader stage already checks both.
5590         parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
5591         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask), "taskNV");
5592         (yyval.interm.type).init((yyvsp[0].lex).loc);
5593         (yyval.interm.type).qualifier.perTaskNV = true;
5594     }
5595 #line 5596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5596     break;
5597 
5598   case 140:
5599 #line 1243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5600     {
5601         (yyval.interm.type) = (yyvsp[-1].interm.type);
5602     }
5603 #line 5604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5604     break;
5605 
5606   case 141:
5607 #line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5608     {
5609         (yyval.interm.type) = (yyvsp[0].interm.type);
5610     }
5611 #line 5612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5612     break;
5613 
5614   case 142:
5615 #line 1252 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5616     {
5617         (yyval.interm.type) = (yyvsp[-2].interm.type);
5618         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
5619         parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
5620     }
5621 #line 5622 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5622     break;
5623 
5624   case 143:
5625 #line 1259 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5626     {
5627         (yyval.interm.type).init((yyvsp[0].lex).loc);
5628         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
5629     }
5630 #line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5631     break;
5632 
5633   case 144:
5634 #line 1263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5635     {
5636         (yyval.interm.type).init((yyvsp[-2].lex).loc);
5637         parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
5638     }
5639 #line 5640 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5640     break;
5641 
5642   case 145:
5643 #line 1267 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5644     { // because "shared" is both an identifier and a keyword
5645         (yyval.interm.type).init((yyvsp[0].lex).loc);
5646         TString strShared("shared");
5647         parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
5648     }
5649 #line 5650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5650     break;
5651 
5652   case 146:
5653 #line 1276 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5654     {
5655         parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
5656         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
5657         (yyval.interm.type).init((yyvsp[0].lex).loc);
5658         (yyval.interm.type).qualifier.noContraction = true;
5659     }
5660 #line 5661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5661     break;
5662 
5663   case 147:
5664 #line 1286 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5665     {
5666         (yyval.interm.type) = (yyvsp[0].interm.type);
5667     }
5668 #line 5669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5669     break;
5670 
5671   case 148:
5672 #line 1289 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5673     {
5674         (yyval.interm.type) = (yyvsp[-1].interm.type);
5675         if ((yyval.interm.type).basicType == EbtVoid)
5676             (yyval.interm.type).basicType = (yyvsp[0].interm.type).basicType;
5677 
5678         (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
5679         parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
5680     }
5681 #line 5682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5682     break;
5683 
5684   case 149:
5685 #line 1300 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5686     {
5687         (yyval.interm.type) = (yyvsp[0].interm.type);
5688     }
5689 #line 5690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5690     break;
5691 
5692   case 150:
5693 #line 1303 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5694     {
5695         (yyval.interm.type) = (yyvsp[0].interm.type);
5696     }
5697 #line 5698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5698     break;
5699 
5700   case 151:
5701 #line 1306 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5702     {
5703         parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
5704         (yyval.interm.type) = (yyvsp[0].interm.type);
5705     }
5706 #line 5707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5707     break;
5708 
5709   case 152:
5710 #line 1310 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5711     {
5712         // allow inheritance of storage qualifier from block declaration
5713         (yyval.interm.type) = (yyvsp[0].interm.type);
5714     }
5715 #line 5716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5716     break;
5717 
5718   case 153:
5719 #line 1314 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5720     {
5721         // allow inheritance of storage qualifier from block declaration
5722         (yyval.interm.type) = (yyvsp[0].interm.type);
5723     }
5724 #line 5725 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5725     break;
5726 
5727   case 154:
5728 #line 1319 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5729     {
5730         // allow inheritance of storage qualifier from block declaration
5731         (yyval.interm.type) = (yyvsp[0].interm.type);
5732     }
5733 #line 5734 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5734     break;
5735 
5736   case 155:
5737 #line 1323 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5738     {
5739         (yyval.interm.type) = (yyvsp[0].interm.type);
5740     }
5741 #line 5742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5742     break;
5743 
5744   case 156:
5745 #line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5746     {
5747         (yyval.interm.type).init((yyvsp[0].lex).loc);
5748         (yyval.interm.type).qualifier.storage = EvqConst;  // will later turn into EvqConstReadOnly, if the initializer is not constant
5749     }
5750 #line 5751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5751     break;
5752 
5753   case 157:
5754 #line 1334 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5755     {
5756         parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
5757         (yyval.interm.type).init((yyvsp[0].lex).loc);
5758         (yyval.interm.type).qualifier.storage = EvqInOut;
5759     }
5760 #line 5761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5761     break;
5762 
5763   case 158:
5764 #line 1339 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5765     {
5766         parseContext.globalCheck((yyvsp[0].lex).loc, "in");
5767         (yyval.interm.type).init((yyvsp[0].lex).loc);
5768         // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
5769         (yyval.interm.type).qualifier.storage = EvqIn;
5770     }
5771 #line 5772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5772     break;
5773 
5774   case 159:
5775 #line 1345 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5776     {
5777         parseContext.globalCheck((yyvsp[0].lex).loc, "out");
5778         (yyval.interm.type).init((yyvsp[0].lex).loc);
5779         // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
5780         (yyval.interm.type).qualifier.storage = EvqOut;
5781     }
5782 #line 5783 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5783     break;
5784 
5785   case 160:
5786 #line 1351 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5787     {
5788         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
5789         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
5790         parseContext.globalCheck((yyvsp[0].lex).loc, "centroid");
5791         (yyval.interm.type).init((yyvsp[0].lex).loc);
5792         (yyval.interm.type).qualifier.centroid = true;
5793     }
5794 #line 5795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5795     break;
5796 
5797   case 161:
5798 #line 1358 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5799     {
5800         parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
5801         (yyval.interm.type).init((yyvsp[0].lex).loc);
5802         (yyval.interm.type).qualifier.storage = EvqUniform;
5803     }
5804 #line 5805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5805     break;
5806 
5807   case 162:
5808 #line 1363 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5809     {
5810         parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
5811         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
5812         parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared");
5813         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared");
5814         (yyval.interm.type).init((yyvsp[0].lex).loc);
5815         (yyval.interm.type).qualifier.storage = EvqShared;
5816     }
5817 #line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5818     break;
5819 
5820   case 163:
5821 #line 1371 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5822     {
5823         parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
5824         (yyval.interm.type).init((yyvsp[0].lex).loc);
5825         (yyval.interm.type).qualifier.storage = EvqBuffer;
5826     }
5827 #line 5828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5828     break;
5829 
5830   case 164:
5831 #line 1377 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5832     {
5833         parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
5834         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
5835         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "attribute");
5836         parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "attribute");
5837         parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "attribute");
5838 
5839         parseContext.globalCheck((yyvsp[0].lex).loc, "attribute");
5840 
5841         (yyval.interm.type).init((yyvsp[0].lex).loc);
5842         (yyval.interm.type).qualifier.storage = EvqVaryingIn;
5843     }
5844 #line 5845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5845     break;
5846 
5847   case 165:
5848 #line 1389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5849     {
5850         parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
5851         parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
5852         parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "varying");
5853         parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "varying");
5854 
5855         parseContext.globalCheck((yyvsp[0].lex).loc, "varying");
5856 
5857         (yyval.interm.type).init((yyvsp[0].lex).loc);
5858         if (parseContext.language == EShLangVertex)
5859             (yyval.interm.type).qualifier.storage = EvqVaryingOut;
5860         else
5861             (yyval.interm.type).qualifier.storage = EvqVaryingIn;
5862     }
5863 #line 5864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5864     break;
5865 
5866   case 166:
5867 #line 1403 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5868     {
5869         parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
5870         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
5871         (yyval.interm.type).init((yyvsp[0].lex).loc);
5872         (yyval.interm.type).qualifier.patch = true;
5873     }
5874 #line 5875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5875     break;
5876 
5877   case 167:
5878 #line 1409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5879     {
5880         parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
5881         (yyval.interm.type).init((yyvsp[0].lex).loc);
5882         (yyval.interm.type).qualifier.sample = true;
5883     }
5884 #line 5885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5885     break;
5886 
5887   case 168:
5888 #line 1414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5889     {
5890         parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
5891         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangClosestHitNVMask
5892             | EShLangAnyHitNVMask), "hitAttributeNV");
5893         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV");
5894         (yyval.interm.type).init((yyvsp[0].lex).loc);
5895         (yyval.interm.type).qualifier.storage = EvqHitAttrNV;
5896     }
5897 #line 5898 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5898     break;
5899 
5900   case 169:
5901 #line 1422 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5902     {
5903         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
5904         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask |
5905             EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNV");
5906         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV");
5907         (yyval.interm.type).init((yyvsp[0].lex).loc);
5908         (yyval.interm.type).qualifier.storage = EvqPayloadNV;
5909     }
5910 #line 5911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5911     break;
5912 
5913   case 170:
5914 #line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5915     {
5916         parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
5917         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitNVMask |
5918             EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNV");
5919         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV");
5920         (yyval.interm.type).init((yyvsp[0].lex).loc);
5921         (yyval.interm.type).qualifier.storage = EvqPayloadInNV;
5922     }
5923 #line 5924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5924     break;
5925 
5926   case 171:
5927 #line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5928     {
5929         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
5930         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask |
5931             EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask), "callableDataNV");
5932         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataNV");
5933         (yyval.interm.type).init((yyvsp[0].lex).loc);
5934         (yyval.interm.type).qualifier.storage = EvqCallableDataNV;
5935     }
5936 #line 5937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5937     break;
5938 
5939   case 172:
5940 #line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5941     {
5942         parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
5943         parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV");
5944         parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV");
5945         (yyval.interm.type).init((yyvsp[0].lex).loc);
5946         (yyval.interm.type).qualifier.storage = EvqCallableDataInNV;
5947     }
5948 #line 5949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5949     break;
5950 
5951   case 173:
5952 #line 1453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5953     {
5954         (yyval.interm.type).init((yyvsp[0].lex).loc);
5955         (yyval.interm.type).qualifier.coherent = true;
5956     }
5957 #line 5958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5958     break;
5959 
5960   case 174:
5961 #line 1457 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5962     {
5963         (yyval.interm.type).init((yyvsp[0].lex).loc);
5964         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
5965         (yyval.interm.type).qualifier.devicecoherent = true;
5966     }
5967 #line 5968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5968     break;
5969 
5970   case 175:
5971 #line 1462 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5972     {
5973         (yyval.interm.type).init((yyvsp[0].lex).loc);
5974         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
5975         (yyval.interm.type).qualifier.queuefamilycoherent = true;
5976     }
5977 #line 5978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5978     break;
5979 
5980   case 176:
5981 #line 1467 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5982     {
5983         (yyval.interm.type).init((yyvsp[0].lex).loc);
5984         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
5985         (yyval.interm.type).qualifier.workgroupcoherent = true;
5986     }
5987 #line 5988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5988     break;
5989 
5990   case 177:
5991 #line 1472 "MachineIndependent/glslang.y" /* yacc.c:1646  */
5992     {
5993         (yyval.interm.type).init((yyvsp[0].lex).loc);
5994         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
5995         (yyval.interm.type).qualifier.subgroupcoherent = true;
5996     }
5997 #line 5998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
5998     break;
5999 
6000   case 178:
6001 #line 1477 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6002     {
6003         (yyval.interm.type).init((yyvsp[0].lex).loc);
6004         parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
6005         (yyval.interm.type).qualifier.nonprivate = true;
6006     }
6007 #line 6008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6008     break;
6009 
6010   case 179:
6011 #line 1482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6012     {
6013         (yyval.interm.type).init((yyvsp[0].lex).loc);
6014         (yyval.interm.type).qualifier.volatil = true;
6015     }
6016 #line 6017 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6017     break;
6018 
6019   case 180:
6020 #line 1486 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6021     {
6022         (yyval.interm.type).init((yyvsp[0].lex).loc);
6023         (yyval.interm.type).qualifier.restrict = true;
6024     }
6025 #line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6026     break;
6027 
6028   case 181:
6029 #line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6030     {
6031         (yyval.interm.type).init((yyvsp[0].lex).loc);
6032         (yyval.interm.type).qualifier.readonly = true;
6033     }
6034 #line 6035 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6035     break;
6036 
6037   case 182:
6038 #line 1494 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6039     {
6040         (yyval.interm.type).init((yyvsp[0].lex).loc);
6041         (yyval.interm.type).qualifier.writeonly = true;
6042     }
6043 #line 6044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6044     break;
6045 
6046   case 183:
6047 #line 1498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6048     {
6049         parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
6050         parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
6051         parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
6052         (yyval.interm.type).init((yyvsp[0].lex).loc);
6053     }
6054 #line 6055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6055     break;
6056 
6057   case 184:
6058 #line 1504 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6059     {
6060         parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
6061         parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
6062         parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
6063         (yyval.interm.type).init((yyvsp[-3].lex).loc);
6064     }
6065 #line 6066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6066     break;
6067 
6068   case 185:
6069 #line 1515 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6070     {
6071         (yyval.interm.type).init((yyvsp[0].lex).loc);
6072         (yyval.interm.type).qualifier.nonUniform = true;
6073     }
6074 #line 6075 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6075     break;
6076 
6077   case 186:
6078 #line 1522 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6079     {
6080         // TODO
6081     }
6082 #line 6083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6083     break;
6084 
6085   case 187:
6086 #line 1525 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6087     {
6088         // TODO: 4.0 semantics: subroutines
6089         // 1) make sure each identifier is a type declared earlier with SUBROUTINE
6090         // 2) save all of the identifiers for future comparison with the declared function
6091     }
6092 #line 6093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6093     break;
6094 
6095   case 188:
6096 #line 1534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6097     {
6098         (yyval.interm.type) = (yyvsp[-1].interm.type);
6099         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
6100         (yyval.interm.type).typeParameters = (yyvsp[0].interm.typeParameters);
6101     }
6102 #line 6103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6103     break;
6104 
6105   case 189:
6106 #line 1539 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6107     {
6108         parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
6109         (yyval.interm.type) = (yyvsp[-2].interm.type);
6110         (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
6111         (yyval.interm.type).typeParameters = (yyvsp[-1].interm.typeParameters);
6112         (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
6113     }
6114 #line 6115 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6115     break;
6116 
6117   case 190:
6118 #line 1549 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6119     {
6120         (yyval.interm).loc = (yyvsp[-1].lex).loc;
6121         (yyval.interm).arraySizes = new TArraySizes;
6122         (yyval.interm).arraySizes->addInnerSize();
6123     }
6124 #line 6125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6125     break;
6126 
6127   case 191:
6128 #line 1554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6129     {
6130         (yyval.interm).loc = (yyvsp[-2].lex).loc;
6131         (yyval.interm).arraySizes = new TArraySizes;
6132 
6133         TArraySize size;
6134         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
6135         (yyval.interm).arraySizes->addInnerSize(size);
6136     }
6137 #line 6138 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6138     break;
6139 
6140   case 192:
6141 #line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6142     {
6143         (yyval.interm) = (yyvsp[-2].interm);
6144         (yyval.interm).arraySizes->addInnerSize();
6145     }
6146 #line 6147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6147     break;
6148 
6149   case 193:
6150 #line 1566 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6151     {
6152         (yyval.interm) = (yyvsp[-3].interm);
6153 
6154         TArraySize size;
6155         parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size");
6156         (yyval.interm).arraySizes->addInnerSize(size);
6157     }
6158 #line 6159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6159     break;
6160 
6161   case 194:
6162 #line 1576 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6163     {
6164         (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters);
6165     }
6166 #line 6167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6167     break;
6168 
6169   case 195:
6170 #line 1579 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6171     {
6172         (yyval.interm.typeParameters) = 0;
6173     }
6174 #line 6175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6175     break;
6176 
6177   case 196:
6178 #line 1585 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6179     {
6180         (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters);
6181     }
6182 #line 6183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6183     break;
6184 
6185   case 197:
6186 #line 1591 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6187     {
6188         (yyval.interm.typeParameters) = new TArraySizes;
6189 
6190         TArraySize size;
6191         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
6192         (yyval.interm.typeParameters)->addInnerSize(size);
6193     }
6194 #line 6195 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6195     break;
6196 
6197   case 198:
6198 #line 1598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6199     {
6200         (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters);
6201 
6202         TArraySize size;
6203         parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter");
6204         (yyval.interm.typeParameters)->addInnerSize(size);
6205     }
6206 #line 6207 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6207     break;
6208 
6209   case 199:
6210 #line 1608 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6211     {
6212         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6213         (yyval.interm.type).basicType = EbtVoid;
6214     }
6215 #line 6216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6216     break;
6217 
6218   case 200:
6219 #line 1612 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6220     {
6221         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6222         (yyval.interm.type).basicType = EbtFloat;
6223     }
6224 #line 6225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6225     break;
6226 
6227   case 201:
6228 #line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6229     {
6230         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6231         (yyval.interm.type).basicType = EbtInt;
6232     }
6233 #line 6234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6234     break;
6235 
6236   case 202:
6237 #line 1620 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6238     {
6239         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
6240         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6241         (yyval.interm.type).basicType = EbtUint;
6242     }
6243 #line 6244 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6244     break;
6245 
6246   case 203:
6247 #line 1625 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6248     {
6249         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6250         (yyval.interm.type).basicType = EbtBool;
6251     }
6252 #line 6253 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6253     break;
6254 
6255   case 204:
6256 #line 1629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6257     {
6258         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6259         (yyval.interm.type).basicType = EbtFloat;
6260         (yyval.interm.type).setVector(2);
6261     }
6262 #line 6263 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6263     break;
6264 
6265   case 205:
6266 #line 1634 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6267     {
6268         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6269         (yyval.interm.type).basicType = EbtFloat;
6270         (yyval.interm.type).setVector(3);
6271     }
6272 #line 6273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6273     break;
6274 
6275   case 206:
6276 #line 1639 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6277     {
6278         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6279         (yyval.interm.type).basicType = EbtFloat;
6280         (yyval.interm.type).setVector(4);
6281     }
6282 #line 6283 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6283     break;
6284 
6285   case 207:
6286 #line 1644 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6287     {
6288         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6289         (yyval.interm.type).basicType = EbtBool;
6290         (yyval.interm.type).setVector(2);
6291     }
6292 #line 6293 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6293     break;
6294 
6295   case 208:
6296 #line 1649 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6297     {
6298         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6299         (yyval.interm.type).basicType = EbtBool;
6300         (yyval.interm.type).setVector(3);
6301     }
6302 #line 6303 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6303     break;
6304 
6305   case 209:
6306 #line 1654 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6307     {
6308         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6309         (yyval.interm.type).basicType = EbtBool;
6310         (yyval.interm.type).setVector(4);
6311     }
6312 #line 6313 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6313     break;
6314 
6315   case 210:
6316 #line 1659 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6317     {
6318         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6319         (yyval.interm.type).basicType = EbtInt;
6320         (yyval.interm.type).setVector(2);
6321     }
6322 #line 6323 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6323     break;
6324 
6325   case 211:
6326 #line 1664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6327     {
6328         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6329         (yyval.interm.type).basicType = EbtInt;
6330         (yyval.interm.type).setVector(3);
6331     }
6332 #line 6333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6333     break;
6334 
6335   case 212:
6336 #line 1669 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6337     {
6338         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6339         (yyval.interm.type).basicType = EbtInt;
6340         (yyval.interm.type).setVector(4);
6341     }
6342 #line 6343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6343     break;
6344 
6345   case 213:
6346 #line 1674 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6347     {
6348         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6349         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6350         (yyval.interm.type).basicType = EbtUint;
6351         (yyval.interm.type).setVector(2);
6352     }
6353 #line 6354 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6354     break;
6355 
6356   case 214:
6357 #line 1680 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6358     {
6359         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6360         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6361         (yyval.interm.type).basicType = EbtUint;
6362         (yyval.interm.type).setVector(3);
6363     }
6364 #line 6365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6365     break;
6366 
6367   case 215:
6368 #line 1686 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6369     {
6370         parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6371         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6372         (yyval.interm.type).basicType = EbtUint;
6373         (yyval.interm.type).setVector(4);
6374     }
6375 #line 6376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6376     break;
6377 
6378   case 216:
6379 #line 1692 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6380     {
6381         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6382         (yyval.interm.type).basicType = EbtFloat;
6383         (yyval.interm.type).setMatrix(2, 2);
6384     }
6385 #line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6386     break;
6387 
6388   case 217:
6389 #line 1697 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6390     {
6391         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6392         (yyval.interm.type).basicType = EbtFloat;
6393         (yyval.interm.type).setMatrix(3, 3);
6394     }
6395 #line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6396     break;
6397 
6398   case 218:
6399 #line 1702 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6400     {
6401         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6402         (yyval.interm.type).basicType = EbtFloat;
6403         (yyval.interm.type).setMatrix(4, 4);
6404     }
6405 #line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6406     break;
6407 
6408   case 219:
6409 #line 1707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6410     {
6411         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6412         (yyval.interm.type).basicType = EbtFloat;
6413         (yyval.interm.type).setMatrix(2, 2);
6414     }
6415 #line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6416     break;
6417 
6418   case 220:
6419 #line 1712 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6420     {
6421         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6422         (yyval.interm.type).basicType = EbtFloat;
6423         (yyval.interm.type).setMatrix(2, 3);
6424     }
6425 #line 6426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6426     break;
6427 
6428   case 221:
6429 #line 1717 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6430     {
6431         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6432         (yyval.interm.type).basicType = EbtFloat;
6433         (yyval.interm.type).setMatrix(2, 4);
6434     }
6435 #line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6436     break;
6437 
6438   case 222:
6439 #line 1722 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6440     {
6441         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6442         (yyval.interm.type).basicType = EbtFloat;
6443         (yyval.interm.type).setMatrix(3, 2);
6444     }
6445 #line 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6446     break;
6447 
6448   case 223:
6449 #line 1727 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6450     {
6451         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6452         (yyval.interm.type).basicType = EbtFloat;
6453         (yyval.interm.type).setMatrix(3, 3);
6454     }
6455 #line 6456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6456     break;
6457 
6458   case 224:
6459 #line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6460     {
6461         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6462         (yyval.interm.type).basicType = EbtFloat;
6463         (yyval.interm.type).setMatrix(3, 4);
6464     }
6465 #line 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6466     break;
6467 
6468   case 225:
6469 #line 1737 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6470     {
6471         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6472         (yyval.interm.type).basicType = EbtFloat;
6473         (yyval.interm.type).setMatrix(4, 2);
6474     }
6475 #line 6476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6476     break;
6477 
6478   case 226:
6479 #line 1742 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6480     {
6481         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6482         (yyval.interm.type).basicType = EbtFloat;
6483         (yyval.interm.type).setMatrix(4, 3);
6484     }
6485 #line 6486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6486     break;
6487 
6488   case 227:
6489 #line 1747 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6490     {
6491         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6492         (yyval.interm.type).basicType = EbtFloat;
6493         (yyval.interm.type).setMatrix(4, 4);
6494     }
6495 #line 6496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6496     break;
6497 
6498   case 228:
6499 #line 1753 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6500     {
6501         parseContext.doubleCheck((yyvsp[0].lex).loc, "double");
6502         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6503         (yyval.interm.type).basicType = EbtDouble;
6504     }
6505 #line 6506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6506     break;
6507 
6508   case 229:
6509 #line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6510     {
6511         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
6512         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6513         (yyval.interm.type).basicType = EbtFloat16;
6514     }
6515 #line 6516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6516     break;
6517 
6518   case 230:
6519 #line 1763 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6520     {
6521         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
6522         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6523         (yyval.interm.type).basicType = EbtFloat;
6524     }
6525 #line 6526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6526     break;
6527 
6528   case 231:
6529 #line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6530     {
6531         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
6532         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6533         (yyval.interm.type).basicType = EbtDouble;
6534     }
6535 #line 6536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6536     break;
6537 
6538   case 232:
6539 #line 1773 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6540     {
6541         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6542         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6543         (yyval.interm.type).basicType = EbtInt8;
6544     }
6545 #line 6546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6546     break;
6547 
6548   case 233:
6549 #line 1778 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6550     {
6551         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6552         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6553         (yyval.interm.type).basicType = EbtUint8;
6554     }
6555 #line 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6556     break;
6557 
6558   case 234:
6559 #line 1783 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6560     {
6561         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6562         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6563         (yyval.interm.type).basicType = EbtInt16;
6564     }
6565 #line 6566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6566     break;
6567 
6568   case 235:
6569 #line 1788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6570     {
6571         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6572         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6573         (yyval.interm.type).basicType = EbtUint16;
6574     }
6575 #line 6576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6576     break;
6577 
6578   case 236:
6579 #line 1793 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6580     {
6581         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6582         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6583         (yyval.interm.type).basicType = EbtInt;
6584     }
6585 #line 6586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6586     break;
6587 
6588   case 237:
6589 #line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6590     {
6591         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6592         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6593         (yyval.interm.type).basicType = EbtUint;
6594     }
6595 #line 6596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6596     break;
6597 
6598   case 238:
6599 #line 1803 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6600     {
6601         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
6602         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6603         (yyval.interm.type).basicType = EbtInt64;
6604     }
6605 #line 6606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6606     break;
6607 
6608   case 239:
6609 #line 1808 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6610     {
6611         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6612         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6613         (yyval.interm.type).basicType = EbtUint64;
6614     }
6615 #line 6616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6616     break;
6617 
6618   case 240:
6619 #line 1813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6620     {
6621         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6622         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6623         (yyval.interm.type).basicType = EbtDouble;
6624         (yyval.interm.type).setVector(2);
6625     }
6626 #line 6627 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6627     break;
6628 
6629   case 241:
6630 #line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6631     {
6632         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6633         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6634         (yyval.interm.type).basicType = EbtDouble;
6635         (yyval.interm.type).setVector(3);
6636     }
6637 #line 6638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6638     break;
6639 
6640   case 242:
6641 #line 1825 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6642     {
6643         parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6644         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6645         (yyval.interm.type).basicType = EbtDouble;
6646         (yyval.interm.type).setVector(4);
6647     }
6648 #line 6649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6649     break;
6650 
6651   case 243:
6652 #line 1831 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6653     {
6654         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6655         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6656         (yyval.interm.type).basicType = EbtFloat16;
6657         (yyval.interm.type).setVector(2);
6658     }
6659 #line 6660 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6660     break;
6661 
6662   case 244:
6663 #line 1837 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6664     {
6665         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6666         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6667         (yyval.interm.type).basicType = EbtFloat16;
6668         (yyval.interm.type).setVector(3);
6669     }
6670 #line 6671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6671     break;
6672 
6673   case 245:
6674 #line 1843 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6675     {
6676         parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6677         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6678         (yyval.interm.type).basicType = EbtFloat16;
6679         (yyval.interm.type).setVector(4);
6680     }
6681 #line 6682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6682     break;
6683 
6684   case 246:
6685 #line 1849 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6686     {
6687         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6688         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6689         (yyval.interm.type).basicType = EbtFloat;
6690         (yyval.interm.type).setVector(2);
6691     }
6692 #line 6693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6693     break;
6694 
6695   case 247:
6696 #line 1855 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6697     {
6698         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6699         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6700         (yyval.interm.type).basicType = EbtFloat;
6701         (yyval.interm.type).setVector(3);
6702     }
6703 #line 6704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6704     break;
6705 
6706   case 248:
6707 #line 1861 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6708     {
6709         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6710         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6711         (yyval.interm.type).basicType = EbtFloat;
6712         (yyval.interm.type).setVector(4);
6713     }
6714 #line 6715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6715     break;
6716 
6717   case 249:
6718 #line 1867 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6719     {
6720         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6721         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6722         (yyval.interm.type).basicType = EbtDouble;
6723         (yyval.interm.type).setVector(2);
6724     }
6725 #line 6726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6726     break;
6727 
6728   case 250:
6729 #line 1873 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6730     {
6731         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6732         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6733         (yyval.interm.type).basicType = EbtDouble;
6734         (yyval.interm.type).setVector(3);
6735     }
6736 #line 6737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6737     break;
6738 
6739   case 251:
6740 #line 1879 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6741     {
6742         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6743         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6744         (yyval.interm.type).basicType = EbtDouble;
6745         (yyval.interm.type).setVector(4);
6746     }
6747 #line 6748 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6748     break;
6749 
6750   case 252:
6751 #line 1885 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6752     {
6753         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6754         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6755         (yyval.interm.type).basicType = EbtInt8;
6756         (yyval.interm.type).setVector(2);
6757     }
6758 #line 6759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6759     break;
6760 
6761   case 253:
6762 #line 1891 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6763     {
6764         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6765         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6766         (yyval.interm.type).basicType = EbtInt8;
6767         (yyval.interm.type).setVector(3);
6768     }
6769 #line 6770 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6770     break;
6771 
6772   case 254:
6773 #line 1897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6774     {
6775         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6776         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6777         (yyval.interm.type).basicType = EbtInt8;
6778         (yyval.interm.type).setVector(4);
6779     }
6780 #line 6781 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6781     break;
6782 
6783   case 255:
6784 #line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6785     {
6786         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6787         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6788         (yyval.interm.type).basicType = EbtInt16;
6789         (yyval.interm.type).setVector(2);
6790     }
6791 #line 6792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6792     break;
6793 
6794   case 256:
6795 #line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6796     {
6797         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6798         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6799         (yyval.interm.type).basicType = EbtInt16;
6800         (yyval.interm.type).setVector(3);
6801     }
6802 #line 6803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6803     break;
6804 
6805   case 257:
6806 #line 1915 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6807     {
6808         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6809         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6810         (yyval.interm.type).basicType = EbtInt16;
6811         (yyval.interm.type).setVector(4);
6812     }
6813 #line 6814 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6814     break;
6815 
6816   case 258:
6817 #line 1921 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6818     {
6819         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6820         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6821         (yyval.interm.type).basicType = EbtInt;
6822         (yyval.interm.type).setVector(2);
6823     }
6824 #line 6825 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6825     break;
6826 
6827   case 259:
6828 #line 1927 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6829     {
6830         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6831         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6832         (yyval.interm.type).basicType = EbtInt;
6833         (yyval.interm.type).setVector(3);
6834     }
6835 #line 6836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6836     break;
6837 
6838   case 260:
6839 #line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6840     {
6841         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6842         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6843         (yyval.interm.type).basicType = EbtInt;
6844         (yyval.interm.type).setVector(4);
6845     }
6846 #line 6847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6847     break;
6848 
6849   case 261:
6850 #line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6851     {
6852         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6853         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6854         (yyval.interm.type).basicType = EbtInt64;
6855         (yyval.interm.type).setVector(2);
6856     }
6857 #line 6858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6858     break;
6859 
6860   case 262:
6861 #line 1945 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6862     {
6863         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6864         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6865         (yyval.interm.type).basicType = EbtInt64;
6866         (yyval.interm.type).setVector(3);
6867     }
6868 #line 6869 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6869     break;
6870 
6871   case 263:
6872 #line 1951 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6873     {
6874         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6875         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6876         (yyval.interm.type).basicType = EbtInt64;
6877         (yyval.interm.type).setVector(4);
6878     }
6879 #line 6880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6880     break;
6881 
6882   case 264:
6883 #line 1957 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6884     {
6885         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6886         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6887         (yyval.interm.type).basicType = EbtUint8;
6888         (yyval.interm.type).setVector(2);
6889     }
6890 #line 6891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6891     break;
6892 
6893   case 265:
6894 #line 1963 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6895     {
6896         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6897         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6898         (yyval.interm.type).basicType = EbtUint8;
6899         (yyval.interm.type).setVector(3);
6900     }
6901 #line 6902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6902     break;
6903 
6904   case 266:
6905 #line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6906     {
6907         parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6908         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6909         (yyval.interm.type).basicType = EbtUint8;
6910         (yyval.interm.type).setVector(4);
6911     }
6912 #line 6913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6913     break;
6914 
6915   case 267:
6916 #line 1975 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6917     {
6918         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6919         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6920         (yyval.interm.type).basicType = EbtUint16;
6921         (yyval.interm.type).setVector(2);
6922     }
6923 #line 6924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6924     break;
6925 
6926   case 268:
6927 #line 1981 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6928     {
6929         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6930         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6931         (yyval.interm.type).basicType = EbtUint16;
6932         (yyval.interm.type).setVector(3);
6933     }
6934 #line 6935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6935     break;
6936 
6937   case 269:
6938 #line 1987 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6939     {
6940         parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6941         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6942         (yyval.interm.type).basicType = EbtUint16;
6943         (yyval.interm.type).setVector(4);
6944     }
6945 #line 6946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6946     break;
6947 
6948   case 270:
6949 #line 1993 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6950     {
6951         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6952         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6953         (yyval.interm.type).basicType = EbtUint;
6954         (yyval.interm.type).setVector(2);
6955     }
6956 #line 6957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6957     break;
6958 
6959   case 271:
6960 #line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6961     {
6962         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6963         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6964         (yyval.interm.type).basicType = EbtUint;
6965         (yyval.interm.type).setVector(3);
6966     }
6967 #line 6968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6968     break;
6969 
6970   case 272:
6971 #line 2005 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6972     {
6973         parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6974         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6975         (yyval.interm.type).basicType = EbtUint;
6976         (yyval.interm.type).setVector(4);
6977     }
6978 #line 6979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6979     break;
6980 
6981   case 273:
6982 #line 2011 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6983     {
6984         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6985         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6986         (yyval.interm.type).basicType = EbtUint64;
6987         (yyval.interm.type).setVector(2);
6988     }
6989 #line 6990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
6990     break;
6991 
6992   case 274:
6993 #line 2017 "MachineIndependent/glslang.y" /* yacc.c:1646  */
6994     {
6995         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6996         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6997         (yyval.interm.type).basicType = EbtUint64;
6998         (yyval.interm.type).setVector(3);
6999     }
7000 #line 7001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7001     break;
7002 
7003   case 275:
7004 #line 2023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7005     {
7006         parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
7007         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7008         (yyval.interm.type).basicType = EbtUint64;
7009         (yyval.interm.type).setVector(4);
7010     }
7011 #line 7012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7012     break;
7013 
7014   case 276:
7015 #line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7016     {
7017         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7018         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7019         (yyval.interm.type).basicType = EbtDouble;
7020         (yyval.interm.type).setMatrix(2, 2);
7021     }
7022 #line 7023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7023     break;
7024 
7025   case 277:
7026 #line 2035 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7027     {
7028         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7029         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7030         (yyval.interm.type).basicType = EbtDouble;
7031         (yyval.interm.type).setMatrix(3, 3);
7032     }
7033 #line 7034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7034     break;
7035 
7036   case 278:
7037 #line 2041 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7038     {
7039         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7040         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7041         (yyval.interm.type).basicType = EbtDouble;
7042         (yyval.interm.type).setMatrix(4, 4);
7043     }
7044 #line 7045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7045     break;
7046 
7047   case 279:
7048 #line 2047 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7049     {
7050         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7051         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7052         (yyval.interm.type).basicType = EbtDouble;
7053         (yyval.interm.type).setMatrix(2, 2);
7054     }
7055 #line 7056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7056     break;
7057 
7058   case 280:
7059 #line 2053 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7060     {
7061         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7062         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7063         (yyval.interm.type).basicType = EbtDouble;
7064         (yyval.interm.type).setMatrix(2, 3);
7065     }
7066 #line 7067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7067     break;
7068 
7069   case 281:
7070 #line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7071     {
7072         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7073         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7074         (yyval.interm.type).basicType = EbtDouble;
7075         (yyval.interm.type).setMatrix(2, 4);
7076     }
7077 #line 7078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7078     break;
7079 
7080   case 282:
7081 #line 2065 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7082     {
7083         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7084         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7085         (yyval.interm.type).basicType = EbtDouble;
7086         (yyval.interm.type).setMatrix(3, 2);
7087     }
7088 #line 7089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7089     break;
7090 
7091   case 283:
7092 #line 2071 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7093     {
7094         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7095         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7096         (yyval.interm.type).basicType = EbtDouble;
7097         (yyval.interm.type).setMatrix(3, 3);
7098     }
7099 #line 7100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7100     break;
7101 
7102   case 284:
7103 #line 2077 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7104     {
7105         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7106         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7107         (yyval.interm.type).basicType = EbtDouble;
7108         (yyval.interm.type).setMatrix(3, 4);
7109     }
7110 #line 7111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7111     break;
7112 
7113   case 285:
7114 #line 2083 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7115     {
7116         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7117         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7118         (yyval.interm.type).basicType = EbtDouble;
7119         (yyval.interm.type).setMatrix(4, 2);
7120     }
7121 #line 7122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7122     break;
7123 
7124   case 286:
7125 #line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7126     {
7127         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7128         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7129         (yyval.interm.type).basicType = EbtDouble;
7130         (yyval.interm.type).setMatrix(4, 3);
7131     }
7132 #line 7133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7133     break;
7134 
7135   case 287:
7136 #line 2095 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7137     {
7138         parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7139         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7140         (yyval.interm.type).basicType = EbtDouble;
7141         (yyval.interm.type).setMatrix(4, 4);
7142     }
7143 #line 7144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7144     break;
7145 
7146   case 288:
7147 #line 2101 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7148     {
7149         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7150         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7151         (yyval.interm.type).basicType = EbtFloat16;
7152         (yyval.interm.type).setMatrix(2, 2);
7153     }
7154 #line 7155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7155     break;
7156 
7157   case 289:
7158 #line 2107 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7159     {
7160         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7161         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7162         (yyval.interm.type).basicType = EbtFloat16;
7163         (yyval.interm.type).setMatrix(3, 3);
7164     }
7165 #line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7166     break;
7167 
7168   case 290:
7169 #line 2113 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7170     {
7171         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7172         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7173         (yyval.interm.type).basicType = EbtFloat16;
7174         (yyval.interm.type).setMatrix(4, 4);
7175     }
7176 #line 7177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7177     break;
7178 
7179   case 291:
7180 #line 2119 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7181     {
7182         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7183         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7184         (yyval.interm.type).basicType = EbtFloat16;
7185         (yyval.interm.type).setMatrix(2, 2);
7186     }
7187 #line 7188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7188     break;
7189 
7190   case 292:
7191 #line 2125 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7192     {
7193         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7194         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7195         (yyval.interm.type).basicType = EbtFloat16;
7196         (yyval.interm.type).setMatrix(2, 3);
7197     }
7198 #line 7199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7199     break;
7200 
7201   case 293:
7202 #line 2131 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7203     {
7204         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7205         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7206         (yyval.interm.type).basicType = EbtFloat16;
7207         (yyval.interm.type).setMatrix(2, 4);
7208     }
7209 #line 7210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7210     break;
7211 
7212   case 294:
7213 #line 2137 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7214     {
7215         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7216         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7217         (yyval.interm.type).basicType = EbtFloat16;
7218         (yyval.interm.type).setMatrix(3, 2);
7219     }
7220 #line 7221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7221     break;
7222 
7223   case 295:
7224 #line 2143 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7225     {
7226         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7227         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7228         (yyval.interm.type).basicType = EbtFloat16;
7229         (yyval.interm.type).setMatrix(3, 3);
7230     }
7231 #line 7232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7232     break;
7233 
7234   case 296:
7235 #line 2149 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7236     {
7237         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7238         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7239         (yyval.interm.type).basicType = EbtFloat16;
7240         (yyval.interm.type).setMatrix(3, 4);
7241     }
7242 #line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7243     break;
7244 
7245   case 297:
7246 #line 2155 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7247     {
7248         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7249         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7250         (yyval.interm.type).basicType = EbtFloat16;
7251         (yyval.interm.type).setMatrix(4, 2);
7252     }
7253 #line 7254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7254     break;
7255 
7256   case 298:
7257 #line 2161 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7258     {
7259         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7260         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7261         (yyval.interm.type).basicType = EbtFloat16;
7262         (yyval.interm.type).setMatrix(4, 3);
7263     }
7264 #line 7265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7265     break;
7266 
7267   case 299:
7268 #line 2167 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7269     {
7270         parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7271         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7272         (yyval.interm.type).basicType = EbtFloat16;
7273         (yyval.interm.type).setMatrix(4, 4);
7274     }
7275 #line 7276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7276     break;
7277 
7278   case 300:
7279 #line 2173 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7280     {
7281         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7282         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7283         (yyval.interm.type).basicType = EbtFloat;
7284         (yyval.interm.type).setMatrix(2, 2);
7285     }
7286 #line 7287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7287     break;
7288 
7289   case 301:
7290 #line 2179 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7291     {
7292         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7293         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7294         (yyval.interm.type).basicType = EbtFloat;
7295         (yyval.interm.type).setMatrix(3, 3);
7296     }
7297 #line 7298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7298     break;
7299 
7300   case 302:
7301 #line 2185 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7302     {
7303         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7304         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7305         (yyval.interm.type).basicType = EbtFloat;
7306         (yyval.interm.type).setMatrix(4, 4);
7307     }
7308 #line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7309     break;
7310 
7311   case 303:
7312 #line 2191 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7313     {
7314         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7315         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7316         (yyval.interm.type).basicType = EbtFloat;
7317         (yyval.interm.type).setMatrix(2, 2);
7318     }
7319 #line 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7320     break;
7321 
7322   case 304:
7323 #line 2197 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7324     {
7325         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7326         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7327         (yyval.interm.type).basicType = EbtFloat;
7328         (yyval.interm.type).setMatrix(2, 3);
7329     }
7330 #line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7331     break;
7332 
7333   case 305:
7334 #line 2203 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7335     {
7336         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7337         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7338         (yyval.interm.type).basicType = EbtFloat;
7339         (yyval.interm.type).setMatrix(2, 4);
7340     }
7341 #line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7342     break;
7343 
7344   case 306:
7345 #line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7346     {
7347         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7348         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7349         (yyval.interm.type).basicType = EbtFloat;
7350         (yyval.interm.type).setMatrix(3, 2);
7351     }
7352 #line 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7353     break;
7354 
7355   case 307:
7356 #line 2215 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7357     {
7358         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7359         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7360         (yyval.interm.type).basicType = EbtFloat;
7361         (yyval.interm.type).setMatrix(3, 3);
7362     }
7363 #line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7364     break;
7365 
7366   case 308:
7367 #line 2221 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7368     {
7369         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7370         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7371         (yyval.interm.type).basicType = EbtFloat;
7372         (yyval.interm.type).setMatrix(3, 4);
7373     }
7374 #line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7375     break;
7376 
7377   case 309:
7378 #line 2227 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7379     {
7380         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7381         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7382         (yyval.interm.type).basicType = EbtFloat;
7383         (yyval.interm.type).setMatrix(4, 2);
7384     }
7385 #line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7386     break;
7387 
7388   case 310:
7389 #line 2233 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7390     {
7391         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7392         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7393         (yyval.interm.type).basicType = EbtFloat;
7394         (yyval.interm.type).setMatrix(4, 3);
7395     }
7396 #line 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7397     break;
7398 
7399   case 311:
7400 #line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7401     {
7402         parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7403         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7404         (yyval.interm.type).basicType = EbtFloat;
7405         (yyval.interm.type).setMatrix(4, 4);
7406     }
7407 #line 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7408     break;
7409 
7410   case 312:
7411 #line 2245 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7412     {
7413         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7414         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7415         (yyval.interm.type).basicType = EbtDouble;
7416         (yyval.interm.type).setMatrix(2, 2);
7417     }
7418 #line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7419     break;
7420 
7421   case 313:
7422 #line 2251 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7423     {
7424         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7425         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7426         (yyval.interm.type).basicType = EbtDouble;
7427         (yyval.interm.type).setMatrix(3, 3);
7428     }
7429 #line 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7430     break;
7431 
7432   case 314:
7433 #line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7434     {
7435         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7436         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7437         (yyval.interm.type).basicType = EbtDouble;
7438         (yyval.interm.type).setMatrix(4, 4);
7439     }
7440 #line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7441     break;
7442 
7443   case 315:
7444 #line 2263 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7445     {
7446         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7447         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7448         (yyval.interm.type).basicType = EbtDouble;
7449         (yyval.interm.type).setMatrix(2, 2);
7450     }
7451 #line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7452     break;
7453 
7454   case 316:
7455 #line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7456     {
7457         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7458         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7459         (yyval.interm.type).basicType = EbtDouble;
7460         (yyval.interm.type).setMatrix(2, 3);
7461     }
7462 #line 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7463     break;
7464 
7465   case 317:
7466 #line 2275 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7467     {
7468         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7469         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7470         (yyval.interm.type).basicType = EbtDouble;
7471         (yyval.interm.type).setMatrix(2, 4);
7472     }
7473 #line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7474     break;
7475 
7476   case 318:
7477 #line 2281 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7478     {
7479         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7480         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7481         (yyval.interm.type).basicType = EbtDouble;
7482         (yyval.interm.type).setMatrix(3, 2);
7483     }
7484 #line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7485     break;
7486 
7487   case 319:
7488 #line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7489     {
7490         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7491         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7492         (yyval.interm.type).basicType = EbtDouble;
7493         (yyval.interm.type).setMatrix(3, 3);
7494     }
7495 #line 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7496     break;
7497 
7498   case 320:
7499 #line 2293 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7500     {
7501         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7502         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7503         (yyval.interm.type).basicType = EbtDouble;
7504         (yyval.interm.type).setMatrix(3, 4);
7505     }
7506 #line 7507 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7507     break;
7508 
7509   case 321:
7510 #line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7511     {
7512         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7513         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7514         (yyval.interm.type).basicType = EbtDouble;
7515         (yyval.interm.type).setMatrix(4, 2);
7516     }
7517 #line 7518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7518     break;
7519 
7520   case 322:
7521 #line 2305 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7522     {
7523         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7524         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7525         (yyval.interm.type).basicType = EbtDouble;
7526         (yyval.interm.type).setMatrix(4, 3);
7527     }
7528 #line 7529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7529     break;
7530 
7531   case 323:
7532 #line 2311 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7533     {
7534         parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7535         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7536         (yyval.interm.type).basicType = EbtDouble;
7537         (yyval.interm.type).setMatrix(4, 4);
7538     }
7539 #line 7540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7540     break;
7541 
7542   case 324:
7543 #line 2317 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7544     {
7545        (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7546        (yyval.interm.type).basicType = EbtAccStructNV;
7547     }
7548 #line 7549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7549     break;
7550 
7551   case 325:
7552 #line 2321 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7553     {
7554         parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
7555         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7556         (yyval.interm.type).basicType = EbtAtomicUint;
7557     }
7558 #line 7559 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7559     break;
7560 
7561   case 326:
7562 #line 2326 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7563     {
7564         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7565         (yyval.interm.type).basicType = EbtSampler;
7566         (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
7567     }
7568 #line 7569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7569     break;
7570 
7571   case 327:
7572 #line 2332 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7573     {
7574         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7575         (yyval.interm.type).basicType = EbtSampler;
7576         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
7577     }
7578 #line 7579 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7579     break;
7580 
7581   case 328:
7582 #line 2337 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7583     {
7584         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7585         (yyval.interm.type).basicType = EbtSampler;
7586         (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
7587     }
7588 #line 7589 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7589     break;
7590 
7591   case 329:
7592 #line 2342 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7593     {
7594         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7595         (yyval.interm.type).basicType = EbtSampler;
7596         (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
7597     }
7598 #line 7599 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7599     break;
7600 
7601   case 330:
7602 #line 2347 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7603     {
7604         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7605         (yyval.interm.type).basicType = EbtSampler;
7606         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
7607     }
7608 #line 7609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7609     break;
7610 
7611   case 331:
7612 #line 2352 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7613     {
7614         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7615         (yyval.interm.type).basicType = EbtSampler;
7616         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
7617     }
7618 #line 7619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7619     break;
7620 
7621   case 332:
7622 #line 2357 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7623     {
7624         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7625         (yyval.interm.type).basicType = EbtSampler;
7626         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
7627     }
7628 #line 7629 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7629     break;
7630 
7631   case 333:
7632 #line 2362 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7633     {
7634         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7635         (yyval.interm.type).basicType = EbtSampler;
7636         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
7637     }
7638 #line 7639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7639     break;
7640 
7641   case 334:
7642 #line 2368 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7643     {
7644         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7645         (yyval.interm.type).basicType = EbtSampler;
7646         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
7647     }
7648 #line 7649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7649     break;
7650 
7651   case 335:
7652 #line 2373 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7653     {
7654         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7655         (yyval.interm.type).basicType = EbtSampler;
7656         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
7657     }
7658 #line 7659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7659     break;
7660 
7661   case 336:
7662 #line 2378 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7663     {
7664         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7665         (yyval.interm.type).basicType = EbtSampler;
7666         (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
7667     }
7668 #line 7669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7669     break;
7670 
7671   case 337:
7672 #line 2383 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7673     {
7674         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7675         (yyval.interm.type).basicType = EbtSampler;
7676         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
7677     }
7678 #line 7679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7679     break;
7680 
7681   case 338:
7682 #line 2388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7683     {
7684         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7685         (yyval.interm.type).basicType = EbtSampler;
7686         (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
7687     }
7688 #line 7689 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7689     break;
7690 
7691   case 339:
7692 #line 2393 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7693     {
7694         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7695         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7696         (yyval.interm.type).basicType = EbtSampler;
7697         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
7698     }
7699 #line 7700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7700     break;
7701 
7702   case 340:
7703 #line 2399 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7704     {
7705         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7706         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7707         (yyval.interm.type).basicType = EbtSampler;
7708         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
7709     }
7710 #line 7711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7711     break;
7712 
7713   case 341:
7714 #line 2405 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7715     {
7716         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7717         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7718         (yyval.interm.type).basicType = EbtSampler;
7719         (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
7720     }
7721 #line 7722 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7722     break;
7723 
7724   case 342:
7725 #line 2411 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7726     {
7727         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7728         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7729         (yyval.interm.type).basicType = EbtSampler;
7730         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
7731     }
7732 #line 7733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7733     break;
7734 
7735   case 343:
7736 #line 2417 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7737     {
7738         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7739         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7740         (yyval.interm.type).basicType = EbtSampler;
7741         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true);
7742     }
7743 #line 7744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7744     break;
7745 
7746   case 344:
7747 #line 2423 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7748     {
7749         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7750         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7751         (yyval.interm.type).basicType = EbtSampler;
7752         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
7753     }
7754 #line 7755 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7755     break;
7756 
7757   case 345:
7758 #line 2429 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7759     {
7760         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7761         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7762         (yyval.interm.type).basicType = EbtSampler;
7763         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
7764     }
7765 #line 7766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7766     break;
7767 
7768   case 346:
7769 #line 2435 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7770     {
7771         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7772         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7773         (yyval.interm.type).basicType = EbtSampler;
7774         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
7775     }
7776 #line 7777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7777     break;
7778 
7779   case 347:
7780 #line 2441 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7781     {
7782         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7783         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7784         (yyval.interm.type).basicType = EbtSampler;
7785         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
7786     }
7787 #line 7788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7788     break;
7789 
7790   case 348:
7791 #line 2447 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7792     {
7793         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7794         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7795         (yyval.interm.type).basicType = EbtSampler;
7796         (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
7797     }
7798 #line 7799 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7799     break;
7800 
7801   case 349:
7802 #line 2453 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7803     {
7804         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7805         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7806         (yyval.interm.type).basicType = EbtSampler;
7807         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
7808     }
7809 #line 7810 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7810     break;
7811 
7812   case 350:
7813 #line 2459 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7814     {
7815         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7816         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7817         (yyval.interm.type).basicType = EbtSampler;
7818         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
7819     }
7820 #line 7821 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7821     break;
7822 
7823   case 351:
7824 #line 2465 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7825     {
7826         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7827         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7828         (yyval.interm.type).basicType = EbtSampler;
7829         (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
7830     }
7831 #line 7832 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7832     break;
7833 
7834   case 352:
7835 #line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7836     {
7837         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7838         (yyval.interm.type).basicType = EbtSampler;
7839         (yyval.interm.type).sampler.set(EbtInt, Esd1D);
7840     }
7841 #line 7842 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7842     break;
7843 
7844   case 353:
7845 #line 2477 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7846     {
7847         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7848         (yyval.interm.type).basicType = EbtSampler;
7849         (yyval.interm.type).sampler.set(EbtInt, Esd2D);
7850     }
7851 #line 7852 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7852     break;
7853 
7854   case 354:
7855 #line 2482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7856     {
7857         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7858         (yyval.interm.type).basicType = EbtSampler;
7859         (yyval.interm.type).sampler.set(EbtInt, Esd3D);
7860     }
7861 #line 7862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7862     break;
7863 
7864   case 355:
7865 #line 2487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7866     {
7867         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7868         (yyval.interm.type).basicType = EbtSampler;
7869         (yyval.interm.type).sampler.set(EbtInt, EsdCube);
7870     }
7871 #line 7872 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7872     break;
7873 
7874   case 356:
7875 #line 2492 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7876     {
7877         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7878         (yyval.interm.type).basicType = EbtSampler;
7879         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
7880     }
7881 #line 7882 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7882     break;
7883 
7884   case 357:
7885 #line 2497 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7886     {
7887         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7888         (yyval.interm.type).basicType = EbtSampler;
7889         (yyval.interm.type).sampler.set(EbtUint, Esd2D);
7890     }
7891 #line 7892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7892     break;
7893 
7894   case 358:
7895 #line 2502 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7896     {
7897         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7898         (yyval.interm.type).basicType = EbtSampler;
7899         (yyval.interm.type).sampler.set(EbtUint, Esd3D);
7900     }
7901 #line 7902 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7902     break;
7903 
7904   case 359:
7905 #line 2507 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7906     {
7907         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7908         (yyval.interm.type).basicType = EbtSampler;
7909         (yyval.interm.type).sampler.set(EbtUint, EsdCube);
7910     }
7911 #line 7912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7912     break;
7913 
7914   case 360:
7915 #line 2513 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7916     {
7917         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7918         (yyval.interm.type).basicType = EbtSampler;
7919         (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
7920     }
7921 #line 7922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7922     break;
7923 
7924   case 361:
7925 #line 2518 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7926     {
7927         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7928         (yyval.interm.type).basicType = EbtSampler;
7929         (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
7930     }
7931 #line 7932 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7932     break;
7933 
7934   case 362:
7935 #line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7936     {
7937         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7938         (yyval.interm.type).basicType = EbtSampler;
7939         (yyval.interm.type).sampler.set(EbtUint, Esd1D);
7940     }
7941 #line 7942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7942     break;
7943 
7944   case 363:
7945 #line 2528 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7946     {
7947         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7948         (yyval.interm.type).basicType = EbtSampler;
7949         (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
7950     }
7951 #line 7952 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7952     break;
7953 
7954   case 364:
7955 #line 2533 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7956     {
7957         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7958         (yyval.interm.type).basicType = EbtSampler;
7959         (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
7960     }
7961 #line 7962 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7962     break;
7963 
7964   case 365:
7965 #line 2538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7966     {
7967         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7968         (yyval.interm.type).basicType = EbtSampler;
7969         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
7970     }
7971 #line 7972 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7972     break;
7973 
7974   case 366:
7975 #line 2543 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7976     {
7977         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7978         (yyval.interm.type).basicType = EbtSampler;
7979         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true);
7980     }
7981 #line 7982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7982     break;
7983 
7984   case 367:
7985 #line 2548 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7986     {
7987         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7988         (yyval.interm.type).basicType = EbtSampler;
7989         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
7990     }
7991 #line 7992 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
7992     break;
7993 
7994   case 368:
7995 #line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646  */
7996     {
7997         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7998         (yyval.interm.type).basicType = EbtSampler;
7999         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
8000     }
8001 #line 8002 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8002     break;
8003 
8004   case 369:
8005 #line 2559 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8006     {
8007         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8008         (yyval.interm.type).basicType = EbtSampler;
8009         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
8010     }
8011 #line 8012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8012     break;
8013 
8014   case 370:
8015 #line 2564 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8016     {
8017         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8018         (yyval.interm.type).basicType = EbtSampler;
8019         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
8020     }
8021 #line 8022 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8022     break;
8023 
8024   case 371:
8025 #line 2569 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8026     {
8027         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8028         (yyval.interm.type).basicType = EbtSampler;
8029         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
8030     }
8031 #line 8032 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8032     break;
8033 
8034   case 372:
8035 #line 2574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8036     {
8037         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8038         (yyval.interm.type).basicType = EbtSampler;
8039         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
8040     }
8041 #line 8042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8042     break;
8043 
8044   case 373:
8045 #line 2579 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8046     {
8047         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8048         (yyval.interm.type).basicType = EbtSampler;
8049         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
8050     }
8051 #line 8052 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8052     break;
8053 
8054   case 374:
8055 #line 2584 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8056     {
8057         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8058         (yyval.interm.type).basicType = EbtSampler;
8059         (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
8060     }
8061 #line 8062 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8062     break;
8063 
8064   case 375:
8065 #line 2589 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8066     {
8067         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8068         (yyval.interm.type).basicType = EbtSampler;
8069         (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
8070     }
8071 #line 8072 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8072     break;
8073 
8074   case 376:
8075 #line 2594 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8076     {
8077         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8078         (yyval.interm.type).basicType = EbtSampler;
8079         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
8080     }
8081 #line 8082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8082     break;
8083 
8084   case 377:
8085 #line 2599 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8086     {
8087         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8088         (yyval.interm.type).basicType = EbtSampler;
8089         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
8090     }
8091 #line 8092 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8092     break;
8093 
8094   case 378:
8095 #line 2604 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8096     {
8097         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8098         (yyval.interm.type).basicType = EbtSampler;
8099         (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
8100     }
8101 #line 8102 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8102     break;
8103 
8104   case 379:
8105 #line 2609 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8106     {
8107         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8108         (yyval.interm.type).basicType = EbtSampler;
8109         (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
8110     }
8111 #line 8112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8112     break;
8113 
8114   case 380:
8115 #line 2614 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8116     {
8117         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8118         (yyval.interm.type).basicType = EbtSampler;
8119         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
8120     }
8121 #line 8122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8122     break;
8123 
8124   case 381:
8125 #line 2619 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8126     {
8127         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8128         (yyval.interm.type).basicType = EbtSampler;
8129         (yyval.interm.type).sampler.setPureSampler(false);
8130     }
8131 #line 8132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8132     break;
8133 
8134   case 382:
8135 #line 2624 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8136     {
8137         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8138         (yyval.interm.type).basicType = EbtSampler;
8139         (yyval.interm.type).sampler.setPureSampler(true);
8140     }
8141 #line 8142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8142     break;
8143 
8144   case 383:
8145 #line 2630 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8146     {
8147         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8148         (yyval.interm.type).basicType = EbtSampler;
8149         (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
8150     }
8151 #line 8152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8152     break;
8153 
8154   case 384:
8155 #line 2635 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8156     {
8157         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8158         (yyval.interm.type).basicType = EbtSampler;
8159         (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
8160     }
8161 #line 8162 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8162     break;
8163 
8164   case 385:
8165 #line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8166     {
8167         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8168         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8169         (yyval.interm.type).basicType = EbtSampler;
8170         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
8171     }
8172 #line 8173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8173     break;
8174 
8175   case 386:
8176 #line 2646 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8177     {
8178         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8179         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8180         (yyval.interm.type).basicType = EbtSampler;
8181         (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
8182     }
8183 #line 8184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8184     break;
8185 
8186   case 387:
8187 #line 2652 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8188     {
8189         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8190         (yyval.interm.type).basicType = EbtSampler;
8191         (yyval.interm.type).sampler.set(EbtInt, EsdRect);
8192     }
8193 #line 8194 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8194     break;
8195 
8196   case 388:
8197 #line 2657 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8198     {
8199         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8200         (yyval.interm.type).basicType = EbtSampler;
8201         (yyval.interm.type).sampler.set(EbtUint, EsdRect);
8202     }
8203 #line 8204 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8204     break;
8205 
8206   case 389:
8207 #line 2662 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8208     {
8209         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8210         (yyval.interm.type).basicType = EbtSampler;
8211         (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
8212     }
8213 #line 8214 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8214     break;
8215 
8216   case 390:
8217 #line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8218     {
8219         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8220         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8221         (yyval.interm.type).basicType = EbtSampler;
8222         (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
8223     }
8224 #line 8225 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8225     break;
8226 
8227   case 391:
8228 #line 2673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8229     {
8230         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8231         (yyval.interm.type).basicType = EbtSampler;
8232         (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
8233     }
8234 #line 8235 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8235     break;
8236 
8237   case 392:
8238 #line 2678 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8239     {
8240         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8241         (yyval.interm.type).basicType = EbtSampler;
8242         (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
8243     }
8244 #line 8245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8245     break;
8246 
8247   case 393:
8248 #line 2683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8249     {
8250         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8251         (yyval.interm.type).basicType = EbtSampler;
8252         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
8253     }
8254 #line 8255 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8255     break;
8256 
8257   case 394:
8258 #line 2688 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8259     {
8260         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8261         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8262         (yyval.interm.type).basicType = EbtSampler;
8263         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
8264     }
8265 #line 8266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8266     break;
8267 
8268   case 395:
8269 #line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8270     {
8271         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8272         (yyval.interm.type).basicType = EbtSampler;
8273         (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
8274     }
8275 #line 8276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8276     break;
8277 
8278   case 396:
8279 #line 2699 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8280     {
8281         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8282         (yyval.interm.type).basicType = EbtSampler;
8283         (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
8284     }
8285 #line 8286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8286     break;
8287 
8288   case 397:
8289 #line 2704 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8290     {
8291         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8292         (yyval.interm.type).basicType = EbtSampler;
8293         (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
8294     }
8295 #line 8296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8296     break;
8297 
8298   case 398:
8299 #line 2709 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8300     {
8301         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8302         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8303         (yyval.interm.type).basicType = EbtSampler;
8304         (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
8305     }
8306 #line 8307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8307     break;
8308 
8309   case 399:
8310 #line 2715 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8311     {
8312         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8313         (yyval.interm.type).basicType = EbtSampler;
8314         (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
8315     }
8316 #line 8317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8317     break;
8318 
8319   case 400:
8320 #line 2720 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8321     {
8322         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8323         (yyval.interm.type).basicType = EbtSampler;
8324         (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
8325     }
8326 #line 8327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8327     break;
8328 
8329   case 401:
8330 #line 2725 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8331     {
8332         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8333         (yyval.interm.type).basicType = EbtSampler;
8334         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
8335     }
8336 #line 8337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8337     break;
8338 
8339   case 402:
8340 #line 2730 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8341     {
8342         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8343         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8344         (yyval.interm.type).basicType = EbtSampler;
8345         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
8346     }
8347 #line 8348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8348     break;
8349 
8350   case 403:
8351 #line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8352     {
8353         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8354         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8355         (yyval.interm.type).basicType = EbtSampler;
8356         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
8357     }
8358 #line 8359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8359     break;
8360 
8361   case 404:
8362 #line 2742 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8363     {
8364         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8365         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8366         (yyval.interm.type).basicType = EbtSampler;
8367         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
8368     }
8369 #line 8370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8370     break;
8371 
8372   case 405:
8373 #line 2748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8374     {
8375         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8376         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8377         (yyval.interm.type).basicType = EbtSampler;
8378         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
8379     }
8380 #line 8381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8381     break;
8382 
8383   case 406:
8384 #line 2754 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8385     {
8386         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8387         (yyval.interm.type).basicType = EbtSampler;
8388         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
8389     }
8390 #line 8391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8391     break;
8392 
8393   case 407:
8394 #line 2759 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8395     {
8396         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8397         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8398         (yyval.interm.type).basicType = EbtSampler;
8399         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
8400     }
8401 #line 8402 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8402     break;
8403 
8404   case 408:
8405 #line 2765 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8406     {
8407         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8408         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8409         (yyval.interm.type).basicType = EbtSampler;
8410         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
8411     }
8412 #line 8413 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8413     break;
8414 
8415   case 409:
8416 #line 2771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8417     {
8418         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8419         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8420         (yyval.interm.type).basicType = EbtSampler;
8421         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
8422     }
8423 #line 8424 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8424     break;
8425 
8426   case 410:
8427 #line 2777 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8428     {
8429         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8430         (yyval.interm.type).basicType = EbtSampler;
8431         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
8432     }
8433 #line 8434 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8434     break;
8435 
8436   case 411:
8437 #line 2782 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8438     {
8439         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8440         (yyval.interm.type).basicType = EbtSampler;
8441         (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
8442     }
8443 #line 8444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8444     break;
8445 
8446   case 412:
8447 #line 2787 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8448     {
8449         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8450         (yyval.interm.type).basicType = EbtSampler;
8451         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
8452     }
8453 #line 8454 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8454     break;
8455 
8456   case 413:
8457 #line 2792 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8458     {
8459         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8460         (yyval.interm.type).basicType = EbtSampler;
8461         (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
8462     }
8463 #line 8464 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8464     break;
8465 
8466   case 414:
8467 #line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8468     {
8469         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8470         (yyval.interm.type).basicType = EbtSampler;
8471         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
8472     }
8473 #line 8474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8474     break;
8475 
8476   case 415:
8477 #line 2802 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8478     {
8479         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8480         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8481         (yyval.interm.type).basicType = EbtSampler;
8482         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
8483     }
8484 #line 8485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8485     break;
8486 
8487   case 416:
8488 #line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8489     {
8490         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8491         (yyval.interm.type).basicType = EbtSampler;
8492         (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
8493     }
8494 #line 8495 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8495     break;
8496 
8497   case 417:
8498 #line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8499     {
8500         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8501         (yyval.interm.type).basicType = EbtSampler;
8502         (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
8503     }
8504 #line 8505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8505     break;
8506 
8507   case 418:
8508 #line 2818 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8509     {
8510         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8511         (yyval.interm.type).basicType = EbtSampler;
8512         (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
8513     }
8514 #line 8515 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8515     break;
8516 
8517   case 419:
8518 #line 2823 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8519     {
8520         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8521         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8522         (yyval.interm.type).basicType = EbtSampler;
8523         (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer);
8524     }
8525 #line 8526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8526     break;
8527 
8528   case 420:
8529 #line 2829 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8530     {
8531         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8532         (yyval.interm.type).basicType = EbtSampler;
8533         (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
8534     }
8535 #line 8536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8536     break;
8537 
8538   case 421:
8539 #line 2834 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8540     {
8541         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8542         (yyval.interm.type).basicType = EbtSampler;
8543         (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
8544     }
8545 #line 8546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8546     break;
8547 
8548   case 422:
8549 #line 2839 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8550     {
8551         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8552         (yyval.interm.type).basicType = EbtSampler;
8553         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
8554     }
8555 #line 8556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8556     break;
8557 
8558   case 423:
8559 #line 2844 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8560     {
8561         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8562         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8563         (yyval.interm.type).basicType = EbtSampler;
8564         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
8565     }
8566 #line 8567 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8567     break;
8568 
8569   case 424:
8570 #line 2850 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8571     {
8572         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8573         (yyval.interm.type).basicType = EbtSampler;
8574         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
8575     }
8576 #line 8577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8577     break;
8578 
8579   case 425:
8580 #line 2855 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8581     {
8582         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8583         (yyval.interm.type).basicType = EbtSampler;
8584         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
8585     }
8586 #line 8587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8587     break;
8588 
8589   case 426:
8590 #line 2860 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8591     {
8592         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8593         (yyval.interm.type).basicType = EbtSampler;
8594         (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
8595     }
8596 #line 8597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8597     break;
8598 
8599   case 427:
8600 #line 2865 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8601     {
8602         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8603         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8604         (yyval.interm.type).basicType = EbtSampler;
8605         (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
8606     }
8607 #line 8608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8608     break;
8609 
8610   case 428:
8611 #line 2871 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8612     {
8613         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8614         (yyval.interm.type).basicType = EbtSampler;
8615         (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
8616     }
8617 #line 8618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8618     break;
8619 
8620   case 429:
8621 #line 2876 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8622     {
8623         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8624         (yyval.interm.type).basicType = EbtSampler;
8625         (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
8626     }
8627 #line 8628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8628     break;
8629 
8630   case 430:
8631 #line 2881 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8632     {
8633         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8634         (yyval.interm.type).basicType = EbtSampler;
8635         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
8636     }
8637 #line 8638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8638     break;
8639 
8640   case 431:
8641 #line 2886 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8642     {
8643         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8644         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8645         (yyval.interm.type).basicType = EbtSampler;
8646         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
8647     }
8648 #line 8649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8649     break;
8650 
8651   case 432:
8652 #line 2892 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8653     {
8654         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8655         (yyval.interm.type).basicType = EbtSampler;
8656         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
8657     }
8658 #line 8659 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8659     break;
8660 
8661   case 433:
8662 #line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8663     {
8664         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8665         (yyval.interm.type).basicType = EbtSampler;
8666         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
8667     }
8668 #line 8669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8669     break;
8670 
8671   case 434:
8672 #line 2902 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8673     {
8674         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8675         (yyval.interm.type).basicType = EbtSampler;
8676         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
8677     }
8678 #line 8679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8679     break;
8680 
8681   case 435:
8682 #line 2907 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8683     {
8684         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8685         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8686         (yyval.interm.type).basicType = EbtSampler;
8687         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
8688     }
8689 #line 8690 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8690     break;
8691 
8692   case 436:
8693 #line 2913 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8694     {
8695         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8696         (yyval.interm.type).basicType = EbtSampler;
8697         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
8698     }
8699 #line 8700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8700     break;
8701 
8702   case 437:
8703 #line 2918 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8704     {
8705         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8706         (yyval.interm.type).basicType = EbtSampler;
8707         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
8708     }
8709 #line 8710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8710     break;
8711 
8712   case 438:
8713 #line 2923 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8714     {
8715         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8716         (yyval.interm.type).basicType = EbtSampler;
8717         (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
8718     }
8719 #line 8720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8720     break;
8721 
8722   case 439:
8723 #line 2928 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8724     {
8725         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8726         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8727         (yyval.interm.type).basicType = EbtSampler;
8728         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
8729     }
8730 #line 8731 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8731     break;
8732 
8733   case 440:
8734 #line 2934 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8735     {
8736         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8737         (yyval.interm.type).basicType = EbtSampler;
8738         (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
8739     }
8740 #line 8741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8741     break;
8742 
8743   case 441:
8744 #line 2939 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8745     {
8746         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8747         (yyval.interm.type).basicType = EbtSampler;
8748         (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
8749     }
8750 #line 8751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8751     break;
8752 
8753   case 442:
8754 #line 2944 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8755     {
8756         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8757         (yyval.interm.type).basicType = EbtSampler;
8758         (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
8759     }
8760 #line 8761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8761     break;
8762 
8763   case 443:
8764 #line 2949 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8765     {
8766         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8767         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8768         (yyval.interm.type).basicType = EbtSampler;
8769         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
8770     }
8771 #line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8772     break;
8773 
8774   case 444:
8775 #line 2955 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8776     {
8777         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8778         (yyval.interm.type).basicType = EbtSampler;
8779         (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
8780     }
8781 #line 8782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8782     break;
8783 
8784   case 445:
8785 #line 2960 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8786     {
8787         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8788         (yyval.interm.type).basicType = EbtSampler;
8789         (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
8790     }
8791 #line 8792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8792     break;
8793 
8794   case 446:
8795 #line 2965 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8796     {
8797         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8798         (yyval.interm.type).basicType = EbtSampler;
8799         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
8800     }
8801 #line 8802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8802     break;
8803 
8804   case 447:
8805 #line 2970 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8806     {
8807         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8808         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8809         (yyval.interm.type).basicType = EbtSampler;
8810         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
8811     }
8812 #line 8813 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8813     break;
8814 
8815   case 448:
8816 #line 2976 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8817     {
8818         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8819         (yyval.interm.type).basicType = EbtSampler;
8820         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
8821     }
8822 #line 8823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8823     break;
8824 
8825   case 449:
8826 #line 2981 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8827     {
8828         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8829         (yyval.interm.type).basicType = EbtSampler;
8830         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
8831     }
8832 #line 8833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8833     break;
8834 
8835   case 450:
8836 #line 2986 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8837     {
8838         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8839         (yyval.interm.type).basicType = EbtSampler;
8840         (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
8841     }
8842 #line 8843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8843     break;
8844 
8845   case 451:
8846 #line 2991 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8847     {
8848         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8849         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8850         (yyval.interm.type).basicType = EbtSampler;
8851         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
8852     }
8853 #line 8854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8854     break;
8855 
8856   case 452:
8857 #line 2997 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8858     {
8859         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8860         (yyval.interm.type).basicType = EbtSampler;
8861         (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
8862     }
8863 #line 8864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8864     break;
8865 
8866   case 453:
8867 #line 3002 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8868     {
8869         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8870         (yyval.interm.type).basicType = EbtSampler;
8871         (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
8872     }
8873 #line 8874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8874     break;
8875 
8876   case 454:
8877 #line 3007 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8878     {
8879         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8880         (yyval.interm.type).basicType = EbtSampler;
8881         (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
8882     }
8883 #line 8884 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8884     break;
8885 
8886   case 455:
8887 #line 3012 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8888     {
8889         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8890         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8891         (yyval.interm.type).basicType = EbtSampler;
8892         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
8893     }
8894 #line 8895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8895     break;
8896 
8897   case 456:
8898 #line 3018 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8899     {
8900         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8901         (yyval.interm.type).basicType = EbtSampler;
8902         (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
8903     }
8904 #line 8905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8905     break;
8906 
8907   case 457:
8908 #line 3023 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8909     {
8910         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8911         (yyval.interm.type).basicType = EbtSampler;
8912         (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
8913     }
8914 #line 8915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8915     break;
8916 
8917   case 458:
8918 #line 3028 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8919     {
8920         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8921         (yyval.interm.type).basicType = EbtSampler;
8922         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
8923     }
8924 #line 8925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8925     break;
8926 
8927   case 459:
8928 #line 3033 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8929     {
8930         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8931         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8932         (yyval.interm.type).basicType = EbtSampler;
8933         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
8934     }
8935 #line 8936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8936     break;
8937 
8938   case 460:
8939 #line 3039 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8940     {
8941         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8942         (yyval.interm.type).basicType = EbtSampler;
8943         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
8944     }
8945 #line 8946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8946     break;
8947 
8948   case 461:
8949 #line 3044 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8950     {
8951         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8952         (yyval.interm.type).basicType = EbtSampler;
8953         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
8954     }
8955 #line 8956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8956     break;
8957 
8958   case 462:
8959 #line 3049 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8960     {
8961         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8962         (yyval.interm.type).basicType = EbtSampler;
8963         (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true);
8964     }
8965 #line 8966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8966     break;
8967 
8968   case 463:
8969 #line 3054 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8970     {
8971         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8972         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8973         (yyval.interm.type).basicType = EbtSampler;
8974         (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
8975     }
8976 #line 8977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8977     break;
8978 
8979   case 464:
8980 #line 3060 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8981     {
8982         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8983         (yyval.interm.type).basicType = EbtSampler;
8984         (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
8985     }
8986 #line 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8987     break;
8988 
8989   case 465:
8990 #line 3065 "MachineIndependent/glslang.y" /* yacc.c:1646  */
8991     {
8992         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8993         (yyval.interm.type).basicType = EbtSampler;
8994         (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
8995     }
8996 #line 8997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
8997     break;
8998 
8999   case 466:
9000 #line 3070 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9001     {
9002         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9003         (yyval.interm.type).basicType = EbtSampler;
9004         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
9005     }
9006 #line 9007 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9007     break;
9008 
9009   case 467:
9010 #line 3075 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9011     {
9012         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
9013         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9014         (yyval.interm.type).basicType = EbtSampler;
9015         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
9016     }
9017 #line 9018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9018     break;
9019 
9020   case 468:
9021 #line 3081 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9022     {
9023         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9024         (yyval.interm.type).basicType = EbtSampler;
9025         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
9026     }
9027 #line 9028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9028     break;
9029 
9030   case 469:
9031 #line 3086 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9032     {
9033         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9034         (yyval.interm.type).basicType = EbtSampler;
9035         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
9036     }
9037 #line 9038 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9038     break;
9039 
9040   case 470:
9041 #line 3091 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9042     {
9043         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9044         (yyval.interm.type).basicType = EbtSampler;
9045         (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
9046     }
9047 #line 9048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9048     break;
9049 
9050   case 471:
9051 #line 3096 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9052     {
9053         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
9054         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9055         (yyval.interm.type).basicType = EbtSampler;
9056         (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
9057     }
9058 #line 9059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9059     break;
9060 
9061   case 472:
9062 #line 3102 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9063     {
9064         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9065         (yyval.interm.type).basicType = EbtSampler;
9066         (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
9067     }
9068 #line 9069 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9069     break;
9070 
9071   case 473:
9072 #line 3107 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9073     {
9074         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9075         (yyval.interm.type).basicType = EbtSampler;
9076         (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
9077     }
9078 #line 9079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9079     break;
9080 
9081   case 474:
9082 #line 3112 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9083     {  // GL_OES_EGL_image_external
9084         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9085         (yyval.interm.type).basicType = EbtSampler;
9086         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
9087         (yyval.interm.type).sampler.external = true;
9088     }
9089 #line 9090 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9090     break;
9091 
9092   case 475:
9093 #line 3118 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9094     { // GL_EXT_YUV_target
9095         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9096         (yyval.interm.type).basicType = EbtSampler;
9097         (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
9098         (yyval.interm.type).sampler.yuv = true;
9099     }
9100 #line 9101 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9101     break;
9102 
9103   case 476:
9104 #line 3124 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9105     {
9106         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9107         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9108         (yyval.interm.type).basicType = EbtSampler;
9109         (yyval.interm.type).sampler.setSubpass(EbtFloat);
9110     }
9111 #line 9112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9112     break;
9113 
9114   case 477:
9115 #line 3130 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9116     {
9117         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9118         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9119         (yyval.interm.type).basicType = EbtSampler;
9120         (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
9121     }
9122 #line 9123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9123     break;
9124 
9125   case 478:
9126 #line 3136 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9127     {
9128         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
9129         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9130         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9131         (yyval.interm.type).basicType = EbtSampler;
9132         (yyval.interm.type).sampler.setSubpass(EbtFloat16);
9133     }
9134 #line 9135 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9135     break;
9136 
9137   case 479:
9138 #line 3143 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9139     {
9140         parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
9141         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9142         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9143         (yyval.interm.type).basicType = EbtSampler;
9144         (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
9145     }
9146 #line 9147 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9147     break;
9148 
9149   case 480:
9150 #line 3150 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9151     {
9152         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9153         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9154         (yyval.interm.type).basicType = EbtSampler;
9155         (yyval.interm.type).sampler.setSubpass(EbtInt);
9156     }
9157 #line 9158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9158     break;
9159 
9160   case 481:
9161 #line 3156 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9162     {
9163         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9164         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9165         (yyval.interm.type).basicType = EbtSampler;
9166         (yyval.interm.type).sampler.setSubpass(EbtInt, true);
9167     }
9168 #line 9169 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9169     break;
9170 
9171   case 482:
9172 #line 3162 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9173     {
9174         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9175         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9176         (yyval.interm.type).basicType = EbtSampler;
9177         (yyval.interm.type).sampler.setSubpass(EbtUint);
9178     }
9179 #line 9180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9180     break;
9181 
9182   case 483:
9183 #line 3168 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9184     {
9185         parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9186         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9187         (yyval.interm.type).basicType = EbtSampler;
9188         (yyval.interm.type).sampler.setSubpass(EbtUint, true);
9189     }
9190 #line 9191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9191     break;
9192 
9193   case 484:
9194 #line 3174 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9195     {
9196         parseContext.fcoopmatCheck((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel());
9197         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9198         (yyval.interm.type).basicType = EbtFloat;
9199         (yyval.interm.type).coopmat = true;
9200     }
9201 #line 9202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9202     break;
9203 
9204   case 485:
9205 #line 3180 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9206     {
9207         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel());
9208         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9209         (yyval.interm.type).basicType = EbtInt;
9210         (yyval.interm.type).coopmat = true;
9211     }
9212 #line 9213 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9213     break;
9214 
9215   case 486:
9216 #line 3186 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9217     {
9218         parseContext.intcoopmatCheck((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel());
9219         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9220         (yyval.interm.type).basicType = EbtUint;
9221         (yyval.interm.type).coopmat = true;
9222     }
9223 #line 9224 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9224     break;
9225 
9226   case 487:
9227 #line 3193 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9228     {
9229         (yyval.interm.type) = (yyvsp[0].interm.type);
9230         (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
9231         parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
9232     }
9233 #line 9234 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9234     break;
9235 
9236   case 488:
9237 #line 3198 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9238     {
9239         //
9240         // This is for user defined type names.  The lexical phase looked up the
9241         // type.
9242         //
9243         if (const TVariable* variable = ((yyvsp[0].lex).symbol)->getAsVariable()) {
9244             const TType& structure = variable->getType();
9245             (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9246             (yyval.interm.type).basicType = EbtStruct;
9247             (yyval.interm.type).userDef = &structure;
9248         } else
9249             parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
9250     }
9251 #line 9252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9252     break;
9253 
9254   case 489:
9255 #line 3214 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9256     {
9257         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
9258         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9259         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
9260     }
9261 #line 9262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9262     break;
9263 
9264   case 490:
9265 #line 3219 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9266     {
9267         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
9268         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9269         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
9270     }
9271 #line 9272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9272     break;
9273 
9274   case 491:
9275 #line 3224 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9276     {
9277         parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
9278         (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9279         parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
9280     }
9281 #line 9282 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9282     break;
9283 
9284   case 492:
9285 #line 3232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9286     { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
9287 #line 9288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9288     break;
9289 
9290   case 493:
9291 #line 3232 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9292     {
9293         TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
9294         parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
9295         TVariable* userTypeDef = new TVariable((yyvsp[-4].lex).string, *structure, true);
9296         if (! parseContext.symbolTable.insert(*userTypeDef))
9297             parseContext.error((yyvsp[-4].lex).loc, "redefinition", (yyvsp[-4].lex).string->c_str(), "struct");
9298         (yyval.interm.type).init((yyvsp[-5].lex).loc);
9299         (yyval.interm.type).basicType = EbtStruct;
9300         (yyval.interm.type).userDef = structure;
9301         --parseContext.structNestingLevel;
9302     }
9303 #line 9304 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9304     break;
9305 
9306   case 494:
9307 #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9308     { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
9309 #line 9310 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9310     break;
9311 
9312   case 495:
9313 #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9314     {
9315         TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
9316         (yyval.interm.type).init((yyvsp[-4].lex).loc);
9317         (yyval.interm.type).basicType = EbtStruct;
9318         (yyval.interm.type).userDef = structure;
9319         --parseContext.structNestingLevel;
9320     }
9321 #line 9322 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9322     break;
9323 
9324   case 496:
9325 #line 3253 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9326     {
9327         (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
9328     }
9329 #line 9330 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9330     break;
9331 
9332   case 497:
9333 #line 3256 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9334     {
9335         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9336         for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
9337             for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
9338                 if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName())
9339                     parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str());
9340             }
9341             (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
9342         }
9343     }
9344 #line 9345 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9345     break;
9346 
9347   case 498:
9348 #line 3269 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9349     {
9350         if ((yyvsp[-2].interm.type).arraySizes) {
9351             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
9352             parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
9353             if (parseContext.isEsProfile())
9354                 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
9355         }
9356 
9357         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9358 
9359         parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
9360         parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
9361 
9362         for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
9363             TType type((yyvsp[-2].interm.type));
9364             type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
9365             type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
9366             type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
9367             parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
9368             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
9369         }
9370     }
9371 #line 9372 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9372     break;
9373 
9374   case 499:
9375 #line 3291 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9376     {
9377         if ((yyvsp[-2].interm.type).arraySizes) {
9378             parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
9379             parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
9380             if (parseContext.isEsProfile())
9381                 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
9382         }
9383 
9384         (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9385 
9386         parseContext.memberQualifierCheck((yyvsp[-3].interm.type));
9387         parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
9388         parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true);
9389         parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
9390 
9391         for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
9392             TType type((yyvsp[-2].interm.type));
9393             type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
9394             type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
9395             type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
9396             parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
9397             (*(yyval.interm.typeList))[i].type->shallowCopy(type);
9398         }
9399     }
9400 #line 9401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9401     break;
9402 
9403   case 500:
9404 #line 3318 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9405     {
9406         (yyval.interm.typeList) = new TTypeList;
9407         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
9408     }
9409 #line 9410 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9410     break;
9411 
9412   case 501:
9413 #line 3322 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9414     {
9415         (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
9416     }
9417 #line 9418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9418     break;
9419 
9420   case 502:
9421 #line 3328 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9422     {
9423         (yyval.interm.typeLine).type = new TType(EbtVoid);
9424         (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
9425         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
9426     }
9427 #line 9428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9428     break;
9429 
9430   case 503:
9431 #line 3333 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9432     {
9433         parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
9434 
9435         (yyval.interm.typeLine).type = new TType(EbtVoid);
9436         (yyval.interm.typeLine).loc = (yyvsp[-1].lex).loc;
9437         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
9438         (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
9439     }
9440 #line 9441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9441     break;
9442 
9443   case 504:
9444 #line 3344 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9445     {
9446         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9447     }
9448 #line 9449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9449     break;
9450 
9451   case 505:
9452 #line 3348 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9453     {
9454         const char* initFeature = "{ } style initializers";
9455         parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
9456         parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
9457         (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
9458     }
9459 #line 9460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9460     break;
9461 
9462   case 506:
9463 #line 3354 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9464     {
9465         const char* initFeature = "{ } style initializers";
9466         parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
9467         parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
9468         (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
9469     }
9470 #line 9471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9471     break;
9472 
9473   case 507:
9474 #line 3365 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9475     {
9476         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
9477     }
9478 #line 9479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9479     break;
9480 
9481   case 508:
9482 #line 3368 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9483     {
9484         (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
9485     }
9486 #line 9487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9487     break;
9488 
9489   case 509:
9490 #line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9491     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9492 #line 9493 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9493     break;
9494 
9495   case 510:
9496 #line 3379 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9497     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9498 #line 9499 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9499     break;
9500 
9501   case 511:
9502 #line 3380 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9503     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9504 #line 9505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9505     break;
9506 
9507   case 512:
9508 #line 3386 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9509     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9510 #line 9511 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9511     break;
9512 
9513   case 513:
9514 #line 3387 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9515     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9516 #line 9517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9517     break;
9518 
9519   case 514:
9520 #line 3388 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9521     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9522 #line 9523 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9523     break;
9524 
9525   case 515:
9526 #line 3389 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9527     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9528 #line 9529 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9529     break;
9530 
9531   case 516:
9532 #line 3390 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9533     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9534 #line 9535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9535     break;
9536 
9537   case 517:
9538 #line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9539     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9540 #line 9541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9541     break;
9542 
9543   case 518:
9544 #line 3392 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9545     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9546 #line 9547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9547     break;
9548 
9549   case 519:
9550 #line 3394 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9551     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9552 #line 9553 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9553     break;
9554 
9555   case 520:
9556 #line 3400 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9557     {
9558         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote");
9559         parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote");
9560         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc);
9561     }
9562 #line 9563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9563     break;
9564 
9565   case 521:
9566 #line 3409 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9567     { (yyval.interm.intermNode) = 0; }
9568 #line 9569 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9569     break;
9570 
9571   case 522:
9572 #line 3410 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9573     {
9574         parseContext.symbolTable.push();
9575         ++parseContext.statementNestingLevel;
9576     }
9577 #line 9578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9578     break;
9579 
9580   case 523:
9581 #line 3414 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9582     {
9583         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9584         --parseContext.statementNestingLevel;
9585     }
9586 #line 9587 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9587     break;
9588 
9589   case 524:
9590 #line 3418 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9591     {
9592         if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate())
9593             (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9594         (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
9595     }
9596 #line 9597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9597     break;
9598 
9599   case 525:
9600 #line 3426 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9601     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9602 #line 9603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9603     break;
9604 
9605   case 526:
9606 #line 3427 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9607     { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9608 #line 9609 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9609     break;
9610 
9611   case 527:
9612 #line 3431 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9613     {
9614         ++parseContext.controlFlowNestingLevel;
9615     }
9616 #line 9617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9617     break;
9618 
9619   case 528:
9620 #line 3434 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9621     {
9622         --parseContext.controlFlowNestingLevel;
9623         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9624     }
9625 #line 9626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9626     break;
9627 
9628   case 529:
9629 #line 3438 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9630     {
9631         parseContext.symbolTable.push();
9632         ++parseContext.statementNestingLevel;
9633         ++parseContext.controlFlowNestingLevel;
9634     }
9635 #line 9636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9636     break;
9637 
9638   case 530:
9639 #line 3443 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9640     {
9641         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9642         --parseContext.statementNestingLevel;
9643         --parseContext.controlFlowNestingLevel;
9644         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9645     }
9646 #line 9647 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9647     break;
9648 
9649   case 531:
9650 #line 3452 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9651     {
9652         (yyval.interm.intermNode) = 0;
9653     }
9654 #line 9655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9655     break;
9656 
9657   case 532:
9658 #line 3455 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9659     {
9660         if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate())
9661             (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9662         (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
9663     }
9664 #line 9665 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9665     break;
9666 
9667   case 533:
9668 #line 3463 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9669     {
9670         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
9671         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
9672                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
9673             parseContext.wrapupSwitchSubsequence(0, (yyvsp[0].interm.intermNode));
9674             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
9675         }
9676     }
9677 #line 9678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9678     break;
9679 
9680   case 534:
9681 #line 3471 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9682     {
9683         if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
9684                                             (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
9685             parseContext.wrapupSwitchSubsequence((yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0, (yyvsp[0].interm.intermNode));
9686             (yyval.interm.intermNode) = 0;  // start a fresh subsequence for what's after this case
9687         } else
9688             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
9689     }
9690 #line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9691     break;
9692 
9693   case 535:
9694 #line 3482 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9695     { (yyval.interm.intermNode) = 0; }
9696 #line 9697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9697     break;
9698 
9699   case 536:
9700 #line 3483 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9701     { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
9702 #line 9703 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9703     break;
9704 
9705   case 537:
9706 #line 3487 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9707     {
9708         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9709     }
9710 #line 9711 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9711     break;
9712 
9713   case 538:
9714 #line 3491 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9715     {
9716         parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9717         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9718     }
9719 #line 9720 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9720     break;
9721 
9722   case 539:
9723 #line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9724     {
9725         parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
9726         (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
9727     }
9728 #line 9729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9729     break;
9730 
9731   case 540:
9732 #line 3505 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9733     {
9734         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
9735         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
9736     }
9737 #line 9738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9738     break;
9739 
9740   case 541:
9741 #line 3509 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9742     {
9743         (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
9744         (yyval.interm.nodePair).node2 = 0;
9745     }
9746 #line 9747 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9747     break;
9748 
9749   case 542:
9750 #line 3517 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9751     {
9752         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9753         parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
9754     }
9755 #line 9756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9756     break;
9757 
9758   case 543:
9759 #line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9760     {
9761         parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
9762 
9763         TType type((yyvsp[-3].interm.type));
9764         TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
9765         if (initNode)
9766             (yyval.interm.intermTypedNode) = initNode->getAsTyped();
9767         else
9768             (yyval.interm.intermTypedNode) = 0;
9769     }
9770 #line 9771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9771     break;
9772 
9773   case 544:
9774 #line 3534 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9775     {
9776         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9777     }
9778 #line 9779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9779     break;
9780 
9781   case 545:
9782 #line 3538 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9783     {
9784         parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9785         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9786     }
9787 #line 9788 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9788     break;
9789 
9790   case 546:
9791 #line 3545 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9792     {
9793         // start new switch sequence on the switch stack
9794         ++parseContext.controlFlowNestingLevel;
9795         ++parseContext.statementNestingLevel;
9796         parseContext.switchSequenceStack.push_back(new TIntermSequence);
9797         parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
9798         parseContext.symbolTable.push();
9799     }
9800 #line 9801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9801     break;
9802 
9803   case 547:
9804 #line 3553 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9805     {
9806         (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
9807         delete parseContext.switchSequenceStack.back();
9808         parseContext.switchSequenceStack.pop_back();
9809         parseContext.switchLevel.pop_back();
9810         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9811         --parseContext.statementNestingLevel;
9812         --parseContext.controlFlowNestingLevel;
9813     }
9814 #line 9815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9815     break;
9816 
9817   case 548:
9818 #line 3565 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9819     {
9820         (yyval.interm.intermNode) = 0;
9821     }
9822 #line 9823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9823     break;
9824 
9825   case 549:
9826 #line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9827     {
9828         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9829     }
9830 #line 9831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9831     break;
9832 
9833   case 550:
9834 #line 3574 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9835     {
9836         (yyval.interm.intermNode) = 0;
9837         if (parseContext.switchLevel.size() == 0)
9838             parseContext.error((yyvsp[-2].lex).loc, "cannot appear outside switch statement", "case", "");
9839         else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
9840             parseContext.error((yyvsp[-2].lex).loc, "cannot be nested inside control flow", "case", "");
9841         else {
9842             parseContext.constantValueCheck((yyvsp[-1].interm.intermTypedNode), "case");
9843             parseContext.integerCheck((yyvsp[-1].interm.intermTypedNode), "case");
9844             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
9845         }
9846     }
9847 #line 9848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9848     break;
9849 
9850   case 551:
9851 #line 3586 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9852     {
9853         (yyval.interm.intermNode) = 0;
9854         if (parseContext.switchLevel.size() == 0)
9855             parseContext.error((yyvsp[-1].lex).loc, "cannot appear outside switch statement", "default", "");
9856         else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
9857             parseContext.error((yyvsp[-1].lex).loc, "cannot be nested inside control flow", "default", "");
9858         else
9859             (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
9860     }
9861 #line 9862 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9862     break;
9863 
9864   case 552:
9865 #line 3598 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9866     {
9867         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9868     }
9869 #line 9870 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9870     break;
9871 
9872   case 553:
9873 #line 3602 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9874     {
9875         parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9876         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9877     }
9878 #line 9879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9879     break;
9880 
9881   case 554:
9882 #line 3609 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9883     {
9884         if (! parseContext.limits.whileLoops)
9885             parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
9886         parseContext.symbolTable.push();
9887         ++parseContext.loopNestingLevel;
9888         ++parseContext.statementNestingLevel;
9889         ++parseContext.controlFlowNestingLevel;
9890     }
9891 #line 9892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9892     break;
9893 
9894   case 555:
9895 #line 3617 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9896     {
9897         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9898         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc);
9899         --parseContext.loopNestingLevel;
9900         --parseContext.statementNestingLevel;
9901         --parseContext.controlFlowNestingLevel;
9902     }
9903 #line 9904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9904     break;
9905 
9906   case 556:
9907 #line 3624 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9908     {
9909         ++parseContext.loopNestingLevel;
9910         ++parseContext.statementNestingLevel;
9911         ++parseContext.controlFlowNestingLevel;
9912     }
9913 #line 9914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9914     break;
9915 
9916   case 557:
9917 #line 3629 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9918     {
9919         if (! parseContext.limits.whileLoops)
9920             parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
9921 
9922         parseContext.boolCheck((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode));
9923 
9924         (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[-5].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, false, (yyvsp[-4].lex).loc);
9925         --parseContext.loopNestingLevel;
9926         --parseContext.statementNestingLevel;
9927         --parseContext.controlFlowNestingLevel;
9928     }
9929 #line 9930 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9930     break;
9931 
9932   case 558:
9933 #line 3640 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9934     {
9935         parseContext.symbolTable.push();
9936         ++parseContext.loopNestingLevel;
9937         ++parseContext.statementNestingLevel;
9938         ++parseContext.controlFlowNestingLevel;
9939     }
9940 #line 9941 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9941     break;
9942 
9943   case 559:
9944 #line 3646 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9945     {
9946         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9947         (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
9948         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);
9949         if (! parseContext.limits.nonInductiveForLoops)
9950             parseContext.inductiveLoopCheck((yyvsp[-6].lex).loc, (yyvsp[-3].interm.intermNode), forLoop);
9951         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyval.interm.intermNode), forLoop, (yyvsp[-6].lex).loc);
9952         (yyval.interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9953         --parseContext.loopNestingLevel;
9954         --parseContext.statementNestingLevel;
9955         --parseContext.controlFlowNestingLevel;
9956     }
9957 #line 9958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9958     break;
9959 
9960   case 560:
9961 #line 3661 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9962     {
9963         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9964     }
9965 #line 9966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9966     break;
9967 
9968   case 561:
9969 #line 3664 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9970     {
9971         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9972     }
9973 #line 9974 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9974     break;
9975 
9976   case 562:
9977 #line 3670 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9978     {
9979         (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9980     }
9981 #line 9982 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9982     break;
9983 
9984   case 563:
9985 #line 3673 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9986     {
9987         (yyval.interm.intermTypedNode) = 0;
9988     }
9989 #line 9990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9990     break;
9991 
9992   case 564:
9993 #line 3679 "MachineIndependent/glslang.y" /* yacc.c:1646  */
9994     {
9995         (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
9996         (yyval.interm.nodePair).node2 = 0;
9997     }
9998 #line 9999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
9999     break;
10000 
10001   case 565:
10002 #line 3683 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10003     {
10004         (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
10005         (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
10006     }
10007 #line 10008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10008     break;
10009 
10010   case 566:
10011 #line 3690 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10012     {
10013         if (parseContext.loopNestingLevel <= 0)
10014             parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
10015         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
10016     }
10017 #line 10018 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10018     break;
10019 
10020   case 567:
10021 #line 3695 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10022     {
10023         if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
10024             parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
10025         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
10026     }
10027 #line 10028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10028     break;
10029 
10030   case 568:
10031 #line 3700 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10032     {
10033         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
10034         if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
10035             parseContext.error((yyvsp[-1].lex).loc, "non-void function must return a value", "return", "");
10036         if (parseContext.inMain)
10037             parseContext.postEntryPointReturn = true;
10038     }
10039 #line 10040 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10040     break;
10041 
10042   case 569:
10043 #line 3707 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10044     {
10045         (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
10046     }
10047 #line 10048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10048     break;
10049 
10050   case 570:
10051 #line 3710 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10052     {
10053         parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
10054         (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
10055     }
10056 #line 10057 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10057     break;
10058 
10059   case 571:
10060 #line 3719 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10061     {
10062         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10063         parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
10064     }
10065 #line 10066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10066     break;
10067 
10068   case 572:
10069 #line 3723 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10070     {
10071         if ((yyvsp[0].interm.intermNode) != nullptr) {
10072             (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
10073             parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
10074         }
10075     }
10076 #line 10077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10077     break;
10078 
10079   case 573:
10080 #line 3732 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10081     {
10082         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10083     }
10084 #line 10085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10085     break;
10086 
10087   case 574:
10088 #line 3735 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10089     {
10090         (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10091     }
10092 #line 10093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10093     break;
10094 
10095   case 575:
10096 #line 3739 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10097     {
10098         parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
10099         parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
10100         (yyval.interm.intermNode) = nullptr;
10101     }
10102 #line 10103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10103     break;
10104 
10105   case 576:
10106 #line 3748 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10107     {
10108         (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
10109         (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
10110     }
10111 #line 10112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10112     break;
10113 
10114   case 577:
10115 #line 3752 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10116     {
10117         //   May be best done as post process phase on intermediate code
10118         if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
10119             parseContext.error((yyvsp[-2].interm).loc, "function does not return a value:", "", (yyvsp[-2].interm).function->getName().c_str());
10120         parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
10121         (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermNode));
10122         parseContext.intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[-2].interm).function->getType(), (yyvsp[-2].interm).loc);
10123         (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[-2].interm).function->getMangledName().c_str());
10124 
10125         // store the pragma information for debug and optimize and other vendor specific
10126         // information. This information can be queried from the parse tree
10127         (yyval.interm.intermNode)->getAsAggregate()->setOptimize(parseContext.contextPragma.optimize);
10128         (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
10129         (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
10130     }
10131 #line 10132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10132     break;
10133 
10134   case 578:
10135 #line 3771 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10136     {
10137         (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
10138         parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute");
10139     }
10140 #line 10141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10141     break;
10142 
10143   case 579:
10144 #line 3777 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10145     {
10146         (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
10147     }
10148 #line 10149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10149     break;
10150 
10151   case 580:
10152 #line 3780 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10153     {
10154         (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
10155     }
10156 #line 10157 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10157     break;
10158 
10159   case 581:
10160 #line 3785 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10161     {
10162         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
10163     }
10164 #line 10165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10165     break;
10166 
10167   case 582:
10168 #line 3788 "MachineIndependent/glslang.y" /* yacc.c:1646  */
10169     {
10170         (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
10171     }
10172 #line 10173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10173     break;
10174 
10175 
10176 #line 10177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646  */
10177       default: break;
10178     }
10179   /* User semantic actions sometimes alter yychar, and that requires
10180      that yytoken be updated with the new translation.  We take the
10181      approach of translating immediately before every use of yytoken.
10182      One alternative is translating here after every semantic action,
10183      but that translation would be missed if the semantic action invokes
10184      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10185      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
10186      incorrect destructor might then be invoked immediately.  In the
10187      case of YYERROR or YYBACKUP, subsequent parser actions might lead
10188      to an incorrect destructor call or verbose syntax error message
10189      before the lookahead is translated.  */
10190   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10191 
10192   YYPOPSTACK (yylen);
10193   yylen = 0;
10194   YY_STACK_PRINT (yyss, yyssp);
10195 
10196   *++yyvsp = yyval;
10197 
10198   /* Now 'shift' the result of the reduction.  Determine what state
10199      that goes to, based on the state we popped back to and the rule
10200      number reduced by.  */
10201 
10202   yyn = yyr1[yyn];
10203 
10204   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10205   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10206     yystate = yytable[yystate];
10207   else
10208     yystate = yydefgoto[yyn - YYNTOKENS];
10209 
10210   goto yynewstate;
10211 
10212 
10213 /*--------------------------------------.
10214 | yyerrlab -- here on detecting error.  |
10215 `--------------------------------------*/
10216 yyerrlab:
10217   /* Make sure we have latest lookahead translation.  See comments at
10218      user semantic actions for why this is necessary.  */
10219   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10220 
10221   /* If not already recovering from an error, report this error.  */
10222   if (!yyerrstatus)
10223     {
10224       ++yynerrs;
10225 #if ! YYERROR_VERBOSE
10226       yyerror (pParseContext, YY_("syntax error"));
10227 #else
10228 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10229                                         yyssp, yytoken)
10230       {
10231         char const *yymsgp = YY_("syntax error");
10232         int yysyntax_error_status;
10233         yysyntax_error_status = YYSYNTAX_ERROR;
10234         if (yysyntax_error_status == 0)
10235           yymsgp = yymsg;
10236         else if (yysyntax_error_status == 1)
10237           {
10238             if (yymsg != yymsgbuf)
10239               YYSTACK_FREE (yymsg);
10240             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
10241             if (!yymsg)
10242               {
10243                 yymsg = yymsgbuf;
10244                 yymsg_alloc = sizeof yymsgbuf;
10245                 yysyntax_error_status = 2;
10246               }
10247             else
10248               {
10249                 yysyntax_error_status = YYSYNTAX_ERROR;
10250                 yymsgp = yymsg;
10251               }
10252           }
10253         yyerror (pParseContext, yymsgp);
10254         if (yysyntax_error_status == 2)
10255           goto yyexhaustedlab;
10256       }
10257 # undef YYSYNTAX_ERROR
10258 #endif
10259     }
10260 
10261 
10262 
10263   if (yyerrstatus == 3)
10264     {
10265       /* If just tried and failed to reuse lookahead token after an
10266          error, discard it.  */
10267 
10268       if (yychar <= YYEOF)
10269         {
10270           /* Return failure if at end of input.  */
10271           if (yychar == YYEOF)
10272             YYABORT;
10273         }
10274       else
10275         {
10276           yydestruct ("Error: discarding",
10277                       yytoken, &yylval, pParseContext);
10278           yychar = YYEMPTY;
10279         }
10280     }
10281 
10282   /* Else will try to reuse lookahead token after shifting the error
10283      token.  */
10284   goto yyerrlab1;
10285 
10286 
10287 /*---------------------------------------------------.
10288 | yyerrorlab -- error raised explicitly by YYERROR.  |
10289 `---------------------------------------------------*/
10290 yyerrorlab:
10291 
10292   /* Pacify compilers like GCC when the user code never invokes
10293      YYERROR and the label yyerrorlab therefore never appears in user
10294      code.  */
10295   if (/*CONSTCOND*/ 0)
10296      goto yyerrorlab;
10297 
10298   /* Do not reclaim the symbols of the rule whose action triggered
10299      this YYERROR.  */
10300   YYPOPSTACK (yylen);
10301   yylen = 0;
10302   YY_STACK_PRINT (yyss, yyssp);
10303   yystate = *yyssp;
10304   goto yyerrlab1;
10305 
10306 
10307 /*-------------------------------------------------------------.
10308 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
10309 `-------------------------------------------------------------*/
10310 yyerrlab1:
10311   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10312 
10313   for (;;)
10314     {
10315       yyn = yypact[yystate];
10316       if (!yypact_value_is_default (yyn))
10317         {
10318           yyn += YYTERROR;
10319           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10320             {
10321               yyn = yytable[yyn];
10322               if (0 < yyn)
10323                 break;
10324             }
10325         }
10326 
10327       /* Pop the current state because it cannot handle the error token.  */
10328       if (yyssp == yyss)
10329         YYABORT;
10330 
10331 
10332       yydestruct ("Error: popping",
10333                   yystos[yystate], yyvsp, pParseContext);
10334       YYPOPSTACK (1);
10335       yystate = *yyssp;
10336       YY_STACK_PRINT (yyss, yyssp);
10337     }
10338 
10339   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
10340   *++yyvsp = yylval;
10341   YY_IGNORE_MAYBE_UNINITIALIZED_END
10342 
10343 
10344   /* Shift the error token.  */
10345   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10346 
10347   yystate = yyn;
10348   goto yynewstate;
10349 
10350 
10351 /*-------------------------------------.
10352 | yyacceptlab -- YYACCEPT comes here.  |
10353 `-------------------------------------*/
10354 yyacceptlab:
10355   yyresult = 0;
10356   goto yyreturn;
10357 
10358 /*-----------------------------------.
10359 | yyabortlab -- YYABORT comes here.  |
10360 `-----------------------------------*/
10361 yyabortlab:
10362   yyresult = 1;
10363   goto yyreturn;
10364 
10365 #if !defined yyoverflow || YYERROR_VERBOSE
10366 /*-------------------------------------------------.
10367 | yyexhaustedlab -- memory exhaustion comes here.  |
10368 `-------------------------------------------------*/
10369 yyexhaustedlab:
10370   yyerror (pParseContext, YY_("memory exhausted"));
10371   yyresult = 2;
10372   /* Fall through.  */
10373 #endif
10374 
10375 yyreturn:
10376   if (yychar != YYEMPTY)
10377     {
10378       /* Make sure we have latest lookahead translation.  See comments at
10379          user semantic actions for why this is necessary.  */
10380       yytoken = YYTRANSLATE (yychar);
10381       yydestruct ("Cleanup: discarding lookahead",
10382                   yytoken, &yylval, pParseContext);
10383     }
10384   /* Do not reclaim the symbols of the rule whose action triggered
10385      this YYABORT or YYACCEPT.  */
10386   YYPOPSTACK (yylen);
10387   YY_STACK_PRINT (yyss, yyssp);
10388   while (yyssp != yyss)
10389     {
10390       yydestruct ("Cleanup: popping",
10391                   yystos[*yyssp], yyvsp, pParseContext);
10392       YYPOPSTACK (1);
10393     }
10394 #ifndef yyoverflow
10395   if (yyss != yyssa)
10396     YYSTACK_FREE (yyss);
10397 #endif
10398 #if YYERROR_VERBOSE
10399   if (yymsg != yymsgbuf)
10400     YYSTACK_FREE (yymsg);
10401 #endif
10402   return yyresult;
10403 }
10404 #line 3793 "MachineIndependent/glslang.y" /* yacc.c:1906  */
10405 
10406