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