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 42 "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 ATTRIBUTE = 258,
127 VARYING = 259,
128 FLOAT16_T = 260,
129 FLOAT = 261,
130 FLOAT32_T = 262,
131 DOUBLE = 263,
132 FLOAT64_T = 264,
133 CONST = 265,
134 BOOL = 266,
135 INT = 267,
136 UINT = 268,
137 INT64_T = 269,
138 UINT64_T = 270,
139 INT32_T = 271,
140 UINT32_T = 272,
141 INT16_T = 273,
142 UINT16_T = 274,
143 INT8_T = 275,
144 UINT8_T = 276,
145 BREAK = 277,
146 CONTINUE = 278,
147 DO = 279,
148 ELSE = 280,
149 FOR = 281,
150 IF = 282,
151 DISCARD = 283,
152 RETURN = 284,
153 SWITCH = 285,
154 CASE = 286,
155 DEFAULT = 287,
156 SUBROUTINE = 288,
157 BVEC2 = 289,
158 BVEC3 = 290,
159 BVEC4 = 291,
160 IVEC2 = 292,
161 IVEC3 = 293,
162 IVEC4 = 294,
163 UVEC2 = 295,
164 UVEC3 = 296,
165 UVEC4 = 297,
166 I64VEC2 = 298,
167 I64VEC3 = 299,
168 I64VEC4 = 300,
169 U64VEC2 = 301,
170 U64VEC3 = 302,
171 U64VEC4 = 303,
172 I32VEC2 = 304,
173 I32VEC3 = 305,
174 I32VEC4 = 306,
175 U32VEC2 = 307,
176 U32VEC3 = 308,
177 U32VEC4 = 309,
178 I16VEC2 = 310,
179 I16VEC3 = 311,
180 I16VEC4 = 312,
181 U16VEC2 = 313,
182 U16VEC3 = 314,
183 U16VEC4 = 315,
184 I8VEC2 = 316,
185 I8VEC3 = 317,
186 I8VEC4 = 318,
187 U8VEC2 = 319,
188 U8VEC3 = 320,
189 U8VEC4 = 321,
190 VEC2 = 322,
191 VEC3 = 323,
192 VEC4 = 324,
193 MAT2 = 325,
194 MAT3 = 326,
195 MAT4 = 327,
196 CENTROID = 328,
197 IN = 329,
198 OUT = 330,
199 INOUT = 331,
200 UNIFORM = 332,
201 PATCH = 333,
202 SAMPLE = 334,
203 BUFFER = 335,
204 SHARED = 336,
205 NONUNIFORM = 337,
206 PAYLOADNV = 338,
207 PAYLOADINNV = 339,
208 HITATTRNV = 340,
209 CALLDATANV = 341,
210 CALLDATAINNV = 342,
211 COHERENT = 343,
212 VOLATILE = 344,
213 RESTRICT = 345,
214 READONLY = 346,
215 WRITEONLY = 347,
216 DEVICECOHERENT = 348,
217 QUEUEFAMILYCOHERENT = 349,
218 WORKGROUPCOHERENT = 350,
219 SUBGROUPCOHERENT = 351,
220 NONPRIVATE = 352,
221 DVEC2 = 353,
222 DVEC3 = 354,
223 DVEC4 = 355,
224 DMAT2 = 356,
225 DMAT3 = 357,
226 DMAT4 = 358,
227 F16VEC2 = 359,
228 F16VEC3 = 360,
229 F16VEC4 = 361,
230 F16MAT2 = 362,
231 F16MAT3 = 363,
232 F16MAT4 = 364,
233 F32VEC2 = 365,
234 F32VEC3 = 366,
235 F32VEC4 = 367,
236 F32MAT2 = 368,
237 F32MAT3 = 369,
238 F32MAT4 = 370,
239 F64VEC2 = 371,
240 F64VEC3 = 372,
241 F64VEC4 = 373,
242 F64MAT2 = 374,
243 F64MAT3 = 375,
244 F64MAT4 = 376,
245 NOPERSPECTIVE = 377,
246 FLAT = 378,
247 SMOOTH = 379,
248 LAYOUT = 380,
249 EXPLICITINTERPAMD = 381,
250 PERVERTEXNV = 382,
251 PERPRIMITIVENV = 383,
252 PERVIEWNV = 384,
253 PERTASKNV = 385,
254 MAT2X2 = 386,
255 MAT2X3 = 387,
256 MAT2X4 = 388,
257 MAT3X2 = 389,
258 MAT3X3 = 390,
259 MAT3X4 = 391,
260 MAT4X2 = 392,
261 MAT4X3 = 393,
262 MAT4X4 = 394,
263 DMAT2X2 = 395,
264 DMAT2X3 = 396,
265 DMAT2X4 = 397,
266 DMAT3X2 = 398,
267 DMAT3X3 = 399,
268 DMAT3X4 = 400,
269 DMAT4X2 = 401,
270 DMAT4X3 = 402,
271 DMAT4X4 = 403,
272 F16MAT2X2 = 404,
273 F16MAT2X3 = 405,
274 F16MAT2X4 = 406,
275 F16MAT3X2 = 407,
276 F16MAT3X3 = 408,
277 F16MAT3X4 = 409,
278 F16MAT4X2 = 410,
279 F16MAT4X3 = 411,
280 F16MAT4X4 = 412,
281 F32MAT2X2 = 413,
282 F32MAT2X3 = 414,
283 F32MAT2X4 = 415,
284 F32MAT3X2 = 416,
285 F32MAT3X3 = 417,
286 F32MAT3X4 = 418,
287 F32MAT4X2 = 419,
288 F32MAT4X3 = 420,
289 F32MAT4X4 = 421,
290 F64MAT2X2 = 422,
291 F64MAT2X3 = 423,
292 F64MAT2X4 = 424,
293 F64MAT3X2 = 425,
294 F64MAT3X3 = 426,
295 F64MAT3X4 = 427,
296 F64MAT4X2 = 428,
297 F64MAT4X3 = 429,
298 F64MAT4X4 = 430,
299 ATOMIC_UINT = 431,
300 ACCSTRUCTNV = 432,
301 SAMPLER1D = 433,
302 SAMPLER2D = 434,
303 SAMPLER3D = 435,
304 SAMPLERCUBE = 436,
305 SAMPLER1DSHADOW = 437,
306 SAMPLER2DSHADOW = 438,
307 SAMPLERCUBESHADOW = 439,
308 SAMPLER1DARRAY = 440,
309 SAMPLER2DARRAY = 441,
310 SAMPLER1DARRAYSHADOW = 442,
311 SAMPLER2DARRAYSHADOW = 443,
312 ISAMPLER1D = 444,
313 ISAMPLER2D = 445,
314 ISAMPLER3D = 446,
315 ISAMPLERCUBE = 447,
316 ISAMPLER1DARRAY = 448,
317 ISAMPLER2DARRAY = 449,
318 USAMPLER1D = 450,
319 USAMPLER2D = 451,
320 USAMPLER3D = 452,
321 USAMPLERCUBE = 453,
322 USAMPLER1DARRAY = 454,
323 USAMPLER2DARRAY = 455,
324 SAMPLER2DRECT = 456,
325 SAMPLER2DRECTSHADOW = 457,
326 ISAMPLER2DRECT = 458,
327 USAMPLER2DRECT = 459,
328 SAMPLERBUFFER = 460,
329 ISAMPLERBUFFER = 461,
330 USAMPLERBUFFER = 462,
331 SAMPLERCUBEARRAY = 463,
332 SAMPLERCUBEARRAYSHADOW = 464,
333 ISAMPLERCUBEARRAY = 465,
334 USAMPLERCUBEARRAY = 466,
335 SAMPLER2DMS = 467,
336 ISAMPLER2DMS = 468,
337 USAMPLER2DMS = 469,
338 SAMPLER2DMSARRAY = 470,
339 ISAMPLER2DMSARRAY = 471,
340 USAMPLER2DMSARRAY = 472,
341 SAMPLEREXTERNALOES = 473,
342 F16SAMPLER1D = 474,
343 F16SAMPLER2D = 475,
344 F16SAMPLER3D = 476,
345 F16SAMPLER2DRECT = 477,
346 F16SAMPLERCUBE = 478,
347 F16SAMPLER1DARRAY = 479,
348 F16SAMPLER2DARRAY = 480,
349 F16SAMPLERCUBEARRAY = 481,
350 F16SAMPLERBUFFER = 482,
351 F16SAMPLER2DMS = 483,
352 F16SAMPLER2DMSARRAY = 484,
353 F16SAMPLER1DSHADOW = 485,
354 F16SAMPLER2DSHADOW = 486,
355 F16SAMPLER1DARRAYSHADOW = 487,
356 F16SAMPLER2DARRAYSHADOW = 488,
357 F16SAMPLER2DRECTSHADOW = 489,
358 F16SAMPLERCUBESHADOW = 490,
359 F16SAMPLERCUBEARRAYSHADOW = 491,
360 SAMPLER = 492,
361 SAMPLERSHADOW = 493,
362 TEXTURE1D = 494,
363 TEXTURE2D = 495,
364 TEXTURE3D = 496,
365 TEXTURECUBE = 497,
366 TEXTURE1DARRAY = 498,
367 TEXTURE2DARRAY = 499,
368 ITEXTURE1D = 500,
369 ITEXTURE2D = 501,
370 ITEXTURE3D = 502,
371 ITEXTURECUBE = 503,
372 ITEXTURE1DARRAY = 504,
373 ITEXTURE2DARRAY = 505,
374 UTEXTURE1D = 506,
375 UTEXTURE2D = 507,
376 UTEXTURE3D = 508,
377 UTEXTURECUBE = 509,
378 UTEXTURE1DARRAY = 510,
379 UTEXTURE2DARRAY = 511,
380 TEXTURE2DRECT = 512,
381 ITEXTURE2DRECT = 513,
382 UTEXTURE2DRECT = 514,
383 TEXTUREBUFFER = 515,
384 ITEXTUREBUFFER = 516,
385 UTEXTUREBUFFER = 517,
386 TEXTURECUBEARRAY = 518,
387 ITEXTURECUBEARRAY = 519,
388 UTEXTURECUBEARRAY = 520,
389 TEXTURE2DMS = 521,
390 ITEXTURE2DMS = 522,
391 UTEXTURE2DMS = 523,
392 TEXTURE2DMSARRAY = 524,
393 ITEXTURE2DMSARRAY = 525,
394 UTEXTURE2DMSARRAY = 526,
395 F16TEXTURE1D = 527,
396 F16TEXTURE2D = 528,
397 F16TEXTURE3D = 529,
398 F16TEXTURE2DRECT = 530,
399 F16TEXTURECUBE = 531,
400 F16TEXTURE1DARRAY = 532,
401 F16TEXTURE2DARRAY = 533,
402 F16TEXTURECUBEARRAY = 534,
403 F16TEXTUREBUFFER = 535,
404 F16TEXTURE2DMS = 536,
405 F16TEXTURE2DMSARRAY = 537,
406 SUBPASSINPUT = 538,
407 SUBPASSINPUTMS = 539,
408 ISUBPASSINPUT = 540,
409 ISUBPASSINPUTMS = 541,
410 USUBPASSINPUT = 542,
411 USUBPASSINPUTMS = 543,
412 F16SUBPASSINPUT = 544,
413 F16SUBPASSINPUTMS = 545,
414 IMAGE1D = 546,
415 IIMAGE1D = 547,
416 UIMAGE1D = 548,
417 IMAGE2D = 549,
418 IIMAGE2D = 550,
419 UIMAGE2D = 551,
420 IMAGE3D = 552,
421 IIMAGE3D = 553,
422 UIMAGE3D = 554,
423 IMAGE2DRECT = 555,
424 IIMAGE2DRECT = 556,
425 UIMAGE2DRECT = 557,
426 IMAGECUBE = 558,
427 IIMAGECUBE = 559,
428 UIMAGECUBE = 560,
429 IMAGEBUFFER = 561,
430 IIMAGEBUFFER = 562,
431 UIMAGEBUFFER = 563,
432 IMAGE1DARRAY = 564,
433 IIMAGE1DARRAY = 565,
434 UIMAGE1DARRAY = 566,
435 IMAGE2DARRAY = 567,
436 IIMAGE2DARRAY = 568,
437 UIMAGE2DARRAY = 569,
438 IMAGECUBEARRAY = 570,
439 IIMAGECUBEARRAY = 571,
440 UIMAGECUBEARRAY = 572,
441 IMAGE2DMS = 573,
442 IIMAGE2DMS = 574,
443 UIMAGE2DMS = 575,
444 IMAGE2DMSARRAY = 576,
445 IIMAGE2DMSARRAY = 577,
446 UIMAGE2DMSARRAY = 578,
447 F16IMAGE1D = 579,
448 F16IMAGE2D = 580,
449 F16IMAGE3D = 581,
450 F16IMAGE2DRECT = 582,
451 F16IMAGECUBE = 583,
452 F16IMAGE1DARRAY = 584,
453 F16IMAGE2DARRAY = 585,
454 F16IMAGECUBEARRAY = 586,
455 F16IMAGEBUFFER = 587,
456 F16IMAGE2DMS = 588,
457 F16IMAGE2DMSARRAY = 589,
458 STRUCT = 590,
459 VOID = 591,
460 WHILE = 592,
461 IDENTIFIER = 593,
462 TYPE_NAME = 594,
463 FLOATCONSTANT = 595,
464 DOUBLECONSTANT = 596,
465 INT16CONSTANT = 597,
466 UINT16CONSTANT = 598,
467 INT32CONSTANT = 599,
468 UINT32CONSTANT = 600,
469 INTCONSTANT = 601,
470 UINTCONSTANT = 602,
471 INT64CONSTANT = 603,
472 UINT64CONSTANT = 604,
473 BOOLCONSTANT = 605,
474 FLOAT16CONSTANT = 606,
475 LEFT_OP = 607,
476 RIGHT_OP = 608,
477 INC_OP = 609,
478 DEC_OP = 610,
479 LE_OP = 611,
480 GE_OP = 612,
481 EQ_OP = 613,
482 NE_OP = 614,
483 AND_OP = 615,
484 OR_OP = 616,
485 XOR_OP = 617,
486 MUL_ASSIGN = 618,
487 DIV_ASSIGN = 619,
488 ADD_ASSIGN = 620,
489 MOD_ASSIGN = 621,
490 LEFT_ASSIGN = 622,
491 RIGHT_ASSIGN = 623,
492 AND_ASSIGN = 624,
493 XOR_ASSIGN = 625,
494 OR_ASSIGN = 626,
495 SUB_ASSIGN = 627,
496 LEFT_PAREN = 628,
497 RIGHT_PAREN = 629,
498 LEFT_BRACKET = 630,
499 RIGHT_BRACKET = 631,
500 LEFT_BRACE = 632,
501 RIGHT_BRACE = 633,
502 DOT = 634,
503 COMMA = 635,
504 COLON = 636,
505 EQUAL = 637,
506 SEMICOLON = 638,
507 BANG = 639,
508 DASH = 640,
509 TILDE = 641,
510 PLUS = 642,
511 STAR = 643,
512 SLASH = 644,
513 PERCENT = 645,
514 LEFT_ANGLE = 646,
515 RIGHT_ANGLE = 647,
516 VERTICAL_BAR = 648,
517 CARET = 649,
518 AMPERSAND = 650,
519 QUESTION = 651,
520 INVARIANT = 652,
521 PRECISE = 653,
522 HIGH_PRECISION = 654,
523 MEDIUM_PRECISION = 655,
524 LOW_PRECISION = 656,
525 PRECISION = 657,
526 PACKED = 658,
527 RESOURCE = 659,
528 SUPERP = 660
529 };
530 #endif
531
532 /* Value type. */
533 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
534
535 union YYSTYPE
536 {
537 #line 70 "MachineIndependent/glslang.y" /* yacc.c:355 */
538
539 struct {
540 glslang::TSourceLoc loc;
541 union {
542 glslang::TString *string;
543 int i;
544 unsigned int u;
545 long long i64;
546 unsigned long long u64;
547 bool b;
548 double d;
549 };
550 glslang::TSymbol* symbol;
551 } lex;
552 struct {
553 glslang::TSourceLoc loc;
554 glslang::TOperator op;
555 union {
556 TIntermNode* intermNode;
557 glslang::TIntermNodePair nodePair;
558 glslang::TIntermTyped* intermTypedNode;
559 glslang::TAttributes* attributes;
560 };
561 union {
562 glslang::TPublicType type;
563 glslang::TFunction* function;
564 glslang::TParameter param;
565 glslang::TTypeLoc typeLine;
566 glslang::TTypeList* typeList;
567 glslang::TArraySizes* arraySizes;
568 glslang::TIdentifierList* identifierList;
569 };
570 } interm;
571
572 #line 573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */
573 };
574
575 typedef union YYSTYPE YYSTYPE;
576 # define YYSTYPE_IS_TRIVIAL 1
577 # define YYSTYPE_IS_DECLARED 1
578 #endif
579
580
581
582 int yyparse (glslang::TParseContext* pParseContext);
583
584 #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */
585
586 /* Copy the second part of user declarations. */
587 #line 105 "MachineIndependent/glslang.y" /* yacc.c:358 */
588
589
590 /* windows only pragma */
591 #ifdef _MSC_VER
592 #pragma warning(disable : 4065)
593 #pragma warning(disable : 4127)
594 #pragma warning(disable : 4244)
595 #endif
596
597 #define parseContext (*pParseContext)
598 #define yyerror(context, msg) context->parserError(msg)
599
600 extern int yylex(YYSTYPE*, TParseContext&);
601
602
603 #line 604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */
604
605 #ifdef short
606 # undef short
607 #endif
608
609 #ifdef YYTYPE_UINT8
610 typedef YYTYPE_UINT8 yytype_uint8;
611 #else
612 typedef unsigned char yytype_uint8;
613 #endif
614
615 #ifdef YYTYPE_INT8
616 typedef YYTYPE_INT8 yytype_int8;
617 #else
618 typedef signed char yytype_int8;
619 #endif
620
621 #ifdef YYTYPE_UINT16
622 typedef YYTYPE_UINT16 yytype_uint16;
623 #else
624 typedef unsigned short int yytype_uint16;
625 #endif
626
627 #ifdef YYTYPE_INT16
628 typedef YYTYPE_INT16 yytype_int16;
629 #else
630 typedef short int yytype_int16;
631 #endif
632
633 #ifndef YYSIZE_T
634 # ifdef __SIZE_TYPE__
635 # define YYSIZE_T __SIZE_TYPE__
636 # elif defined size_t
637 # define YYSIZE_T size_t
638 # elif ! defined YYSIZE_T
639 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
640 # define YYSIZE_T size_t
641 # else
642 # define YYSIZE_T unsigned int
643 # endif
644 #endif
645
646 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
647
648 #ifndef YY_
649 # if defined YYENABLE_NLS && YYENABLE_NLS
650 # if ENABLE_NLS
651 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
652 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
653 # endif
654 # endif
655 # ifndef YY_
656 # define YY_(Msgid) Msgid
657 # endif
658 #endif
659
660 #ifndef YY_ATTRIBUTE
661 # if (defined __GNUC__ \
662 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
663 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
664 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
665 # else
666 # define YY_ATTRIBUTE(Spec) /* empty */
667 # endif
668 #endif
669
670 #ifndef YY_ATTRIBUTE_PURE
671 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
672 #endif
673
674 #ifndef YY_ATTRIBUTE_UNUSED
675 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
676 #endif
677
678 #if !defined _Noreturn \
679 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
680 # if defined _MSC_VER && 1200 <= _MSC_VER
681 # define _Noreturn __declspec (noreturn)
682 # else
683 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
684 # endif
685 #endif
686
687 /* Suppress unused-variable warnings by "using" E. */
688 #if ! defined lint || defined __GNUC__
689 # define YYUSE(E) ((void) (E))
690 #else
691 # define YYUSE(E) /* empty */
692 #endif
693
694 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
695 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
696 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
697 _Pragma ("GCC diagnostic push") \
698 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
699 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
700 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
701 _Pragma ("GCC diagnostic pop")
702 #else
703 # define YY_INITIAL_VALUE(Value) Value
704 #endif
705 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
706 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
707 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
708 #endif
709 #ifndef YY_INITIAL_VALUE
710 # define YY_INITIAL_VALUE(Value) /* Nothing. */
711 #endif
712
713
714 #if ! defined yyoverflow || YYERROR_VERBOSE
715
716 /* The parser invokes alloca or malloc; define the necessary symbols. */
717
718 # ifdef YYSTACK_USE_ALLOCA
719 # if YYSTACK_USE_ALLOCA
720 # ifdef __GNUC__
721 # define YYSTACK_ALLOC __builtin_alloca
722 # elif defined __BUILTIN_VA_ARG_INCR
723 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
724 # elif defined _AIX
725 # define YYSTACK_ALLOC __alloca
726 # elif defined _MSC_VER
727 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
728 # define alloca _alloca
729 # else
730 # define YYSTACK_ALLOC alloca
731 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
732 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
733 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
734 # ifndef EXIT_SUCCESS
735 # define EXIT_SUCCESS 0
736 # endif
737 # endif
738 # endif
739 # endif
740 # endif
741
742 # ifdef YYSTACK_ALLOC
743 /* Pacify GCC's 'empty if-body' warning. */
744 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
745 # ifndef YYSTACK_ALLOC_MAXIMUM
746 /* The OS might guarantee only one guard page at the bottom of the stack,
747 and a page size can be as small as 4096 bytes. So we cannot safely
748 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
749 to allow for a few compiler-allocated temporary stack slots. */
750 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
751 # endif
752 # else
753 # define YYSTACK_ALLOC YYMALLOC
754 # define YYSTACK_FREE YYFREE
755 # ifndef YYSTACK_ALLOC_MAXIMUM
756 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
757 # endif
758 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
759 && ! ((defined YYMALLOC || defined malloc) \
760 && (defined YYFREE || defined free)))
761 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
762 # ifndef EXIT_SUCCESS
763 # define EXIT_SUCCESS 0
764 # endif
765 # endif
766 # ifndef YYMALLOC
767 # define YYMALLOC malloc
768 # if ! defined malloc && ! defined EXIT_SUCCESS
769 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
770 # endif
771 # endif
772 # ifndef YYFREE
773 # define YYFREE free
774 # if ! defined free && ! defined EXIT_SUCCESS
775 void free (void *); /* INFRINGES ON USER NAME SPACE */
776 # endif
777 # endif
778 # endif
779 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
780
781
782 #if (! defined yyoverflow \
783 && (! defined __cplusplus \
784 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
785
786 /* A type that is properly aligned for any stack member. */
787 union yyalloc
788 {
789 yytype_int16 yyss_alloc;
790 YYSTYPE yyvs_alloc;
791 };
792
793 /* The size of the maximum gap between one aligned stack and the next. */
794 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
795
796 /* The size of an array large to enough to hold all stacks, each with
797 N elements. */
798 # define YYSTACK_BYTES(N) \
799 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
800 + YYSTACK_GAP_MAXIMUM)
801
802 # define YYCOPY_NEEDED 1
803
804 /* Relocate STACK from its old location to the new one. The
805 local variables YYSIZE and YYSTACKSIZE give the old and new number of
806 elements in the stack, and YYPTR gives the new location of the
807 stack. Advance YYPTR to a properly aligned location for the next
808 stack. */
809 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
810 do \
811 { \
812 YYSIZE_T yynewbytes; \
813 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
814 Stack = &yyptr->Stack_alloc; \
815 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
816 yyptr += yynewbytes / sizeof (*yyptr); \
817 } \
818 while (0)
819
820 #endif
821
822 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
823 /* Copy COUNT objects from SRC to DST. The source and destination do
824 not overlap. */
825 # ifndef YYCOPY
826 # if defined __GNUC__ && 1 < __GNUC__
827 # define YYCOPY(Dst, Src, Count) \
828 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
829 # else
830 # define YYCOPY(Dst, Src, Count) \
831 do \
832 { \
833 YYSIZE_T yyi; \
834 for (yyi = 0; yyi < (Count); yyi++) \
835 (Dst)[yyi] = (Src)[yyi]; \
836 } \
837 while (0)
838 # endif
839 # endif
840 #endif /* !YYCOPY_NEEDED */
841
842 /* YYFINAL -- State number of the termination state. */
843 #define YYFINAL 381
844 /* YYLAST -- Last index in YYTABLE. */
845 #define YYLAST 9294
846
847 /* YYNTOKENS -- Number of terminals. */
848 #define YYNTOKENS 406
849 /* YYNNTS -- Number of nonterminals. */
850 #define YYNNTS 107
851 /* YYNRULES -- Number of rules. */
852 #define YYNRULES 571
853 /* YYNSTATES -- Number of states. */
854 #define YYNSTATES 712
855
856 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
857 by yylex, with out-of-bounds checking. */
858 #define YYUNDEFTOK 2
859 #define YYMAXUTOK 660
860
861 #define YYTRANSLATE(YYX) \
862 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
863
864 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
865 as returned by yylex, without out-of-bounds checking. */
866 static const yytype_uint16 yytranslate[] =
867 {
868 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
869 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
870 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
871 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
872 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
873 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
874 2, 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, 1, 2, 3, 4,
894 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
895 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
896 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
897 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
898 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
899 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
900 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
901 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
902 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
903 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
904 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
905 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
906 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
907 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
908 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
909 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
910 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
911 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
912 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
913 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
914 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
915 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
916 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
917 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
918 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
919 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
920 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
921 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
922 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
923 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
924 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
925 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
926 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
927 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
928 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
929 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
930 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
931 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
932 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
933 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
934 405
935 };
936
937 #if YYDEBUG
938 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
939 static const yytype_uint16 yyrline[] =
940 {
941 0, 294, 294, 300, 303, 307, 311, 314, 318, 322,
942 326, 330, 334, 337, 341, 345, 348, 356, 359, 362,
943 365, 368, 373, 381, 388, 395, 401, 405, 412, 415,
944 421, 428, 438, 446, 451, 478, 486, 492, 496, 500,
945 520, 521, 522, 523, 529, 530, 535, 540, 549, 550,
946 555, 563, 564, 570, 579, 580, 585, 590, 595, 603,
947 604, 612, 623, 624, 633, 634, 643, 644, 653, 654,
948 662, 663, 671, 672, 680, 681, 681, 699, 700, 716,
949 720, 724, 728, 733, 737, 741, 745, 749, 753, 757,
950 764, 767, 778, 785, 790, 795, 803, 807, 811, 815,
951 820, 825, 834, 834, 845, 849, 856, 863, 866, 873,
952 881, 901, 924, 939, 964, 975, 985, 995, 1005, 1014,
953 1017, 1021, 1025, 1030, 1038, 1043, 1048, 1053, 1058, 1067,
954 1078, 1105, 1114, 1121, 1128, 1139, 1148, 1158, 1170, 1179,
955 1191, 1197, 1200, 1207, 1211, 1215, 1223, 1232, 1235, 1246,
956 1249, 1252, 1256, 1260, 1264, 1268, 1274, 1278, 1290, 1304,
957 1309, 1315, 1321, 1328, 1334, 1339, 1344, 1349, 1359, 1369,
958 1379, 1389, 1398, 1410, 1414, 1419, 1424, 1429, 1434, 1439,
959 1443, 1447, 1451, 1455, 1461, 1470, 1477, 1480, 1488, 1492,
960 1501, 1506, 1514, 1518, 1528, 1532, 1536, 1541, 1546, 1551,
961 1556, 1560, 1565, 1570, 1575, 1580, 1585, 1590, 1595, 1600,
962 1605, 1609, 1614, 1619, 1624, 1630, 1636, 1642, 1648, 1654,
963 1660, 1666, 1672, 1678, 1684, 1690, 1696, 1701, 1706, 1711,
964 1716, 1721, 1726, 1732, 1738, 1744, 1750, 1756, 1762, 1768,
965 1774, 1780, 1786, 1792, 1798, 1804, 1810, 1816, 1822, 1828,
966 1834, 1840, 1846, 1852, 1858, 1864, 1870, 1876, 1882, 1888,
967 1893, 1898, 1903, 1908, 1913, 1918, 1923, 1928, 1933, 1938,
968 1943, 1948, 1954, 1960, 1966, 1972, 1978, 1984, 1990, 1996,
969 2002, 2008, 2014, 2020, 2026, 2032, 2038, 2044, 2050, 2056,
970 2062, 2068, 2074, 2080, 2086, 2092, 2098, 2104, 2110, 2116,
971 2122, 2128, 2134, 2140, 2146, 2152, 2158, 2164, 2170, 2176,
972 2182, 2188, 2194, 2200, 2206, 2212, 2218, 2224, 2230, 2236,
973 2242, 2247, 2252, 2257, 2262, 2267, 2272, 2277, 2282, 2287,
974 2292, 2297, 2302, 2307, 2312, 2320, 2328, 2336, 2344, 2352,
975 2360, 2368, 2376, 2384, 2392, 2400, 2408, 2416, 2421, 2426,
976 2431, 2436, 2441, 2446, 2451, 2456, 2461, 2466, 2471, 2476,
977 2481, 2486, 2491, 2496, 2504, 2512, 2517, 2522, 2527, 2535,
978 2540, 2545, 2550, 2558, 2563, 2568, 2573, 2581, 2586, 2591,
979 2596, 2601, 2606, 2614, 2619, 2627, 2632, 2640, 2645, 2653,
980 2658, 2666, 2671, 2679, 2684, 2692, 2697, 2702, 2707, 2712,
981 2717, 2722, 2727, 2732, 2737, 2742, 2747, 2752, 2757, 2762,
982 2767, 2775, 2780, 2785, 2790, 2798, 2803, 2808, 2813, 2821,
983 2826, 2831, 2836, 2844, 2849, 2854, 2859, 2867, 2872, 2877,
984 2882, 2890, 2895, 2900, 2905, 2913, 2918, 2923, 2928, 2936,
985 2941, 2946, 2951, 2959, 2964, 2969, 2974, 2982, 2987, 2992,
986 2997, 3005, 3010, 3015, 3020, 3028, 3033, 3038, 3043, 3051,
987 3056, 3061, 3066, 3074, 3079, 3084, 3089, 3097, 3102, 3107,
988 3113, 3119, 3125, 3134, 3143, 3149, 3155, 3161, 3167, 3172,
989 3188, 3193, 3198, 3206, 3206, 3217, 3217, 3227, 3230, 3243,
990 3265, 3292, 3296, 3302, 3307, 3318, 3321, 3327, 3336, 3339,
991 3345, 3349, 3350, 3356, 3357, 3358, 3359, 3360, 3361, 3362,
992 3366, 3367, 3371, 3367, 3383, 3384, 3388, 3388, 3395, 3395,
993 3409, 3412, 3420, 3428, 3439, 3440, 3444, 3447, 3453, 3460,
994 3464, 3472, 3476, 3489, 3492, 3498, 3498, 3518, 3521, 3527,
995 3539, 3551, 3554, 3560, 3560, 3575, 3575, 3591, 3591, 3612,
996 3615, 3621, 3624, 3630, 3634, 3641, 3646, 3651, 3658, 3661,
997 3670, 3674, 3683, 3686, 3689, 3697, 3697, 3719, 3725, 3728,
998 3733, 3736
999 };
1000 #endif
1001
1002 #if YYDEBUG || YYERROR_VERBOSE || 1
1003 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1004 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1005 static const char *const yytname[] =
1006 {
1007 "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "FLOAT16_T",
1008 "FLOAT", "FLOAT32_T", "DOUBLE", "FLOAT64_T", "CONST", "BOOL", "INT",
1009 "UINT", "INT64_T", "UINT64_T", "INT32_T", "UINT32_T", "INT16_T",
1010 "UINT16_T", "INT8_T", "UINT8_T", "BREAK", "CONTINUE", "DO", "ELSE",
1011 "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT",
1012 "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4",
1013 "UVEC2", "UVEC3", "UVEC4", "I64VEC2", "I64VEC3", "I64VEC4", "U64VEC2",
1014 "U64VEC3", "U64VEC4", "I32VEC2", "I32VEC3", "I32VEC4", "U32VEC2",
1015 "U32VEC3", "U32VEC4", "I16VEC2", "I16VEC3", "I16VEC4", "U16VEC2",
1016 "U16VEC3", "U16VEC4", "I8VEC2", "I8VEC3", "I8VEC4", "U8VEC2", "U8VEC3",
1017 "U8VEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID",
1018 "IN", "OUT", "INOUT", "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED",
1019 "NONUNIFORM", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", "CALLDATANV",
1020 "CALLDATAINNV", "COHERENT", "VOLATILE", "RESTRICT", "READONLY",
1021 "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT",
1022 "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", "DVEC2", "DVEC3",
1023 "DVEC4", "DMAT2", "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4",
1024 "F16MAT2", "F16MAT3", "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4",
1025 "F32MAT2", "F32MAT3", "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4",
1026 "F64MAT2", "F64MAT3", "F64MAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH",
1027 "LAYOUT", "EXPLICITINTERPAMD", "PERVERTEXNV", "PERPRIMITIVENV",
1028 "PERVIEWNV", "PERTASKNV", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2",
1029 "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3",
1030 "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3",
1031 "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2",
1032 "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4",
1033 "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", "F32MAT3X3",
1034 "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2",
1035 "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4",
1036 "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV",
1037 "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW",
1038 "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER1DARRAY",
1039 "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", "SAMPLER2DARRAYSHADOW",
1040 "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE",
1041 "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", "USAMPLER2D",
1042 "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", "USAMPLER2DARRAY",
1043 "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT",
1044 "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER",
1045 "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY",
1046 "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS",
1047 "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY",
1048 "SAMPLEREXTERNALOES", "F16SAMPLER1D", "F16SAMPLER2D", "F16SAMPLER3D",
1049 "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY",
1050 "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER",
1051 "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW",
1052 "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW",
1053 "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW",
1054 "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER",
1055 "SAMPLERSHADOW", "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE",
1056 "TEXTURE1DARRAY", "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D",
1057 "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY",
1058 "UTEXTURE1D", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE",
1059 "UTEXTURE1DARRAY", "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT",
1060 "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER",
1061 "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY",
1062 "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS", "TEXTURE2DMSARRAY",
1063 "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D",
1064 "F16TEXTURE3D", "F16TEXTURE2DRECT", "F16TEXTURECUBE",
1065 "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY",
1066 "F16TEXTUREBUFFER", "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY",
1067 "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS",
1068 "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT",
1069 "F16SUBPASSINPUTMS", "IMAGE1D", "IIMAGE1D", "UIMAGE1D", "IMAGE2D",
1070 "IIMAGE2D", "UIMAGE2D", "IMAGE3D", "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT",
1071 "IIMAGE2DRECT", "UIMAGE2DRECT", "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE",
1072 "IMAGEBUFFER", "IIMAGEBUFFER", "UIMAGEBUFFER", "IMAGE1DARRAY",
1073 "IIMAGE1DARRAY", "UIMAGE1DARRAY", "IMAGE2DARRAY", "IIMAGE2DARRAY",
1074 "UIMAGE2DARRAY", "IMAGECUBEARRAY", "IIMAGECUBEARRAY", "UIMAGECUBEARRAY",
1075 "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS", "IMAGE2DMSARRAY",
1076 "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "F16IMAGE1D", "F16IMAGE2D",
1077 "F16IMAGE3D", "F16IMAGE2DRECT", "F16IMAGECUBE", "F16IMAGE1DARRAY",
1078 "F16IMAGE2DARRAY", "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS",
1079 "F16IMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER",
1080 "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", "INT16CONSTANT",
1081 "UINT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INTCONSTANT",
1082 "UINTCONSTANT", "INT64CONSTANT", "UINT64CONSTANT", "BOOLCONSTANT",
1083 "FLOAT16CONSTANT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP",
1084 "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN",
1085 "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
1086 "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN",
1087 "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE",
1088 "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG",
1089 "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE",
1090 "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION",
1091 "INVARIANT", "PRECISE", "HIGH_PRECISION", "MEDIUM_PRECISION",
1092 "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", "$accept",
1093 "variable_identifier", "primary_expression", "postfix_expression",
1094 "integer_expression", "function_call", "function_call_or_method",
1095 "function_call_generic", "function_call_header_no_parameters",
1096 "function_call_header_with_parameters", "function_call_header",
1097 "function_identifier", "unary_expression", "unary_operator",
1098 "multiplicative_expression", "additive_expression", "shift_expression",
1099 "relational_expression", "equality_expression", "and_expression",
1100 "exclusive_or_expression", "inclusive_or_expression",
1101 "logical_and_expression", "logical_xor_expression",
1102 "logical_or_expression", "conditional_expression", "$@1",
1103 "assignment_expression", "assignment_operator", "expression",
1104 "constant_expression", "declaration", "block_structure", "$@2",
1105 "identifier_list", "function_prototype", "function_declarator",
1106 "function_header_with_parameters", "function_header",
1107 "parameter_declarator", "parameter_declaration",
1108 "parameter_type_specifier", "init_declarator_list", "single_declaration",
1109 "fully_specified_type", "invariant_qualifier", "interpolation_qualifier",
1110 "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id",
1111 "precise_qualifier", "type_qualifier", "single_type_qualifier",
1112 "storage_qualifier", "non_uniform_qualifier", "type_name_list",
1113 "type_specifier", "array_specifier", "type_specifier_nonarray",
1114 "precision_qualifier", "struct_specifier", "$@3", "$@4",
1115 "struct_declaration_list", "struct_declaration",
1116 "struct_declarator_list", "struct_declarator", "initializer",
1117 "initializer_list", "declaration_statement", "statement",
1118 "simple_statement", "compound_statement", "$@5", "$@6",
1119 "statement_no_new_scope", "statement_scoped", "$@7", "$@8",
1120 "compound_statement_no_new_scope", "statement_list",
1121 "expression_statement", "selection_statement",
1122 "selection_statement_nonattributed", "selection_rest_statement",
1123 "condition", "switch_statement", "switch_statement_nonattributed", "$@9",
1124 "switch_statement_list", "case_label", "iteration_statement",
1125 "iteration_statement_nonattributed", "$@10", "$@11", "$@12",
1126 "for_init_statement", "conditionopt", "for_rest_statement",
1127 "jump_statement", "translation_unit", "external_declaration",
1128 "function_definition", "$@13", "attribute", "attribute_list",
1129 "single_attribute", YY_NULLPTR
1130 };
1131 #endif
1132
1133 # ifdef YYPRINT
1134 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1135 (internal) symbol number NUM (which must be that of a token). */
1136 static const yytype_uint16 yytoknum[] =
1137 {
1138 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1139 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1140 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1141 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1142 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1143 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1144 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1145 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1146 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1147 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1148 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1149 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1150 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1151 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
1152 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
1153 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
1154 415, 416, 417, 418, 419, 420, 421, 422, 423, 424,
1155 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
1156 435, 436, 437, 438, 439, 440, 441, 442, 443, 444,
1157 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,
1158 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
1159 465, 466, 467, 468, 469, 470, 471, 472, 473, 474,
1160 475, 476, 477, 478, 479, 480, 481, 482, 483, 484,
1161 485, 486, 487, 488, 489, 490, 491, 492, 493, 494,
1162 495, 496, 497, 498, 499, 500, 501, 502, 503, 504,
1163 505, 506, 507, 508, 509, 510, 511, 512, 513, 514,
1164 515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
1165 525, 526, 527, 528, 529, 530, 531, 532, 533, 534,
1166 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
1167 545, 546, 547, 548, 549, 550, 551, 552, 553, 554,
1168 555, 556, 557, 558, 559, 560, 561, 562, 563, 564,
1169 565, 566, 567, 568, 569, 570, 571, 572, 573, 574,
1170 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,
1171 585, 586, 587, 588, 589, 590, 591, 592, 593, 594,
1172 595, 596, 597, 598, 599, 600, 601, 602, 603, 604,
1173 605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
1174 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
1175 625, 626, 627, 628, 629, 630, 631, 632, 633, 634,
1176 635, 636, 637, 638, 639, 640, 641, 642, 643, 644,
1177 645, 646, 647, 648, 649, 650, 651, 652, 653, 654,
1178 655, 656, 657, 658, 659, 660
1179 };
1180 # endif
1181
1182 #define YYPACT_NINF -649
1183
1184 #define yypact_value_is_default(Yystate) \
1185 (!!((Yystate) == (-649)))
1186
1187 #define YYTABLE_NINF -517
1188
1189 #define yytable_value_is_error(Yytable_value) \
1190 0
1191
1192 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1193 STATE-NUM. */
1194 static const yytype_int16 yypact[] =
1195 {
1196 3511, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1197 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1198 -326, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1199 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1200 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1201 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1202 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1203 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1204 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1205 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1206 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1207 -649, -649, -310, -649, -649, -649, -649, -649, -649, -649,
1208 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1209 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1210 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1211 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1212 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1213 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1214 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1215 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1216 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1217 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1218 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1219 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1220 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1221 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1222 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1223 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1224 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1225 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1226 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1227 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1228 -649, -649, -316, -649, -649, -649, -649, -649, -649, -649,
1229 -649, -256, -649, -317, -357, -305, -269, 5906, -315, -649,
1230 -225, -649, -649, -649, -649, 4310, -649, -649, -649, -649,
1231 -234, -649, -649, 711, -649, -649, -204, -69, -222, -649,
1232 8955, -335, -649, -649, -218, -649, 5906, -649, -649, -649,
1233 5906, -170, -169, -649, -339, -303, -649, -649, -649, 6657,
1234 -205, -649, -649, -649, -307, -649, -211, -302, -649, -649,
1235 5906, -210, -649, -321, 1111, -649, -649, -649, -649, -234,
1236 -340, -649, 7040, -325, -649, -166, -649, -292, -649, -649,
1237 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1238 -649, 8189, 8189, 8189, -649, -649, -649, -649, -649, -649,
1239 -649, -324, -649, -649, -649, -200, -298, 8572, -198, -649,
1240 8189, -242, -278, -314, -333, -209, -219, -217, -215, -180,
1241 -181, -336, -194, -649, -649, 7423, -649, -155, 8189, -649,
1242 -69, 5906, 5906, -154, 4709, -649, -649, -649, -197, -195,
1243 -649, -188, -184, -193, 7806, -179, 8189, -189, -178, -182,
1244 -177, -649, -649, -267, -649, -649, -252, -649, -357, -176,
1245 -173, -649, -649, -649, -649, 1511, -649, -649, -649, -649,
1246 -649, -649, -649, -649, -649, -19, -205, 7040, -311, 7040,
1247 -649, -649, 7040, 5906, -649, -142, -649, -649, -649, -293,
1248 -649, -649, 8189, -136, -649, -649, 8189, -171, -649, -649,
1249 -649, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189,
1250 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189,
1251 -649, -649, -649, -172, -649, -649, -649, -649, 5108, -154,
1252 -234, -251, -649, -649, -649, -649, -649, 1911, -649, 8189,
1253 -649, -649, -245, 8189, -228, -649, -649, -133, -649, 1911,
1254 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1255 -649, 8189, 8189, -649, -649, -649, -649, -649, -649, -649,
1256 7040, -649, -285, -649, 5507, -649, -649, -168, -165, -649,
1257 -649, -649, -649, -649, -242, -242, -278, -278, -314, -314,
1258 -314, -314, -333, -333, -209, -219, -217, -215, -180, -181,
1259 8189, -649, -649, -241, -205, -154, -649, -128, 3111, -290,
1260 -649, -268, -649, 3911, -163, -297, -649, 1911, -649, -649,
1261 -649, -649, 6274, -649, -649, -223, -649, -649, -162, -649,
1262 -649, 3911, -161, -649, -165, -126, 5906, -160, 8189, -159,
1263 -133, -158, -649, -649, 8189, 8189, -649, -164, -156, 196,
1264 -151, 2711, -649, -131, -135, 2311, -152, -649, -649, -649,
1265 -649, -254, 8189, 2311, -161, -649, -649, 1911, 7040, -649,
1266 -649, -649, -649, -134, -165, -649, -649, 1911, -127, -649,
1267 -649, -649
1268 };
1269
1270 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1271 Performed when YYTABLE does not specify something else to do. Zero
1272 means the default is an error. */
1273 static const yytype_uint16 yydefact[] =
1274 {
1275 0, 157, 158, 197, 195, 198, 196, 199, 156, 210,
1276 200, 201, 208, 209, 206, 207, 204, 205, 202, 203,
1277 183, 226, 227, 228, 229, 230, 231, 244, 245, 246,
1278 241, 242, 243, 256, 257, 258, 238, 239, 240, 253,
1279 254, 255, 235, 236, 237, 250, 251, 252, 232, 233,
1280 234, 247, 248, 249, 211, 212, 213, 259, 260, 261,
1281 162, 160, 161, 159, 165, 163, 164, 166, 172, 185,
1282 168, 169, 167, 170, 171, 173, 179, 180, 181, 182,
1283 174, 175, 176, 177, 178, 214, 215, 216, 271, 272,
1284 273, 217, 218, 219, 283, 284, 285, 220, 221, 222,
1285 295, 296, 297, 223, 224, 225, 307, 308, 309, 134,
1286 133, 132, 0, 135, 136, 137, 138, 139, 262, 263,
1287 264, 265, 266, 267, 268, 269, 270, 274, 275, 276,
1288 277, 278, 279, 280, 281, 282, 286, 287, 288, 289,
1289 290, 291, 292, 293, 294, 298, 299, 300, 301, 302,
1290 303, 304, 305, 306, 310, 311, 312, 313, 314, 315,
1291 316, 317, 318, 320, 319, 321, 322, 323, 324, 325,
1292 326, 327, 328, 329, 330, 331, 347, 348, 349, 350,
1293 351, 352, 354, 355, 356, 357, 358, 359, 361, 362,
1294 365, 366, 367, 369, 370, 332, 333, 353, 360, 371,
1295 373, 374, 375, 377, 378, 469, 334, 335, 336, 363,
1296 337, 341, 342, 345, 368, 372, 376, 338, 339, 343,
1297 344, 364, 340, 346, 379, 380, 381, 383, 385, 387,
1298 389, 391, 395, 396, 397, 398, 399, 400, 402, 403,
1299 404, 405, 406, 407, 409, 411, 412, 413, 415, 416,
1300 393, 401, 408, 417, 419, 420, 421, 423, 424, 382,
1301 384, 386, 410, 388, 390, 392, 394, 414, 418, 422,
1302 470, 471, 474, 475, 476, 477, 472, 473, 425, 427,
1303 428, 429, 431, 432, 433, 435, 436, 437, 439, 440,
1304 441, 443, 444, 445, 447, 448, 449, 451, 452, 453,
1305 455, 456, 457, 459, 460, 461, 463, 464, 465, 467,
1306 468, 426, 430, 434, 438, 442, 450, 454, 458, 446,
1307 462, 466, 0, 194, 479, 564, 131, 146, 480, 481,
1308 482, 0, 563, 0, 565, 0, 108, 107, 0, 119,
1309 124, 153, 152, 150, 154, 0, 147, 149, 155, 129,
1310 188, 151, 478, 0, 560, 562, 0, 0, 0, 485,
1311 0, 0, 96, 93, 0, 106, 0, 115, 109, 117,
1312 0, 118, 0, 94, 125, 0, 99, 148, 130, 0,
1313 189, 1, 561, 186, 0, 145, 143, 0, 141, 483,
1314 0, 0, 97, 0, 0, 566, 110, 114, 116, 112,
1315 120, 111, 0, 126, 102, 0, 100, 0, 2, 12,
1316 13, 10, 11, 4, 5, 6, 7, 8, 9, 15,
1317 14, 0, 0, 0, 190, 42, 41, 43, 40, 3,
1318 17, 36, 19, 24, 25, 0, 0, 29, 0, 44,
1319 0, 48, 51, 54, 59, 62, 64, 66, 68, 70,
1320 72, 74, 0, 35, 33, 0, 184, 0, 0, 140,
1321 0, 0, 0, 0, 0, 487, 95, 98, 0, 0,
1322 545, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1323 511, 520, 524, 44, 77, 90, 0, 500, 0, 155,
1324 129, 503, 522, 502, 501, 0, 504, 505, 526, 506,
1325 533, 507, 508, 541, 509, 0, 113, 0, 121, 0,
1326 495, 128, 0, 0, 104, 0, 101, 37, 38, 0,
1327 21, 22, 0, 0, 27, 26, 0, 194, 30, 32,
1328 39, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1329 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1330 75, 191, 192, 0, 187, 92, 144, 142, 0, 0,
1331 493, 0, 491, 486, 488, 556, 555, 0, 547, 0,
1332 559, 557, 0, 0, 0, 540, 543, 0, 510, 0,
1333 80, 81, 83, 82, 85, 86, 87, 88, 89, 84,
1334 79, 0, 0, 525, 521, 523, 527, 534, 542, 123,
1335 0, 498, 0, 127, 0, 105, 16, 0, 23, 20,
1336 31, 45, 46, 47, 50, 49, 52, 53, 57, 58,
1337 55, 56, 60, 61, 63, 65, 67, 69, 71, 73,
1338 0, 193, 484, 0, 494, 0, 489, 0, 0, 0,
1339 558, 0, 539, 0, 570, 0, 568, 512, 78, 91,
1340 122, 496, 0, 103, 18, 0, 490, 492, 0, 550,
1341 549, 552, 518, 535, 531, 0, 0, 0, 0, 0,
1342 0, 0, 497, 499, 0, 0, 551, 0, 0, 530,
1343 0, 0, 528, 0, 0, 0, 0, 567, 569, 513,
1344 76, 0, 553, 0, 518, 517, 519, 537, 0, 515,
1345 544, 514, 571, 0, 554, 548, 529, 538, 0, 532,
1346 546, 536
1347 };
1348
1349 /* YYPGOTO[NTERM-NUM]. */
1350 static const yytype_int16 yypgoto[] =
1351 {
1352 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649,
1353 -649, -649, -304, -649, -373, -370, -416, -379, -294, -322,
1354 -291, -295, -288, -296, -649, -369, -649, -393, -649, -382,
1355 -414, 1, -649, -649, -649, 2, -649, -649, -649, -114,
1356 -109, -112, -649, -649, -615, -649, -649, -649, -649, -196,
1357 -649, -334, -341, -649, 6, -649, 0, -347, -649, -68,
1358 -649, -649, -649, -443, -448, -287, -368, -492, -649, -376,
1359 -482, -648, -415, -649, -649, -427, -426, -649, -649, -93,
1360 -560, -365, -649, -231, -649, -386, -649, -229, -649, -649,
1361 -649, -649, -227, -649, -649, -649, -649, -649, -649, -649,
1362 -649, -76, -649, -649, -649, -649, -390
1363 };
1364
1365 /* YYDEFGOTO[NTERM-NUM]. */
1366 static const yytype_int16 yydefgoto[] =
1367 {
1368 -1, 429, 430, 431, 607, 432, 433, 434, 435, 436,
1369 437, 438, 483, 440, 441, 442, 443, 444, 445, 446,
1370 447, 448, 449, 450, 451, 484, 630, 485, 591, 486,
1371 556, 487, 333, 513, 407, 488, 335, 336, 337, 367,
1372 368, 369, 338, 339, 340, 341, 342, 343, 387, 388,
1373 344, 345, 346, 347, 453, 384, 454, 380, 350, 351,
1374 352, 461, 390, 464, 465, 561, 562, 511, 602, 491,
1375 492, 493, 494, 579, 671, 700, 679, 680, 681, 701,
1376 495, 496, 497, 498, 682, 667, 499, 500, 683, 708,
1377 501, 502, 503, 643, 567, 638, 661, 677, 678, 504,
1378 353, 354, 355, 364, 505, 645, 646
1379 };
1380
1381 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1382 positive, shift that token. If negative, reduce the rule whose
1383 number is the opposite. If YYTABLE_NINF, syntax error. */
1384 static const yytype_int16 yytable[] =
1385 {
1386 349, 332, 334, 370, 377, 470, 348, 471, 472, 510,
1387 452, 475, 385, 595, 393, 599, 564, 601, 558, 647,
1388 603, 361, 358, 538, 539, 549, 363, 403, 665, 377,
1389 520, 521, 370, 696, 401, 379, 379, 699, 536, 537,
1390 379, 519, 507, 402, 528, 699, 665, 356, 392, -34,
1391 455, 522, 506, 508, 455, 523, 462, 512, 540, 541,
1392 550, 359, 467, 357, 455, 372, 362, 456, 373, 365,
1393 604, 600, 459, 457, 404, 439, 525, 405, 460, 669,
1394 406, 606, 526, 670, 662, 637, 553, 592, 515, 555,
1395 592, 516, 572, 651, 574, 652, 580, 581, 582, 583,
1396 584, 585, 586, 587, 588, 589, 663, 534, 650, 535,
1397 564, 366, 592, 374, 510, 590, 510, 517, 518, 510,
1398 703, 377, 618, 619, 620, 621, 592, 462, 592, 635,
1399 462, 593, 636, 610, 383, 592, 530, 707, 640, 635,
1400 608, 379, 656, 328, 329, 330, 531, 532, 533, 542,
1401 543, 439, 592, 642, 439, 389, 564, 592, 674, 394,
1402 673, 614, 615, 622, 623, 595, 616, 617, 399, 400,
1403 455, 458, 514, 466, 524, 529, 544, 545, 546, 462,
1404 547, 548, 551, 554, 560, 568, 565, 639, 566, 569,
1405 570, 641, 575, 577, 573, 576, 605, -35, 648, 649,
1406 -33, 578, 609, -28, 631, 644, 709, 510, 654, 658,
1407 668, 675, 684, 634, 685, 592, -516, 687, 693, 692,
1408 689, 694, 702, 625, 462, 595, 480, 611, 612, 613,
1409 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
1410 439, 439, 439, 439, 439, 439, 697, 698, 655, 710,
1411 624, 711, 627, 629, 686, 626, 397, 396, 398, 510,
1412 628, 664, 659, 360, 557, 695, 705, 657, 706, 386,
1413 462, 395, 633, 660, 596, 676, 597, 382, 598, 664,
1414 688, 690, 0, 0, 0, 0, 0, 0, 0, 0,
1415 0, 0, 0, 691, 0, 0, 0, 0, 0, 555,
1416 0, 0, 0, 0, 0, 510, 0, 0, 0, 666,
1417 704, 0, 0, 0, 0, 0, 0, 0, 478, 0,
1418 0, 0, 0, 0, 0, 377, 0, 666, 0, 0,
1419 0, 0, 0, 0, 0, 0, 0, 371, 0, 0,
1420 0, 0, 0, 348, 0, 378, 0, 0, 0, 0,
1421 0, 348, 0, 349, 332, 334, 0, 0, 0, 348,
1422 391, 0, 0, 0, 439, 0, 371, 0, 0, 0,
1423 371, 0, 348, 0, 0, 0, 348, 0, 0, 0,
1424 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1425 463, 0, 0, 0, 490, 0, 348, 0, 0, 0,
1426 489, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1427 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1428 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1429 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1430 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1431 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1432 0, 463, 559, 0, 463, 0, 0, 348, 348, 0,
1433 348, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1434 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1435 0, 0, 0, 0, 0, 490, 0, 0, 0, 0,
1436 0, 489, 0, 0, 0, 0, 0, 0, 0, 0,
1437 0, 0, 0, 463, 0, 0, 0, 0, 0, 348,
1438 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1439 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1440 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1441 0, 0, 0, 0, 0, 0, 0, 0, 463, 0,
1442 0, 0, 0, 0, 348, 0, 0, 490, 0, 0,
1443 0, 0, 0, 489, 0, 0, 0, 0, 0, 490,
1444 0, 0, 0, 0, 0, 489, 0, 0, 0, 0,
1445 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1446 0, 0, 0, 0, 463, 0, 0, 0, 0, 0,
1447 348, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1449 0, 0, 0, 0, 0, 0, 0, 0, 490, 0,
1450 0, 0, 0, 490, 489, 0, 0, 490, 0, 489,
1451 0, 0, 0, 489, 0, 0, 0, 0, 0, 0,
1452 0, 490, 0, 0, 0, 0, 378, 489, 0, 0,
1453 0, 0, 348, 0, 0, 0, 0, 0, 0, 0,
1454 0, 490, 0, 0, 0, 490, 0, 489, 0, 0,
1455 0, 489, 0, 490, 0, 0, 0, 490, 0, 489,
1456 0, 0, 0, 489, 0, 0, 0, 490, 0, 0,
1457 0, 381, 0, 489, 1, 2, 3, 4, 5, 6,
1458 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1459 17, 18, 19, 0, 0, 0, 0, 0, 0, 0,
1460 0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
1461 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1462 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1463 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1464 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1465 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1466 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1467 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1468 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1469 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1470 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1471 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1472 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1473 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1474 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1475 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1476 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1477 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1478 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1479 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1480 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1481 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1482 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1483 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1484 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1485 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1486 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1487 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1488 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1489 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1490 316, 317, 318, 319, 320, 321, 322, 323, 0, 0,
1491 324, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1492 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1493 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1494 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1495 0, 0, 0, 0, 325, 0, 0, 0, 0, 0,
1496 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1497 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1498 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1499 17, 18, 19, 468, 469, 470, 0, 471, 472, 473,
1500 474, 475, 476, 477, 20, 21, 22, 23, 24, 25,
1501 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1502 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1503 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1504 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1505 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1506 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1507 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1508 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1509 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1510 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1511 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1512 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1513 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1514 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1515 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1516 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1517 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1518 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1519 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1520 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1521 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1522 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1523 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1524 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1525 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1526 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1527 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1528 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1529 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1530 316, 317, 318, 319, 320, 321, 322, 323, 478, 408,
1531 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1532 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1533 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1534 0, 0, 0, 0, 423, 0, 479, 0, 480, 481,
1535 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1536 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1537 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1538 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1539 17, 18, 19, 468, 469, 470, 0, 471, 472, 473,
1540 474, 475, 476, 477, 20, 21, 22, 23, 24, 25,
1541 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1542 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1543 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1544 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1545 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1546 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1547 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1548 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1549 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1550 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1551 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1552 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1553 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1554 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1555 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1556 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1557 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1558 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1559 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1560 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1561 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1562 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1563 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1564 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1565 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1566 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1567 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1568 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1569 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1570 316, 317, 318, 319, 320, 321, 322, 323, 478, 408,
1571 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1572 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1573 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1574 0, 0, 0, 0, 423, 0, 479, 0, 480, 594,
1575 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1576 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1577 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1578 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1579 17, 18, 19, 468, 469, 470, 0, 471, 472, 473,
1580 474, 475, 476, 477, 20, 21, 22, 23, 24, 25,
1581 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1582 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1583 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1584 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1585 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1586 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1587 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1588 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1589 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1590 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1591 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1592 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1593 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1594 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1595 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1596 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1597 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1598 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1599 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1600 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1601 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1602 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1603 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1604 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1605 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1606 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1607 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1608 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1609 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1610 316, 317, 318, 319, 320, 321, 322, 323, 478, 408,
1611 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1612 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1613 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1614 0, 0, 0, 0, 423, 0, 479, 0, 480, 0,
1615 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1616 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1617 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1618 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1619 17, 18, 19, 468, 469, 470, 0, 471, 472, 473,
1620 474, 475, 476, 477, 20, 21, 22, 23, 24, 25,
1621 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1622 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1623 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1624 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1625 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1626 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1627 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1628 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1629 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1630 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1631 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1632 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1633 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1634 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1635 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1636 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1637 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1638 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1639 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1640 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1641 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1642 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1643 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1644 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1645 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1646 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1647 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1648 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1649 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1650 316, 317, 318, 319, 320, 321, 322, 323, 478, 408,
1651 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1652 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1653 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1654 0, 0, 0, 0, 423, 0, 479, 0, 394, 0,
1655 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1656 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1657 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1658 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1659 17, 18, 19, 468, 469, 470, 0, 471, 472, 473,
1660 474, 475, 476, 477, 20, 21, 22, 23, 24, 25,
1661 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1662 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1663 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1664 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1665 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1666 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1667 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1668 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1669 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1670 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1671 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1672 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1673 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1674 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1675 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1676 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1677 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1678 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1679 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1680 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1681 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1682 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1683 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1684 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1685 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1686 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1687 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1688 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1689 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1690 316, 317, 318, 319, 320, 321, 322, 323, 478, 408,
1691 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1692 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694 0, 0, 0, 0, 423, 0, 479, 0, 0, 0,
1695 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1696 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1697 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1698 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1699 17, 18, 19, 0, 0, 0, 0, 0, 0, 0,
1700 0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
1701 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1702 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1703 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1704 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1705 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1706 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1707 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1708 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1709 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1710 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1711 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1712 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1713 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1714 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1715 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1716 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1717 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1718 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1719 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1720 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1721 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1722 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1723 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1724 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1725 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1726 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1727 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1728 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1729 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1730 316, 317, 318, 319, 320, 321, 322, 323, 0, 408,
1731 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1732 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1733 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1734 0, 0, 0, 0, 423, 0, 0, 0, 0, 0,
1735 0, 0, 0, 0, 482, 425, 426, 427, 428, 0,
1736 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1737 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1738 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1739 17, 18, 19, 0, 0, 0, 0, 0, 0, 0,
1740 0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
1741 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1742 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1743 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1744 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1745 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1746 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1747 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1748 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1749 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1750 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1751 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1752 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1753 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1754 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1755 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1756 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1757 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1758 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1759 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1760 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1761 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1762 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1763 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1764 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1765 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1766 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1767 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1768 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1769 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1770 316, 317, 318, 319, 320, 321, 322, 323, 0, 0,
1771 324, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1772 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1774 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1775 0, 0, 0, 0, 325, 0, 0, 0, 0, 0,
1776 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1777 328, 329, 330, 331, 1, 2, 3, 4, 5, 6,
1778 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1779 17, 18, 19, 0, 0, 0, 0, 0, 0, 0,
1780 0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
1781 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1782 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1783 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1784 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1785 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1786 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1787 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1788 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1789 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1790 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1791 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1792 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1793 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
1794 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1795 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
1796 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1797 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1798 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
1799 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
1800 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1801 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1802 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
1803 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
1804 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
1805 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
1806 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
1807 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
1808 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
1809 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
1810 316, 317, 318, 319, 320, 321, 322, 323, 0, 408,
1811 324, 409, 410, 411, 412, 413, 414, 415, 416, 417,
1812 418, 419, 420, 0, 0, 421, 422, 0, 0, 0,
1813 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1814 0, 0, 0, 0, 423, 0, 0, 0, 0, 0,
1815 0, 0, 0, 0, 0, 425, 426, 427, 428, 0,
1816 0, 0, 0, 0, 0, 0, 0, 0, 326, 327,
1817 328, 329, 330, 1, 2, 3, 4, 5, 6, 7,
1818 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1819 18, 19, 0, 0, 0, 0, 0, 0, 0, 0,
1820 0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
1821 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1822 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1823 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1824 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1825 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1826 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1827 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
1828 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
1829 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
1830 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
1831 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
1832 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
1833 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
1834 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
1835 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
1836 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
1837 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
1838 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
1839 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
1840 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
1841 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1842 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
1843 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
1844 257, 258, 259, 260, 261, 262, 263, 264, 265, 266,
1845 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
1846 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
1847 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
1848 297, 298, 299, 300, 301, 302, 303, 304, 305, 306,
1849 307, 308, 309, 310, 311, 312, 313, 314, 315, 316,
1850 317, 318, 319, 320, 321, 322, 323, 0, 375, 324,
1851 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1852 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1853 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1854 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 0, 0, 0, 376, 0, 0, 0, 0, 0, 0,
1856 0, 0, 0, 0, 0, 0, 0, 326, 327, 328,
1857 329, 330, 1, 2, 3, 4, 5, 6, 7, 8,
1858 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
1859 19, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1860 0, 0, 20, 21, 22, 23, 24, 25, 26, 27,
1861 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1862 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1863 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1864 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1865 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1866 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
1867 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
1868 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
1869 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
1870 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
1871 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
1872 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
1873 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
1874 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
1875 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
1876 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
1877 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
1878 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
1879 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
1880 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
1881 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
1882 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
1883 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
1884 258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
1885 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
1886 278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
1887 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
1888 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
1889 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
1890 318, 319, 320, 321, 322, 323, 0, 0, 324, 0,
1891 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1892 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1893 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1894 0, 0, 0, 0, 0, 0, 0, 563, 0, 0,
1895 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1896 0, 0, 0, 0, 0, 0, 326, 327, 328, 329,
1897 330, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1898 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1899 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1900 0, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1901 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1902 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1903 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1904 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
1905 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
1906 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1907 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
1908 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
1909 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
1910 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
1911 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
1912 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
1913 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
1914 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1915 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
1916 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
1917 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
1918 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
1919 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
1920 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
1921 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
1922 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
1923 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
1924 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
1925 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
1926 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
1927 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
1928 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
1929 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
1930 319, 320, 321, 322, 323, 0, 0, 324, 0, 0,
1931 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1932 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1933 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1934 0, 0, 0, 0, 0, 0, 632, 0, 0, 0,
1935 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1936 0, 0, 0, 0, 0, 326, 327, 328, 329, 330,
1937 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1938 11, 12, 13, 14, 15, 16, 17, 18, 19, 0,
1939 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1940 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1941 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1942 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1943 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1944 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1945 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1946 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1947 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
1948 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
1949 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
1950 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
1951 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
1952 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
1953 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
1954 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
1955 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
1956 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
1957 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
1958 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
1959 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
1960 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
1961 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
1962 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
1963 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
1964 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
1965 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
1966 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
1967 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
1968 300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
1969 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
1970 320, 321, 322, 323, 0, 0, 324, 0, 0, 0,
1971 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1972 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1973 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1974 0, 0, 0, 0, 0, 653, 0, 0, 0, 0,
1975 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1976 0, 0, 0, 0, 326, 327, 328, 329, 330, 1,
1977 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1978 12, 13, 14, 15, 16, 17, 18, 19, 0, 0,
1979 0, 0, 0, 0, 0, 0, 0, 0, 0, 20,
1980 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1981 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1982 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
1983 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1984 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
1985 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
1986 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
1987 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
1988 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
1989 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
1990 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
1991 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
1992 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
1993 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
1994 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
1995 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
1996 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
1997 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
1998 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
1999 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
2000 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
2001 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
2002 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
2003 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
2004 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
2005 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
2006 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
2007 291, 292, 293, 294, 295, 296, 297, 298, 299, 300,
2008 301, 302, 303, 304, 305, 306, 307, 308, 309, 310,
2009 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
2010 321, 322, 323, 0, 0, 324, 0, 0, 0, 0,
2011 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2012 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2013 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
2014 4, 5, 6, 7, 0, 9, 10, 11, 12, 13,
2015 14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2016 0, 0, 0, 326, 327, 328, 329, 330, 21, 22,
2017 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
2018 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
2019 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
2020 53, 54, 55, 56, 57, 58, 59, 0, 0, 0,
2021 0, 0, 0, 0, 0, 0, 69, 0, 0, 0,
2022 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2023 0, 0, 85, 86, 87, 88, 89, 90, 91, 92,
2024 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
2025 103, 104, 105, 106, 107, 108, 0, 0, 0, 0,
2026 0, 0, 0, 0, 0, 118, 119, 120, 121, 122,
2027 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2028 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2029 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
2030 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
2031 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
2032 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2033 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
2034 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
2035 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
2036 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
2037 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
2038 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
2039 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
2040 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
2041 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
2042 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
2043 283, 284, 285, 286, 287, 288, 289, 290, 291, 292,
2044 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
2045 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,
2046 313, 314, 315, 316, 317, 318, 319, 320, 321, 322,
2047 323, 0, 408, 324, 409, 410, 411, 412, 413, 414,
2048 415, 416, 417, 418, 419, 420, 0, 0, 421, 422,
2049 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2050 0, 0, 0, 0, 0, 0, 0, 423, 0, 0,
2051 0, 509, 672, 0, 0, 0, 0, 0, 425, 426,
2052 427, 428, 3, 4, 5, 6, 7, 0, 9, 10,
2053 11, 12, 13, 14, 15, 16, 17, 18, 19, 0,
2054 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2055 0, 21, 22, 23, 24, 25, 26, 27, 28, 29,
2056 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2057 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
2058 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
2059 0, 0, 0, 0, 0, 0, 0, 0, 0, 69,
2060 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2061 0, 0, 0, 0, 0, 85, 86, 87, 88, 89,
2062 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
2063 100, 101, 102, 103, 104, 105, 106, 107, 108, 0,
2064 0, 0, 0, 0, 0, 0, 0, 0, 118, 119,
2065 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2066 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2067 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
2068 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
2069 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
2070 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
2071 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
2072 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
2073 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
2074 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
2075 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
2076 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
2077 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
2078 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
2079 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
2080 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
2081 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
2082 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
2083 300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
2084 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
2085 320, 321, 322, 323, 0, 408, 324, 409, 410, 411,
2086 412, 413, 414, 415, 416, 417, 418, 419, 420, 0,
2087 0, 421, 422, 0, 0, 0, 0, 0, 0, 0,
2088 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2089 423, 0, 0, 424, 0, 0, 0, 0, 0, 0,
2090 0, 425, 426, 427, 428, 3, 4, 5, 6, 7,
2091 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2092 18, 19, 0, 0, 0, 0, 0, 0, 0, 0,
2093 0, 0, 0, 0, 21, 22, 23, 24, 25, 26,
2094 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2095 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
2096 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
2097 57, 58, 59, 0, 0, 0, 0, 0, 0, 0,
2098 0, 0, 69, 0, 0, 0, 0, 0, 0, 0,
2099 0, 0, 0, 0, 0, 0, 0, 0, 85, 86,
2100 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
2101 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
2102 107, 108, 0, 0, 0, 0, 0, 0, 0, 0,
2103 0, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2104 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2105 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
2106 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
2107 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
2108 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
2109 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
2110 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
2111 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
2112 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
2113 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
2114 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
2115 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
2116 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
2117 257, 258, 259, 260, 261, 262, 263, 264, 265, 266,
2118 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
2119 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
2120 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
2121 297, 298, 299, 300, 301, 302, 303, 304, 305, 306,
2122 307, 308, 309, 310, 311, 312, 313, 314, 315, 316,
2123 317, 318, 319, 320, 321, 322, 323, 0, 408, 324,
2124 409, 410, 411, 412, 413, 414, 415, 416, 417, 418,
2125 419, 420, 0, 0, 421, 422, 0, 0, 0, 0,
2126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2127 0, 0, 0, 423, 0, 0, 0, 509, 0, 0,
2128 0, 0, 0, 0, 425, 426, 427, 428, 3, 4,
2129 5, 6, 7, 0, 9, 10, 11, 12, 13, 14,
2130 15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2131 0, 0, 0, 0, 0, 0, 0, 21, 22, 23,
2132 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
2133 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
2134 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
2135 54, 55, 56, 57, 58, 59, 0, 0, 0, 0,
2136 0, 0, 0, 0, 0, 69, 0, 0, 0, 0,
2137 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2138 0, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2139 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
2140 104, 105, 106, 107, 108, 0, 0, 0, 0, 0,
2141 0, 0, 0, 0, 118, 119, 120, 121, 122, 123,
2142 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2143 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2144 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2145 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2146 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
2147 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2148 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
2149 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
2150 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
2151 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
2152 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
2153 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
2154 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
2155 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
2156 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
2157 274, 275, 276, 277, 278, 279, 280, 281, 282, 283,
2158 284, 285, 286, 287, 288, 289, 290, 291, 292, 293,
2159 294, 295, 296, 297, 298, 299, 300, 301, 302, 303,
2160 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
2161 314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
2162 0, 408, 324, 409, 410, 411, 412, 413, 414, 415,
2163 416, 417, 418, 419, 420, 0, 0, 421, 422, 0,
2164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2165 0, 0, 0, 0, 0, 0, 423, 0, 0, 552,
2166 0, 0, 0, 0, 0, 0, 0, 425, 426, 427,
2167 428, 3, 4, 5, 6, 7, 0, 9, 10, 11,
2168 12, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2170 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
2171 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2172 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
2173 51, 52, 53, 54, 55, 56, 57, 58, 59, 0,
2174 0, 0, 0, 0, 0, 0, 0, 0, 69, 0,
2175 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2176 0, 0, 0, 0, 85, 86, 87, 88, 89, 90,
2177 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
2178 101, 102, 103, 104, 105, 106, 107, 108, 0, 0,
2179 0, 0, 0, 0, 0, 0, 0, 118, 119, 120,
2180 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
2181 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
2182 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2183 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
2184 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2185 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
2186 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
2187 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
2188 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
2189 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
2190 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
2191 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
2192 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
2193 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
2194 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
2195 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
2196 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
2197 291, 292, 293, 294, 295, 296, 297, 298, 299, 300,
2198 301, 302, 303, 304, 305, 306, 307, 308, 309, 310,
2199 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
2200 321, 322, 323, 0, 408, 324, 409, 410, 411, 412,
2201 413, 414, 415, 416, 417, 418, 419, 420, 0, 0,
2202 421, 422, 0, 0, 0, 0, 0, 0, 0, 0,
2203 0, 0, 0, 0, 0, 0, 0, 0, 0, 423,
2204 0, 0, 0, 0, 0, 0, 0, 0, 0, 571,
2205 425, 426, 427, 428, 3, 4, 5, 6, 7, 0,
2206 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2207 19, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2208 0, 0, 0, 21, 22, 23, 24, 25, 26, 27,
2209 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2210 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
2211 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
2212 58, 59, 0, 0, 0, 0, 0, 0, 0, 0,
2213 0, 69, 0, 0, 0, 0, 0, 0, 0, 0,
2214 0, 0, 0, 0, 0, 0, 0, 85, 86, 87,
2215 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
2216 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
2217 108, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2218 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
2219 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
2220 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
2221 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
2222 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
2223 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
2224 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2225 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
2226 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
2227 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
2228 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
2229 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
2230 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
2231 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
2232 258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
2233 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
2234 278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
2235 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
2236 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
2237 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
2238 318, 319, 320, 321, 322, 323, 0, 408, 324, 409,
2239 410, 411, 412, 413, 414, 415, 416, 417, 418, 419,
2240 420, 0, 0, 421, 422, 0, 0, 0, 0, 0,
2241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2242 0, 0, 423, 0, 0, 0, 0, 0, 0, 0,
2243 0, 0, 0, 425, 426, 427, 428, 3, 4, 5,
2244 6, 7, 0, 9, 10, 11, 12, 13, 14, 15,
2245 16, 17, 18, 19, 0, 0, 0, 0, 0, 0,
2246 0, 0, 0, 0, 0, 0, 21, 22, 23, 24,
2247 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2248 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2249 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2250 55, 56, 57, 58, 59, 0, 0, 0, 0, 0,
2251 0, 0, 0, 0, 69, 0, 0, 0, 0, 0,
2252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
2254 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
2255 105, 106, 107, 108, 0, 0, 0, 0, 0, 0,
2256 0, 0, 0, 118, 119, 120, 121, 122, 123, 124,
2257 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2258 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2259 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
2260 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
2261 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
2262 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
2263 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
2264 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
2265 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
2266 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
2267 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
2268 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
2269 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
2270 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2271 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2272 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2273 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2274 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2275 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2276 315, 316, 317, 318, 319, 320, 321, 322, 527, 0,
2277 408, 324, 409, 410, 411, 412, 413, 414, 415, 416,
2278 417, 418, 419, 420, 0, 0, 421, 422, 0, 0,
2279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2280 0, 0, 0, 0, 0, 423, 0, 0, 0, 0,
2281 0, 0, 0, 0, 0, 0, 425, 426, 427, 428,
2282 3, 4, 5, 6, 7, 0, 9, 10, 11, 12,
2283 13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2284 0, 0, 0, 0, 0, 0, 0, 0, 0, 21,
2285 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
2286 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
2287 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
2288 52, 53, 54, 55, 56, 57, 58, 59, 0, 0,
2289 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2291 0, 0, 0, 85, 86, 87, 88, 89, 90, 91,
2292 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
2293 102, 103, 104, 105, 106, 107, 108, 0, 0, 0,
2294 0, 0, 0, 0, 0, 0, 118, 119, 120, 121,
2295 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2296 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2297 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
2298 152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
2299 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
2300 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2301 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
2302 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
2303 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
2304 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
2305 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
2306 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
2307 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
2308 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
2309 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
2310 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
2311 282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
2312 292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
2313 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
2314 312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
2315 322, 323, 0, 0, 324
2316 };
2317
2318 static const yytype_int16 yycheck[] =
2319 {
2320 0, 0, 0, 337, 345, 24, 0, 26, 27, 402,
2321 379, 30, 81, 495, 361, 507, 464, 509, 461, 579,
2322 512, 338, 338, 356, 357, 361, 383, 374, 643, 370,
2323 354, 355, 366, 681, 373, 375, 375, 685, 352, 353,
2324 375, 423, 382, 382, 437, 693, 661, 373, 383, 373,
2325 375, 375, 399, 400, 375, 379, 390, 382, 391, 392,
2326 396, 377, 383, 373, 375, 380, 383, 374, 383, 374,
2327 513, 382, 374, 380, 377, 379, 374, 380, 380, 376,
2328 383, 374, 380, 380, 374, 567, 455, 380, 380, 458,
2329 380, 383, 474, 378, 476, 380, 363, 364, 365, 366,
2330 367, 368, 369, 370, 371, 372, 374, 385, 600, 387,
2331 558, 380, 380, 338, 507, 382, 509, 421, 422, 512,
2332 374, 462, 538, 539, 540, 541, 380, 461, 380, 380,
2333 464, 383, 383, 526, 338, 380, 440, 697, 383, 380,
2334 522, 375, 383, 399, 400, 401, 388, 389, 390, 358,
2335 359, 455, 380, 381, 458, 377, 604, 380, 381, 377,
2336 652, 534, 535, 542, 543, 647, 536, 537, 338, 338,
2337 375, 382, 338, 383, 374, 373, 395, 394, 393, 513,
2338 360, 362, 376, 338, 338, 373, 383, 569, 383, 373,
2339 383, 573, 381, 375, 373, 373, 338, 373, 591, 592,
2340 373, 378, 338, 374, 376, 338, 698, 600, 376, 337,
2341 373, 373, 338, 560, 374, 380, 377, 376, 374, 383,
2342 378, 25, 374, 545, 558, 707, 377, 531, 532, 533,
2343 534, 535, 536, 537, 538, 539, 540, 541, 542, 543,
2344 544, 545, 546, 547, 548, 549, 377, 382, 630, 383,
2345 544, 378, 547, 549, 668, 546, 370, 366, 370, 652,
2346 548, 643, 638, 331, 460, 680, 693, 635, 694, 338,
2347 604, 364, 559, 638, 505, 661, 505, 353, 505, 661,
2348 670, 674, -1, -1, -1, -1, -1, -1, -1, -1,
2349 -1, -1, -1, 675, -1, -1, -1, -1, -1, 668,
2350 -1, -1, -1, -1, -1, 698, -1, -1, -1, 643,
2351 692, -1, -1, -1, -1, -1, -1, -1, 337, -1,
2352 -1, -1, -1, -1, -1, 666, -1, 661, -1, -1,
2353 -1, -1, -1, -1, -1, -1, -1, 337, -1, -1,
2354 -1, -1, -1, 337, -1, 345, -1, -1, -1, -1,
2355 -1, 345, -1, 353, 353, 353, -1, -1, -1, 353,
2356 360, -1, -1, -1, 668, -1, 366, -1, -1, -1,
2357 370, -1, 366, -1, -1, -1, 370, -1, -1, -1,
2358 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2359 390, -1, -1, -1, 394, -1, 390, -1, -1, -1,
2360 394, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2361 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2362 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2363 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2364 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2365 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2366 -1, 461, 462, -1, 464, -1, -1, 461, 462, -1,
2367 464, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2368 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2369 -1, -1, -1, -1, -1, 495, -1, -1, -1, -1,
2370 -1, 495, -1, -1, -1, -1, -1, -1, -1, -1,
2371 -1, -1, -1, 513, -1, -1, -1, -1, -1, 513,
2372 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2373 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2374 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2375 -1, -1, -1, -1, -1, -1, -1, -1, 558, -1,
2376 -1, -1, -1, -1, 558, -1, -1, 567, -1, -1,
2377 -1, -1, -1, 567, -1, -1, -1, -1, -1, 579,
2378 -1, -1, -1, -1, -1, 579, -1, -1, -1, -1,
2379 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2380 -1, -1, -1, -1, 604, -1, -1, -1, -1, -1,
2381 604, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2382 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2383 -1, -1, -1, -1, -1, -1, -1, -1, 638, -1,
2384 -1, -1, -1, 643, 638, -1, -1, 647, -1, 643,
2385 -1, -1, -1, 647, -1, -1, -1, -1, -1, -1,
2386 -1, 661, -1, -1, -1, -1, 666, 661, -1, -1,
2387 -1, -1, 666, -1, -1, -1, -1, -1, -1, -1,
2388 -1, 681, -1, -1, -1, 685, -1, 681, -1, -1,
2389 -1, 685, -1, 693, -1, -1, -1, 697, -1, 693,
2390 -1, -1, -1, 697, -1, -1, -1, 707, -1, -1,
2391 -1, 0, -1, 707, 3, 4, 5, 6, 7, 8,
2392 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2393 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2394 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
2395 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2396 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2397 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2398 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2399 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2400 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2401 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2402 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2403 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2404 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2405 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2406 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2407 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2408 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2409 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2410 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2411 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2412 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2413 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2414 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2415 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2416 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2417 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2418 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2419 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2420 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2421 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2422 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2423 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2424 329, 330, 331, 332, 333, 334, 335, 336, -1, -1,
2425 339, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2426 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2427 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2428 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2429 -1, -1, -1, -1, 383, -1, -1, -1, -1, -1,
2430 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2431 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2432 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2433 19, 20, 21, 22, 23, 24, -1, 26, 27, 28,
2434 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2435 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2436 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2437 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2438 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2439 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2440 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2441 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2442 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2443 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2444 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2445 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2446 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2447 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2448 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2449 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2450 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2451 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2452 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2453 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2454 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2455 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2456 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2457 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2458 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2459 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2460 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2461 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2462 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2463 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2464 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2465 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2466 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2467 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2468 -1, -1, -1, -1, 373, -1, 375, -1, 377, 378,
2469 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2470 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2471 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2472 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2473 19, 20, 21, 22, 23, 24, -1, 26, 27, 28,
2474 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2475 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2476 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2477 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2478 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2479 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2480 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2481 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2482 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2483 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2484 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2485 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2486 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2487 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2488 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2489 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2490 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2491 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2492 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2493 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2494 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2495 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2496 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2497 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2498 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2499 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2500 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2501 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2502 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2503 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2504 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2505 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2506 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2507 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2508 -1, -1, -1, -1, 373, -1, 375, -1, 377, 378,
2509 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2510 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2511 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2512 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2513 19, 20, 21, 22, 23, 24, -1, 26, 27, 28,
2514 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2515 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2516 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2517 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2518 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2519 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2520 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2521 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2522 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2523 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2524 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2525 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2526 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2527 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2528 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2529 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2530 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2531 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2532 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2533 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2534 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2535 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2536 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2537 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2538 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2539 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2540 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2541 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2542 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2543 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2544 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2545 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2546 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2547 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2548 -1, -1, -1, -1, 373, -1, 375, -1, 377, -1,
2549 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2550 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2551 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2552 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2553 19, 20, 21, 22, 23, 24, -1, 26, 27, 28,
2554 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2555 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2556 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2557 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2558 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2559 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2560 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2561 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2562 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2563 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2564 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2565 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2566 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2567 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2568 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2569 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2570 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2571 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2572 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2573 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2574 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2575 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2576 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2577 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2578 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2579 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2580 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2581 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2582 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2583 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2584 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2585 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2586 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2587 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2588 -1, -1, -1, -1, 373, -1, 375, -1, 377, -1,
2589 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2590 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2591 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2592 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2593 19, 20, 21, 22, 23, 24, -1, 26, 27, 28,
2594 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2595 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2596 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2597 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2598 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2599 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2600 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2601 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2602 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2603 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2604 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2605 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2606 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2607 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2608 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2609 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2610 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2611 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2612 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2613 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2614 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2615 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2616 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2617 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2618 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2619 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2620 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2621 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2622 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2623 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2624 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2625 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2626 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2627 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2628 -1, -1, -1, -1, 373, -1, 375, -1, -1, -1,
2629 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2630 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2631 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2632 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2633 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2634 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
2635 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2636 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2637 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2638 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2639 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2640 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2641 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2642 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2643 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2644 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2645 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2646 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2647 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2648 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2649 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2650 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2651 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2652 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2653 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2654 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2655 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2656 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2657 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2658 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2659 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2660 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2661 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2662 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2663 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2664 329, 330, 331, 332, 333, 334, 335, 336, -1, 338,
2665 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2666 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2667 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2668 -1, -1, -1, -1, 373, -1, -1, -1, -1, -1,
2669 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1,
2670 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2671 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2672 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2673 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2674 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
2675 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2676 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2677 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2678 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2679 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2680 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2681 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2682 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2683 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2684 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2685 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2686 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2687 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2688 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2689 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2690 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2691 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2692 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2693 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2694 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2695 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2696 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2697 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2698 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2699 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2700 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2701 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2702 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2703 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2704 329, 330, 331, 332, 333, 334, 335, 336, -1, -1,
2705 339, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2706 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2707 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2708 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2709 -1, -1, -1, -1, 383, -1, -1, -1, -1, -1,
2710 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2711 399, 400, 401, 402, 3, 4, 5, 6, 7, 8,
2712 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2713 19, 20, 21, -1, -1, -1, -1, -1, -1, -1,
2714 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38,
2715 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
2716 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
2717 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
2718 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2719 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2720 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
2721 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
2722 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
2723 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
2724 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2725 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2726 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2727 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2728 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
2729 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
2730 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
2731 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
2732 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
2733 219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
2734 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
2735 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
2736 249, 250, 251, 252, 253, 254, 255, 256, 257, 258,
2737 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
2738 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
2739 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
2740 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
2741 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
2742 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
2743 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
2744 329, 330, 331, 332, 333, 334, 335, 336, -1, 338,
2745 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
2746 349, 350, 351, -1, -1, 354, 355, -1, -1, -1,
2747 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2748 -1, -1, -1, -1, 373, -1, -1, -1, -1, -1,
2749 -1, -1, -1, -1, -1, 384, 385, 386, 387, -1,
2750 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398,
2751 399, 400, 401, 3, 4, 5, 6, 7, 8, 9,
2752 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
2753 20, 21, -1, -1, -1, -1, -1, -1, -1, -1,
2754 -1, -1, -1, 33, 34, 35, 36, 37, 38, 39,
2755 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
2756 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
2757 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
2758 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
2759 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
2760 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
2761 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
2762 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
2763 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2764 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2765 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
2766 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
2767 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
2768 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
2769 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
2770 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
2771 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
2772 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
2773 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
2774 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
2775 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
2776 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
2777 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
2778 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
2779 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
2780 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
2781 300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
2782 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
2783 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
2784 330, 331, 332, 333, 334, 335, 336, -1, 338, 339,
2785 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2786 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2787 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2788 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2789 -1, -1, -1, 383, -1, -1, -1, -1, -1, -1,
2790 -1, -1, -1, -1, -1, -1, -1, 397, 398, 399,
2791 400, 401, 3, 4, 5, 6, 7, 8, 9, 10,
2792 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
2793 21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2794 -1, -1, 33, 34, 35, 36, 37, 38, 39, 40,
2795 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
2796 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
2797 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
2798 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2799 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2800 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
2801 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
2802 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
2803 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
2804 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
2805 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2806 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
2807 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2808 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
2809 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
2810 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
2811 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
2812 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
2813 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
2814 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
2815 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
2816 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
2817 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
2818 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
2819 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
2820 291, 292, 293, 294, 295, 296, 297, 298, 299, 300,
2821 301, 302, 303, 304, 305, 306, 307, 308, 309, 310,
2822 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
2823 321, 322, 323, 324, 325, 326, 327, 328, 329, 330,
2824 331, 332, 333, 334, 335, 336, -1, -1, 339, -1,
2825 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2828 -1, -1, -1, -1, -1, -1, -1, 378, -1, -1,
2829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2830 -1, -1, -1, -1, -1, -1, 397, 398, 399, 400,
2831 401, 3, 4, 5, 6, 7, 8, 9, 10, 11,
2832 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
2833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2834 -1, 33, 34, 35, 36, 37, 38, 39, 40, 41,
2835 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
2836 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
2837 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
2838 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
2839 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
2840 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
2841 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
2842 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2843 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2844 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2845 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
2846 152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
2847 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
2848 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2849 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
2850 192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
2851 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
2852 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
2853 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
2854 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
2855 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
2856 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
2857 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
2858 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
2859 282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
2860 292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
2861 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
2862 312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
2863 322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
2864 332, 333, 334, 335, 336, -1, -1, 339, -1, -1,
2865 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2866 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2867 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2868 -1, -1, -1, -1, -1, -1, 378, -1, -1, -1,
2869 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2870 -1, -1, -1, -1, -1, 397, 398, 399, 400, 401,
2871 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
2872 13, 14, 15, 16, 17, 18, 19, 20, 21, -1,
2873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2874 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
2875 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
2876 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2877 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
2878 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
2879 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
2880 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
2881 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
2882 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
2883 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2884 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2885 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
2886 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
2887 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
2888 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2889 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
2890 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
2891 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
2892 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
2893 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
2894 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
2895 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
2896 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
2897 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
2898 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
2899 283, 284, 285, 286, 287, 288, 289, 290, 291, 292,
2900 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
2901 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,
2902 313, 314, 315, 316, 317, 318, 319, 320, 321, 322,
2903 323, 324, 325, 326, 327, 328, 329, 330, 331, 332,
2904 333, 334, 335, 336, -1, -1, 339, -1, -1, -1,
2905 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2906 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2907 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2908 -1, -1, -1, -1, -1, 378, -1, -1, -1, -1,
2909 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2910 -1, -1, -1, -1, 397, 398, 399, 400, 401, 3,
2911 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
2912 14, 15, 16, 17, 18, 19, 20, 21, -1, -1,
2913 -1, -1, -1, -1, -1, -1, -1, -1, -1, 33,
2914 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
2915 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
2916 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
2917 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
2918 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2919 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2920 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
2921 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
2922 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
2923 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2924 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2925 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2926 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2927 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
2928 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2929 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
2930 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
2931 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
2932 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
2933 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
2934 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
2935 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
2936 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
2937 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
2938 274, 275, 276, 277, 278, 279, 280, 281, 282, 283,
2939 284, 285, 286, 287, 288, 289, 290, 291, 292, 293,
2940 294, 295, 296, 297, 298, 299, 300, 301, 302, 303,
2941 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
2942 314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
2943 324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2944 334, 335, 336, -1, -1, 339, -1, -1, -1, -1,
2945 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2946 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2947 -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,
2948 6, 7, 8, 9, -1, 11, 12, 13, 14, 15,
2949 16, 17, 18, 19, 20, 21, -1, -1, -1, -1,
2950 -1, -1, -1, 397, 398, 399, 400, 401, 34, 35,
2951 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
2952 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
2953 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
2954 66, 67, 68, 69, 70, 71, 72, -1, -1, -1,
2955 -1, -1, -1, -1, -1, -1, 82, -1, -1, -1,
2956 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2957 -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
2958 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2959 116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
2960 -1, -1, -1, -1, -1, 131, 132, 133, 134, 135,
2961 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
2962 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2963 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2964 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
2965 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
2966 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
2967 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
2968 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
2969 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
2970 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
2971 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
2972 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
2973 256, 257, 258, 259, 260, 261, 262, 263, 264, 265,
2974 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
2975 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
2976 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
2977 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
2978 306, 307, 308, 309, 310, 311, 312, 313, 314, 315,
2979 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,
2980 326, 327, 328, 329, 330, 331, 332, 333, 334, 335,
2981 336, -1, 338, 339, 340, 341, 342, 343, 344, 345,
2982 346, 347, 348, 349, 350, 351, -1, -1, 354, 355,
2983 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2984 -1, -1, -1, -1, -1, -1, -1, 373, -1, -1,
2985 -1, 377, 378, -1, -1, -1, -1, -1, 384, 385,
2986 386, 387, 5, 6, 7, 8, 9, -1, 11, 12,
2987 13, 14, 15, 16, 17, 18, 19, 20, 21, -1,
2988 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2989 -1, 34, 35, 36, 37, 38, 39, 40, 41, 42,
2990 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
2991 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2992 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
2993 -1, -1, -1, -1, -1, -1, -1, -1, -1, 82,
2994 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2995 -1, -1, -1, -1, -1, 98, 99, 100, 101, 102,
2996 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
2997 113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
2998 -1, -1, -1, -1, -1, -1, -1, -1, 131, 132,
2999 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
3000 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
3001 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
3002 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
3003 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
3004 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
3005 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
3006 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
3007 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
3008 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
3009 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
3010 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
3011 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
3012 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
3013 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
3014 283, 284, 285, 286, 287, 288, 289, 290, 291, 292,
3015 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
3016 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,
3017 313, 314, 315, 316, 317, 318, 319, 320, 321, 322,
3018 323, 324, 325, 326, 327, 328, 329, 330, 331, 332,
3019 333, 334, 335, 336, -1, 338, 339, 340, 341, 342,
3020 343, 344, 345, 346, 347, 348, 349, 350, 351, -1,
3021 -1, 354, 355, -1, -1, -1, -1, -1, -1, -1,
3022 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3023 373, -1, -1, 376, -1, -1, -1, -1, -1, -1,
3024 -1, 384, 385, 386, 387, 5, 6, 7, 8, 9,
3025 -1, 11, 12, 13, 14, 15, 16, 17, 18, 19,
3026 20, 21, -1, -1, -1, -1, -1, -1, -1, -1,
3027 -1, -1, -1, -1, 34, 35, 36, 37, 38, 39,
3028 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
3029 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3030 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
3031 70, 71, 72, -1, -1, -1, -1, -1, -1, -1,
3032 -1, -1, 82, -1, -1, -1, -1, -1, -1, -1,
3033 -1, -1, -1, -1, -1, -1, -1, -1, 98, 99,
3034 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
3035 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
3036 120, 121, -1, -1, -1, -1, -1, -1, -1, -1,
3037 -1, 131, 132, 133, 134, 135, 136, 137, 138, 139,
3038 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
3039 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
3040 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
3041 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
3042 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
3043 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
3044 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
3045 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
3046 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
3047 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
3048 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
3049 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
3050 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
3051 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
3052 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
3053 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
3054 300, 301, 302, 303, 304, 305, 306, 307, 308, 309,
3055 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
3056 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
3057 330, 331, 332, 333, 334, 335, 336, -1, 338, 339,
3058 340, 341, 342, 343, 344, 345, 346, 347, 348, 349,
3059 350, 351, -1, -1, 354, 355, -1, -1, -1, -1,
3060 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3061 -1, -1, -1, 373, -1, -1, -1, 377, -1, -1,
3062 -1, -1, -1, -1, 384, 385, 386, 387, 5, 6,
3063 7, 8, 9, -1, 11, 12, 13, 14, 15, 16,
3064 17, 18, 19, 20, 21, -1, -1, -1, -1, -1,
3065 -1, -1, -1, -1, -1, -1, -1, 34, 35, 36,
3066 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
3067 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3068 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
3069 67, 68, 69, 70, 71, 72, -1, -1, -1, -1,
3070 -1, -1, -1, -1, -1, 82, -1, -1, -1, -1,
3071 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3072 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3073 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
3074 117, 118, 119, 120, 121, -1, -1, -1, -1, -1,
3075 -1, -1, -1, -1, 131, 132, 133, 134, 135, 136,
3076 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
3077 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,
3078 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
3079 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
3080 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
3081 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
3082 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
3083 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
3084 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
3085 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
3086 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
3087 247, 248, 249, 250, 251, 252, 253, 254, 255, 256,
3088 257, 258, 259, 260, 261, 262, 263, 264, 265, 266,
3089 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
3090 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
3091 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
3092 297, 298, 299, 300, 301, 302, 303, 304, 305, 306,
3093 307, 308, 309, 310, 311, 312, 313, 314, 315, 316,
3094 317, 318, 319, 320, 321, 322, 323, 324, 325, 326,
3095 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
3096 -1, 338, 339, 340, 341, 342, 343, 344, 345, 346,
3097 347, 348, 349, 350, 351, -1, -1, 354, 355, -1,
3098 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3099 -1, -1, -1, -1, -1, -1, 373, -1, -1, 376,
3100 -1, -1, -1, -1, -1, -1, -1, 384, 385, 386,
3101 387, 5, 6, 7, 8, 9, -1, 11, 12, 13,
3102 14, 15, 16, 17, 18, 19, 20, 21, -1, -1,
3103 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3104 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
3105 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3106 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
3107 64, 65, 66, 67, 68, 69, 70, 71, 72, -1,
3108 -1, -1, -1, -1, -1, -1, -1, -1, 82, -1,
3109 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3110 -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
3111 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
3112 114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3113 -1, -1, -1, -1, -1, -1, -1, 131, 132, 133,
3114 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
3115 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
3116 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
3117 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3118 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
3119 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
3120 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
3121 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
3122 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
3123 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
3124 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
3125 244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
3126 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
3127 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
3128 274, 275, 276, 277, 278, 279, 280, 281, 282, 283,
3129 284, 285, 286, 287, 288, 289, 290, 291, 292, 293,
3130 294, 295, 296, 297, 298, 299, 300, 301, 302, 303,
3131 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
3132 314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
3133 324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
3134 334, 335, 336, -1, 338, 339, 340, 341, 342, 343,
3135 344, 345, 346, 347, 348, 349, 350, 351, -1, -1,
3136 354, 355, -1, -1, -1, -1, -1, -1, -1, -1,
3137 -1, -1, -1, -1, -1, -1, -1, -1, -1, 373,
3138 -1, -1, -1, -1, -1, -1, -1, -1, -1, 383,
3139 384, 385, 386, 387, 5, 6, 7, 8, 9, -1,
3140 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3141 21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3142 -1, -1, -1, 34, 35, 36, 37, 38, 39, 40,
3143 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
3144 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3145 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
3146 71, 72, -1, -1, -1, -1, -1, -1, -1, -1,
3147 -1, 82, -1, -1, -1, -1, -1, -1, -1, -1,
3148 -1, -1, -1, -1, -1, -1, -1, 98, 99, 100,
3149 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
3150 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
3151 121, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3152 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
3153 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
3154 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
3155 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3156 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
3157 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3158 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
3159 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
3160 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
3161 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
3162 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
3163 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
3164 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
3165 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
3166 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
3167 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
3168 291, 292, 293, 294, 295, 296, 297, 298, 299, 300,
3169 301, 302, 303, 304, 305, 306, 307, 308, 309, 310,
3170 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
3171 321, 322, 323, 324, 325, 326, 327, 328, 329, 330,
3172 331, 332, 333, 334, 335, 336, -1, 338, 339, 340,
3173 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,
3174 351, -1, -1, 354, 355, -1, -1, -1, -1, -1,
3175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3176 -1, -1, 373, -1, -1, -1, -1, -1, -1, -1,
3177 -1, -1, -1, 384, 385, 386, 387, 5, 6, 7,
3178 8, 9, -1, 11, 12, 13, 14, 15, 16, 17,
3179 18, 19, 20, 21, -1, -1, -1, -1, -1, -1,
3180 -1, -1, -1, -1, -1, -1, 34, 35, 36, 37,
3181 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
3182 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3183 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
3184 68, 69, 70, 71, 72, -1, -1, -1, -1, -1,
3185 -1, -1, -1, -1, 82, -1, -1, -1, -1, -1,
3186 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3187 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
3188 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
3189 118, 119, 120, 121, -1, -1, -1, -1, -1, -1,
3190 -1, -1, -1, 131, 132, 133, 134, 135, 136, 137,
3191 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
3192 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
3193 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
3194 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
3195 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3196 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
3197 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
3198 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
3199 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
3200 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
3201 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
3202 248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
3203 258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
3204 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
3205 278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
3206 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
3207 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
3208 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
3209 318, 319, 320, 321, 322, 323, 324, 325, 326, 327,
3210 328, 329, 330, 331, 332, 333, 334, 335, 336, -1,
3211 338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
3212 348, 349, 350, 351, -1, -1, 354, 355, -1, -1,
3213 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3214 -1, -1, -1, -1, -1, 373, -1, -1, -1, -1,
3215 -1, -1, -1, -1, -1, -1, 384, 385, 386, 387,
3216 5, 6, 7, 8, 9, -1, 11, 12, 13, 14,
3217 15, 16, 17, 18, 19, 20, 21, -1, -1, -1,
3218 -1, -1, -1, -1, -1, -1, -1, -1, -1, 34,
3219 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
3220 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3221 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3222 65, 66, 67, 68, 69, 70, 71, 72, -1, -1,
3223 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3224 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3225 -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3226 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
3227 115, 116, 117, 118, 119, 120, 121, -1, -1, -1,
3228 -1, -1, -1, -1, -1, -1, 131, 132, 133, 134,
3229 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
3230 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
3231 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
3232 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3233 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
3234 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
3235 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
3236 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
3237 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
3238 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
3239 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
3240 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
3241 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
3242 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
3243 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
3244 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
3245 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
3246 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
3247 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
3248 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
3249 335, 336, -1, -1, 339
3250 };
3251
3252 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3253 symbol of state STATE-NUM. */
3254 static const yytype_uint16 yystos[] =
3255 {
3256 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3257 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3258 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
3259 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
3260 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
3261 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
3262 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3263 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
3264 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
3265 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
3266 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
3267 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
3268 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
3269 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
3270 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
3271 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
3272 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
3273 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
3274 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
3275 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
3276 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
3277 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
3278 233, 234, 235, 236, 237, 238, 239, 240, 241, 242,
3279 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
3280 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
3281 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
3282 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
3283 283, 284, 285, 286, 287, 288, 289, 290, 291, 292,
3284 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
3285 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,
3286 313, 314, 315, 316, 317, 318, 319, 320, 321, 322,
3287 323, 324, 325, 326, 327, 328, 329, 330, 331, 332,
3288 333, 334, 335, 336, 339, 383, 397, 398, 399, 400,
3289 401, 402, 437, 438, 441, 442, 443, 444, 448, 449,
3290 450, 451, 452, 453, 456, 457, 458, 459, 460, 462,
3291 464, 465, 466, 506, 507, 508, 373, 373, 338, 377,
3292 465, 338, 383, 383, 509, 374, 380, 445, 446, 447,
3293 457, 462, 380, 383, 338, 338, 383, 458, 462, 375,
3294 463, 0, 507, 338, 461, 81, 338, 454, 455, 377,
3295 468, 462, 383, 463, 377, 485, 446, 445, 447, 338,
3296 338, 373, 382, 463, 377, 380, 383, 440, 338, 340,
3297 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,
3298 351, 354, 355, 373, 376, 384, 385, 386, 387, 407,
3299 408, 409, 411, 412, 413, 414, 415, 416, 417, 418,
3300 419, 420, 421, 422, 423, 424, 425, 426, 427, 428,
3301 429, 430, 431, 460, 462, 375, 374, 380, 382, 374,
3302 380, 467, 457, 462, 469, 470, 383, 383, 22, 23,
3303 24, 26, 27, 28, 29, 30, 31, 32, 337, 375,
3304 377, 378, 383, 418, 431, 433, 435, 437, 441, 460,
3305 462, 475, 476, 477, 478, 486, 487, 488, 489, 492,
3306 493, 496, 497, 498, 505, 510, 463, 382, 463, 377,
3307 433, 473, 382, 439, 338, 380, 383, 418, 418, 435,
3308 354, 355, 375, 379, 374, 374, 380, 336, 433, 373,
3309 418, 388, 389, 390, 385, 387, 352, 353, 356, 357,
3310 391, 392, 358, 359, 395, 394, 393, 360, 362, 361,
3311 396, 376, 376, 431, 338, 431, 436, 455, 469, 462,
3312 338, 471, 472, 378, 470, 383, 383, 500, 373, 373,
3313 383, 383, 435, 373, 435, 381, 373, 375, 378, 479,
3314 363, 364, 365, 366, 367, 368, 369, 370, 371, 372,
3315 382, 434, 380, 383, 378, 476, 489, 493, 498, 473,
3316 382, 473, 474, 473, 469, 338, 374, 410, 435, 338,
3317 433, 418, 418, 418, 420, 420, 421, 421, 422, 422,
3318 422, 422, 423, 423, 424, 425, 426, 427, 428, 429,
3319 432, 376, 378, 471, 463, 380, 383, 476, 501, 435,
3320 383, 435, 381, 499, 338, 511, 512, 486, 433, 433,
3321 473, 378, 380, 378, 376, 435, 383, 472, 337, 475,
3322 487, 502, 374, 374, 435, 450, 457, 491, 373, 376,
3323 380, 480, 378, 473, 381, 373, 491, 503, 504, 482,
3324 483, 484, 490, 494, 338, 374, 436, 376, 512, 378,
3325 433, 435, 383, 374, 25, 478, 477, 377, 382, 477,
3326 481, 485, 374, 374, 435, 481, 482, 486, 495, 473,
3327 383, 378
3328 };
3329
3330 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
3331 static const yytype_uint16 yyr1[] =
3332 {
3333 0, 406, 407, 408, 408, 408, 408, 408, 408, 408,
3334 408, 408, 408, 408, 408, 408, 408, 409, 409, 409,
3335 409, 409, 409, 410, 411, 412, 413, 413, 414, 414,
3336 415, 415, 416, 417, 417, 417, 418, 418, 418, 418,
3337 419, 419, 419, 419, 420, 420, 420, 420, 421, 421,
3338 421, 422, 422, 422, 423, 423, 423, 423, 423, 424,
3339 424, 424, 425, 425, 426, 426, 427, 427, 428, 428,
3340 429, 429, 430, 430, 431, 432, 431, 433, 433, 434,
3341 434, 434, 434, 434, 434, 434, 434, 434, 434, 434,
3342 435, 435, 436, 437, 437, 437, 437, 437, 437, 437,
3343 437, 437, 439, 438, 440, 440, 441, 442, 442, 443,
3344 443, 444, 445, 445, 446, 446, 446, 446, 447, 448,
3345 448, 448, 448, 448, 449, 449, 449, 449, 449, 450,
3346 450, 451, 452, 452, 452, 452, 452, 452, 452, 452,
3347 453, 454, 454, 455, 455, 455, 456, 457, 457, 458,
3348 458, 458, 458, 458, 458, 458, 459, 459, 459, 459,
3349 459, 459, 459, 459, 459, 459, 459, 459, 459, 459,
3350 459, 459, 459, 459, 459, 459, 459, 459, 459, 459,
3351 459, 459, 459, 459, 459, 460, 461, 461, 462, 462,
3352 463, 463, 463, 463, 464, 464, 464, 464, 464, 464,
3353 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3354 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3355 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3356 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3357 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3358 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3359 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3360 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3361 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3362 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3363 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3364 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3365 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3366 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3367 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3368 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3369 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3370 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3371 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3372 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3373 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3374 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3375 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3376 464, 464, 464, 464, 464, 464, 464, 464, 464, 464,
3377 464, 464, 464, 464, 464, 464, 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, 464, 464, 464, 464, 464,
3381 465, 465, 465, 467, 466, 468, 466, 469, 469, 470,
3382 470, 471, 471, 472, 472, 473, 473, 473, 474, 474,
3383 475, 476, 476, 477, 477, 477, 477, 477, 477, 477,
3384 478, 479, 480, 478, 481, 481, 483, 482, 484, 482,
3385 485, 485, 486, 486, 487, 487, 488, 488, 489, 490,
3386 490, 491, 491, 492, 492, 494, 493, 495, 495, 496,
3387 496, 497, 497, 499, 498, 500, 498, 501, 498, 502,
3388 502, 503, 503, 504, 504, 505, 505, 505, 505, 505,
3389 506, 506, 507, 507, 507, 509, 508, 510, 511, 511,
3390 512, 512
3391 };
3392
3393 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
3394 static const yytype_uint8 yyr2[] =
3395 {
3396 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
3397 1, 1, 1, 1, 1, 1, 3, 1, 4, 1,
3398 3, 2, 2, 1, 1, 1, 2, 2, 2, 1,
3399 2, 3, 2, 1, 1, 1, 1, 2, 2, 2,
3400 1, 1, 1, 1, 1, 3, 3, 3, 1, 3,
3401 3, 1, 3, 3, 1, 3, 3, 3, 3, 1,
3402 3, 3, 1, 3, 1, 3, 1, 3, 1, 3,
3403 1, 3, 1, 3, 1, 0, 6, 1, 3, 1,
3404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3405 1, 3, 1, 2, 2, 4, 2, 3, 4, 2,
3406 3, 4, 0, 6, 2, 3, 2, 1, 1, 2,
3407 3, 3, 2, 3, 2, 1, 2, 1, 1, 1,
3408 3, 4, 6, 5, 1, 2, 3, 5, 4, 1,
3409 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3410 4, 1, 3, 1, 3, 1, 1, 1, 2, 1,
3411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3414 1, 1, 1, 1, 4, 1, 1, 3, 1, 2,
3415 2, 3, 3, 4, 1, 1, 1, 1, 1, 1,
3416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3440 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 0, 6, 0, 5, 1, 2, 3,
3445 4, 1, 3, 1, 2, 1, 3, 4, 1, 3,
3446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3447 2, 0, 0, 5, 1, 1, 0, 2, 0, 2,
3448 2, 3, 1, 2, 1, 2, 1, 2, 5, 3,
3449 1, 1, 4, 1, 2, 0, 8, 0, 1, 3,
3450 2, 1, 2, 0, 6, 0, 8, 0, 7, 1,
3451 1, 1, 0, 2, 3, 2, 2, 2, 3, 2,
3452 1, 2, 1, 1, 1, 0, 3, 5, 1, 3,
3453 1, 4
3454 };
3455
3456
3457 #define yyerrok (yyerrstatus = 0)
3458 #define yyclearin (yychar = YYEMPTY)
3459 #define YYEMPTY (-2)
3460 #define YYEOF 0
3461
3462 #define YYACCEPT goto yyacceptlab
3463 #define YYABORT goto yyabortlab
3464 #define YYERROR goto yyerrorlab
3465
3466
3467 #define YYRECOVERING() (!!yyerrstatus)
3468
3469 #define YYBACKUP(Token, Value) \
3470 do \
3471 if (yychar == YYEMPTY) \
3472 { \
3473 yychar = (Token); \
3474 yylval = (Value); \
3475 YYPOPSTACK (yylen); \
3476 yystate = *yyssp; \
3477 goto yybackup; \
3478 } \
3479 else \
3480 { \
3481 yyerror (pParseContext, YY_("syntax error: cannot back up")); \
3482 YYERROR; \
3483 } \
3484 while (0)
3485
3486 /* Error token number */
3487 #define YYTERROR 1
3488 #define YYERRCODE 256
3489
3490
3491
3492 /* Enable debugging if requested. */
3493 #if YYDEBUG
3494
3495 # ifndef YYFPRINTF
3496 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3497 # define YYFPRINTF fprintf
3498 # endif
3499
3500 # define YYDPRINTF(Args) \
3501 do { \
3502 if (yydebug) \
3503 YYFPRINTF Args; \
3504 } while (0)
3505
3506 /* This macro is provided for backward compatibility. */
3507 #ifndef YY_LOCATION_PRINT
3508 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3509 #endif
3510
3511
3512 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
3513 do { \
3514 if (yydebug) \
3515 { \
3516 YYFPRINTF (stderr, "%s ", Title); \
3517 yy_symbol_print (stderr, \
3518 Type, Value, pParseContext); \
3519 YYFPRINTF (stderr, "\n"); \
3520 } \
3521 } while (0)
3522
3523
3524 /*----------------------------------------.
3525 | Print this symbol's value on YYOUTPUT. |
3526 `----------------------------------------*/
3527
3528 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,glslang::TParseContext * pParseContext)3529 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
3530 {
3531 FILE *yyo = yyoutput;
3532 YYUSE (yyo);
3533 YYUSE (pParseContext);
3534 if (!yyvaluep)
3535 return;
3536 # ifdef YYPRINT
3537 if (yytype < YYNTOKENS)
3538 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3539 # endif
3540 YYUSE (yytype);
3541 }
3542
3543
3544 /*--------------------------------.
3545 | Print this symbol on YYOUTPUT. |
3546 `--------------------------------*/
3547
3548 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,glslang::TParseContext * pParseContext)3549 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext)
3550 {
3551 YYFPRINTF (yyoutput, "%s %s (",
3552 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
3553
3554 yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParseContext);
3555 YYFPRINTF (yyoutput, ")");
3556 }
3557
3558 /*------------------------------------------------------------------.
3559 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3560 | TOP (included). |
3561 `------------------------------------------------------------------*/
3562
3563 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)3564 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
3565 {
3566 YYFPRINTF (stderr, "Stack now");
3567 for (; yybottom <= yytop; yybottom++)
3568 {
3569 int yybot = *yybottom;
3570 YYFPRINTF (stderr, " %d", yybot);
3571 }
3572 YYFPRINTF (stderr, "\n");
3573 }
3574
3575 # define YY_STACK_PRINT(Bottom, Top) \
3576 do { \
3577 if (yydebug) \
3578 yy_stack_print ((Bottom), (Top)); \
3579 } while (0)
3580
3581
3582 /*------------------------------------------------.
3583 | Report that the YYRULE is going to be reduced. |
3584 `------------------------------------------------*/
3585
3586 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule,glslang::TParseContext * pParseContext)3587 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, glslang::TParseContext* pParseContext)
3588 {
3589 unsigned long int yylno = yyrline[yyrule];
3590 int yynrhs = yyr2[yyrule];
3591 int yyi;
3592 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
3593 yyrule - 1, yylno);
3594 /* The symbols being reduced. */
3595 for (yyi = 0; yyi < yynrhs; yyi++)
3596 {
3597 YYFPRINTF (stderr, " $%d = ", yyi + 1);
3598 yy_symbol_print (stderr,
3599 yystos[yyssp[yyi + 1 - yynrhs]],
3600 &(yyvsp[(yyi + 1) - (yynrhs)])
3601 , pParseContext);
3602 YYFPRINTF (stderr, "\n");
3603 }
3604 }
3605
3606 # define YY_REDUCE_PRINT(Rule) \
3607 do { \
3608 if (yydebug) \
3609 yy_reduce_print (yyssp, yyvsp, Rule, pParseContext); \
3610 } while (0)
3611
3612 /* Nonzero means print parse trace. It is left uninitialized so that
3613 multiple parsers can coexist. */
3614 int yydebug;
3615 #else /* !YYDEBUG */
3616 # define YYDPRINTF(Args)
3617 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3618 # define YY_STACK_PRINT(Bottom, Top)
3619 # define YY_REDUCE_PRINT(Rule)
3620 #endif /* !YYDEBUG */
3621
3622
3623 /* YYINITDEPTH -- initial size of the parser's stacks. */
3624 #ifndef YYINITDEPTH
3625 # define YYINITDEPTH 200
3626 #endif
3627
3628 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3629 if the built-in stack extension method is used).
3630
3631 Do not make this value too large; the results are undefined if
3632 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3633 evaluated with infinite-precision integer arithmetic. */
3634
3635 #ifndef YYMAXDEPTH
3636 # define YYMAXDEPTH 10000
3637 #endif
3638
3639
3640 #if YYERROR_VERBOSE
3641
3642 # ifndef yystrlen
3643 # if defined __GLIBC__ && defined _STRING_H
3644 # define yystrlen strlen
3645 # else
3646 /* Return the length of YYSTR. */
3647 static YYSIZE_T
yystrlen(const char * yystr)3648 yystrlen (const char *yystr)
3649 {
3650 YYSIZE_T yylen;
3651 for (yylen = 0; yystr[yylen]; yylen++)
3652 continue;
3653 return yylen;
3654 }
3655 # endif
3656 # endif
3657
3658 # ifndef yystpcpy
3659 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
3660 # define yystpcpy stpcpy
3661 # else
3662 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3663 YYDEST. */
3664 static char *
yystpcpy(char * yydest,const char * yysrc)3665 yystpcpy (char *yydest, const char *yysrc)
3666 {
3667 char *yyd = yydest;
3668 const char *yys = yysrc;
3669
3670 while ((*yyd++ = *yys++) != '\0')
3671 continue;
3672
3673 return yyd - 1;
3674 }
3675 # endif
3676 # endif
3677
3678 # ifndef yytnamerr
3679 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3680 quotes and backslashes, so that it's suitable for yyerror. The
3681 heuristic is that double-quoting is unnecessary unless the string
3682 contains an apostrophe, a comma, or backslash (other than
3683 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3684 null, do not copy; instead, return the length of what the result
3685 would have been. */
3686 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)3687 yytnamerr (char *yyres, const char *yystr)
3688 {
3689 if (*yystr == '"')
3690 {
3691 YYSIZE_T yyn = 0;
3692 char const *yyp = yystr;
3693
3694 for (;;)
3695 switch (*++yyp)
3696 {
3697 case '\'':
3698 case ',':
3699 goto do_not_strip_quotes;
3700
3701 case '\\':
3702 if (*++yyp != '\\')
3703 goto do_not_strip_quotes;
3704 /* Fall through. */
3705 default:
3706 if (yyres)
3707 yyres[yyn] = *yyp;
3708 yyn++;
3709 break;
3710
3711 case '"':
3712 if (yyres)
3713 yyres[yyn] = '\0';
3714 return yyn;
3715 }
3716 do_not_strip_quotes: ;
3717 }
3718
3719 if (! yyres)
3720 return yystrlen (yystr);
3721
3722 return yystpcpy (yyres, yystr) - yyres;
3723 }
3724 # endif
3725
3726 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
3727 about the unexpected token YYTOKEN for the state stack whose top is
3728 YYSSP.
3729
3730 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
3731 not large enough to hold the message. In that case, also set
3732 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
3733 required number of bytes is too large to store. */
3734 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)3735 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
3736 yytype_int16 *yyssp, int yytoken)
3737 {
3738 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
3739 YYSIZE_T yysize = yysize0;
3740 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3741 /* Internationalized format string. */
3742 const char *yyformat = YY_NULLPTR;
3743 /* Arguments of yyformat. */
3744 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3745 /* Number of reported tokens (one for the "unexpected", one per
3746 "expected"). */
3747 int yycount = 0;
3748
3749 /* There are many possibilities here to consider:
3750 - If this state is a consistent state with a default action, then
3751 the only way this function was invoked is if the default action
3752 is an error action. In that case, don't check for expected
3753 tokens because there are none.
3754 - The only way there can be no lookahead present (in yychar) is if
3755 this state is a consistent state with a default action. Thus,
3756 detecting the absence of a lookahead is sufficient to determine
3757 that there is no unexpected or expected token to report. In that
3758 case, just report a simple "syntax error".
3759 - Don't assume there isn't a lookahead just because this state is a
3760 consistent state with a default action. There might have been a
3761 previous inconsistent state, consistent state with a non-default
3762 action, or user semantic action that manipulated yychar.
3763 - Of course, the expected token list depends on states to have
3764 correct lookahead information, and it depends on the parser not
3765 to perform extra reductions after fetching a lookahead from the
3766 scanner and before detecting a syntax error. Thus, state merging
3767 (from LALR or IELR) and default reductions corrupt the expected
3768 token list. However, the list is correct for canonical LR with
3769 one exception: it will still contain any token that will not be
3770 accepted due to an error action in a later state.
3771 */
3772 if (yytoken != YYEMPTY)
3773 {
3774 int yyn = yypact[*yyssp];
3775 yyarg[yycount++] = yytname[yytoken];
3776 if (!yypact_value_is_default (yyn))
3777 {
3778 /* Start YYX at -YYN if negative to avoid negative indexes in
3779 YYCHECK. In other words, skip the first -YYN actions for
3780 this state because they are default actions. */
3781 int yyxbegin = yyn < 0 ? -yyn : 0;
3782 /* Stay within bounds of both yycheck and yytname. */
3783 int yychecklim = YYLAST - yyn + 1;
3784 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3785 int yyx;
3786
3787 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3788 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
3789 && !yytable_value_is_error (yytable[yyx + yyn]))
3790 {
3791 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3792 {
3793 yycount = 1;
3794 yysize = yysize0;
3795 break;
3796 }
3797 yyarg[yycount++] = yytname[yyx];
3798 {
3799 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
3800 if (! (yysize <= yysize1
3801 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
3802 return 2;
3803 yysize = yysize1;
3804 }
3805 }
3806 }
3807 }
3808
3809 switch (yycount)
3810 {
3811 # define YYCASE_(N, S) \
3812 case N: \
3813 yyformat = S; \
3814 break
3815 YYCASE_(0, YY_("syntax error"));
3816 YYCASE_(1, YY_("syntax error, unexpected %s"));
3817 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
3818 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
3819 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
3820 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
3821 # undef YYCASE_
3822 }
3823
3824 {
3825 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
3826 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
3827 return 2;
3828 yysize = yysize1;
3829 }
3830
3831 if (*yymsg_alloc < yysize)
3832 {
3833 *yymsg_alloc = 2 * yysize;
3834 if (! (yysize <= *yymsg_alloc
3835 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
3836 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
3837 return 1;
3838 }
3839
3840 /* Avoid sprintf, as that infringes on the user's name space.
3841 Don't have undefined behavior even if the translation
3842 produced a string with the wrong number of "%s"s. */
3843 {
3844 char *yyp = *yymsg;
3845 int yyi = 0;
3846 while ((*yyp = *yyformat) != '\0')
3847 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
3848 {
3849 yyp += yytnamerr (yyp, yyarg[yyi++]);
3850 yyformat += 2;
3851 }
3852 else
3853 {
3854 yyp++;
3855 yyformat++;
3856 }
3857 }
3858 return 0;
3859 }
3860 #endif /* YYERROR_VERBOSE */
3861
3862 /*-----------------------------------------------.
3863 | Release the memory associated to this symbol. |
3864 `-----------------------------------------------*/
3865
3866 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,glslang::TParseContext * pParseContext)3867 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext)
3868 {
3869 YYUSE (yyvaluep);
3870 YYUSE (pParseContext);
3871 if (!yymsg)
3872 yymsg = "Deleting";
3873 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3874
3875 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3876 YYUSE (yytype);
3877 YY_IGNORE_MAYBE_UNINITIALIZED_END
3878 }
3879
3880
3881
3882
3883 /*----------.
3884 | yyparse. |
3885 `----------*/
3886
3887 int
yyparse(glslang::TParseContext * pParseContext)3888 yyparse (glslang::TParseContext* pParseContext)
3889 {
3890 /* The lookahead symbol. */
3891 int yychar;
3892
3893
3894 /* The semantic value of the lookahead symbol. */
3895 /* Default value used for initialization, for pacifying older GCCs
3896 or non-GCC compilers. */
3897 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
3898 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
3899
3900 /* Number of syntax errors so far. */
3901 int yynerrs;
3902
3903 int yystate;
3904 /* Number of tokens to shift before error messages enabled. */
3905 int yyerrstatus;
3906
3907 /* The stacks and their tools:
3908 'yyss': related to states.
3909 'yyvs': related to semantic values.
3910
3911 Refer to the stacks through separate pointers, to allow yyoverflow
3912 to reallocate them elsewhere. */
3913
3914 /* The state stack. */
3915 yytype_int16 yyssa[YYINITDEPTH];
3916 yytype_int16 *yyss;
3917 yytype_int16 *yyssp;
3918
3919 /* The semantic value stack. */
3920 YYSTYPE yyvsa[YYINITDEPTH];
3921 YYSTYPE *yyvs;
3922 YYSTYPE *yyvsp;
3923
3924 YYSIZE_T yystacksize;
3925
3926 int yyn;
3927 int yyresult;
3928 /* Lookahead token as an internal (translated) token number. */
3929 int yytoken = 0;
3930 /* The variables used to return semantic value and location from the
3931 action routines. */
3932 YYSTYPE yyval;
3933
3934 #if YYERROR_VERBOSE
3935 /* Buffer for error messages, and its allocated size. */
3936 char yymsgbuf[128];
3937 char *yymsg = yymsgbuf;
3938 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3939 #endif
3940
3941 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
3942
3943 /* The number of symbols on the RHS of the reduced rule.
3944 Keep to zero when no symbol should be popped. */
3945 int yylen = 0;
3946
3947 yyssp = yyss = yyssa;
3948 yyvsp = yyvs = yyvsa;
3949 yystacksize = YYINITDEPTH;
3950
3951 YYDPRINTF ((stderr, "Starting parse\n"));
3952
3953 yystate = 0;
3954 yyerrstatus = 0;
3955 yynerrs = 0;
3956 yychar = YYEMPTY; /* Cause a token to be read. */
3957 goto yysetstate;
3958
3959 /*------------------------------------------------------------.
3960 | yynewstate -- Push a new state, which is found in yystate. |
3961 `------------------------------------------------------------*/
3962 yynewstate:
3963 /* In all cases, when you get here, the value and location stacks
3964 have just been pushed. So pushing a state here evens the stacks. */
3965 yyssp++;
3966
3967 yysetstate:
3968 *yyssp = yystate;
3969
3970 if (yyss + yystacksize - 1 <= yyssp)
3971 {
3972 /* Get the current used size of the three stacks, in elements. */
3973 YYSIZE_T yysize = yyssp - yyss + 1;
3974
3975 #ifdef yyoverflow
3976 {
3977 /* Give user a chance to reallocate the stack. Use copies of
3978 these so that the &'s don't force the real ones into
3979 memory. */
3980 YYSTYPE *yyvs1 = yyvs;
3981 yytype_int16 *yyss1 = yyss;
3982
3983 /* Each stack pointer address is followed by the size of the
3984 data in use in that stack, in bytes. This used to be a
3985 conditional around just the two extra args, but that might
3986 be undefined if yyoverflow is a macro. */
3987 yyoverflow (YY_("memory exhausted"),
3988 &yyss1, yysize * sizeof (*yyssp),
3989 &yyvs1, yysize * sizeof (*yyvsp),
3990 &yystacksize);
3991
3992 yyss = yyss1;
3993 yyvs = yyvs1;
3994 }
3995 #else /* no yyoverflow */
3996 # ifndef YYSTACK_RELOCATE
3997 goto yyexhaustedlab;
3998 # else
3999 /* Extend the stack our own way. */
4000 if (YYMAXDEPTH <= yystacksize)
4001 goto yyexhaustedlab;
4002 yystacksize *= 2;
4003 if (YYMAXDEPTH < yystacksize)
4004 yystacksize = YYMAXDEPTH;
4005
4006 {
4007 yytype_int16 *yyss1 = yyss;
4008 union yyalloc *yyptr =
4009 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4010 if (! yyptr)
4011 goto yyexhaustedlab;
4012 YYSTACK_RELOCATE (yyss_alloc, yyss);
4013 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4014 # undef YYSTACK_RELOCATE
4015 if (yyss1 != yyssa)
4016 YYSTACK_FREE (yyss1);
4017 }
4018 # endif
4019 #endif /* no yyoverflow */
4020
4021 yyssp = yyss + yysize - 1;
4022 yyvsp = yyvs + yysize - 1;
4023
4024 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4025 (unsigned long int) yystacksize));
4026
4027 if (yyss + yystacksize - 1 <= yyssp)
4028 YYABORT;
4029 }
4030
4031 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4032
4033 if (yystate == YYFINAL)
4034 YYACCEPT;
4035
4036 goto yybackup;
4037
4038 /*-----------.
4039 | yybackup. |
4040 `-----------*/
4041 yybackup:
4042
4043 /* Do appropriate processing given the current state. Read a
4044 lookahead token if we need one and don't already have one. */
4045
4046 /* First try to decide what to do without reference to lookahead token. */
4047 yyn = yypact[yystate];
4048 if (yypact_value_is_default (yyn))
4049 goto yydefault;
4050
4051 /* Not known => get a lookahead token if don't already have one. */
4052
4053 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4054 if (yychar == YYEMPTY)
4055 {
4056 YYDPRINTF ((stderr, "Reading a token: "));
4057 yychar = yylex (&yylval, parseContext);
4058 }
4059
4060 if (yychar <= YYEOF)
4061 {
4062 yychar = yytoken = YYEOF;
4063 YYDPRINTF ((stderr, "Now at end of input.\n"));
4064 }
4065 else
4066 {
4067 yytoken = YYTRANSLATE (yychar);
4068 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4069 }
4070
4071 /* If the proper action on seeing token YYTOKEN is to reduce or to
4072 detect an error, take that action. */
4073 yyn += yytoken;
4074 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4075 goto yydefault;
4076 yyn = yytable[yyn];
4077 if (yyn <= 0)
4078 {
4079 if (yytable_value_is_error (yyn))
4080 goto yyerrlab;
4081 yyn = -yyn;
4082 goto yyreduce;
4083 }
4084
4085 /* Count tokens shifted since error; after three, turn off error
4086 status. */
4087 if (yyerrstatus)
4088 yyerrstatus--;
4089
4090 /* Shift the lookahead token. */
4091 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4092
4093 /* Discard the shifted token. */
4094 yychar = YYEMPTY;
4095
4096 yystate = yyn;
4097 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4098 *++yyvsp = yylval;
4099 YY_IGNORE_MAYBE_UNINITIALIZED_END
4100
4101 goto yynewstate;
4102
4103
4104 /*-----------------------------------------------------------.
4105 | yydefault -- do the default action for the current state. |
4106 `-----------------------------------------------------------*/
4107 yydefault:
4108 yyn = yydefact[yystate];
4109 if (yyn == 0)
4110 goto yyerrlab;
4111 goto yyreduce;
4112
4113
4114 /*-----------------------------.
4115 | yyreduce -- Do a reduction. |
4116 `-----------------------------*/
4117 yyreduce:
4118 /* yyn is the number of a rule to reduce with. */
4119 yylen = yyr2[yyn];
4120
4121 /* If YYLEN is nonzero, implement the default value of the action:
4122 '$$ = $1'.
4123
4124 Otherwise, the following line sets YYVAL to garbage.
4125 This behavior is undocumented and Bison
4126 users should not rely upon it. Assigning to YYVAL
4127 unconditionally makes the parser a bit smaller, and it avoids a
4128 GCC warning that YYVAL may be used uninitialized. */
4129 yyval = yyvsp[1-yylen];
4130
4131
4132 YY_REDUCE_PRINT (yyn);
4133 switch (yyn)
4134 {
4135 case 2:
4136 #line 294 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4137 {
4138 (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string);
4139 }
4140 #line 4141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4141 break;
4142
4143 case 3:
4144 #line 300 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4145 {
4146 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4147 }
4148 #line 4149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4149 break;
4150
4151 case 4:
4152 #line 303 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4153 {
4154 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
4155 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4156 }
4157 #line 4158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4158 break;
4159
4160 case 5:
4161 #line 307 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4162 {
4163 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal");
4164 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4165 }
4166 #line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4167 break;
4168
4169 case 6:
4170 #line 311 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4171 {
4172 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4173 }
4174 #line 4175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4175 break;
4176
4177 case 7:
4178 #line 314 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4179 {
4180 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal");
4181 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4182 }
4183 #line 4184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4184 break;
4185
4186 case 8:
4187 #line 318 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4188 {
4189 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal");
4190 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true);
4191 }
4192 #line 4193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4193 break;
4194
4195 case 9:
4196 #line 322 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4197 {
4198 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal");
4199 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true);
4200 }
4201 #line 4202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4202 break;
4203
4204 case 10:
4205 #line 326 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4206 {
4207 parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal");
4208 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true);
4209 }
4210 #line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4211 break;
4212
4213 case 11:
4214 #line 330 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4215 {
4216 parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal");
4217 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true);
4218 }
4219 #line 4220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4220 break;
4221
4222 case 12:
4223 #line 334 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4224 {
4225 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true);
4226 }
4227 #line 4228 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4228 break;
4229
4230 case 13:
4231 #line 337 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4232 {
4233 parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal");
4234 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true);
4235 }
4236 #line 4237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4237 break;
4238
4239 case 14:
4240 #line 341 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4241 {
4242 parseContext.float16Check((yyvsp[0].lex).loc, "half float literal");
4243 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true);
4244 }
4245 #line 4246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4246 break;
4247
4248 case 15:
4249 #line 345 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4250 {
4251 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true);
4252 }
4253 #line 4254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4254 break;
4255
4256 case 16:
4257 #line 348 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4258 {
4259 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
4260 if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
4261 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
4262 }
4263 #line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4264 break;
4265
4266 case 17:
4267 #line 356 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4268 {
4269 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4270 }
4271 #line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4272 break;
4273
4274 case 18:
4275 #line 359 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4276 {
4277 (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode));
4278 }
4279 #line 4280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4280 break;
4281
4282 case 19:
4283 #line 362 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4284 {
4285 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4286 }
4287 #line 4288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4288 break;
4289
4290 case 20:
4291 #line 365 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4292 {
4293 (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string);
4294 }
4295 #line 4296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4296 break;
4297
4298 case 21:
4299 #line 368 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4300 {
4301 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
4302 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode));
4303 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode));
4304 }
4305 #line 4306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4306 break;
4307
4308 case 22:
4309 #line 373 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4310 {
4311 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode));
4312 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode));
4313 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode));
4314 }
4315 #line 4316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4316 break;
4317
4318 case 23:
4319 #line 381 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4320 {
4321 parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]");
4322 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4323 }
4324 #line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4325 break;
4326
4327 case 24:
4328 #line 388 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4329 {
4330 (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode);
4331 delete (yyvsp[0].interm).function;
4332 }
4333 #line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4334 break;
4335
4336 case 25:
4337 #line 395 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4338 {
4339 (yyval.interm) = (yyvsp[0].interm);
4340 }
4341 #line 4342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4342 break;
4343
4344 case 26:
4345 #line 401 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4346 {
4347 (yyval.interm) = (yyvsp[-1].interm);
4348 (yyval.interm).loc = (yyvsp[0].lex).loc;
4349 }
4350 #line 4351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4351 break;
4352
4353 case 27:
4354 #line 405 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4355 {
4356 (yyval.interm) = (yyvsp[-1].interm);
4357 (yyval.interm).loc = (yyvsp[0].lex).loc;
4358 }
4359 #line 4360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4360 break;
4361
4362 case 28:
4363 #line 412 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4364 {
4365 (yyval.interm) = (yyvsp[-1].interm);
4366 }
4367 #line 4368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4368 break;
4369
4370 case 29:
4371 #line 415 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4372 {
4373 (yyval.interm) = (yyvsp[0].interm);
4374 }
4375 #line 4376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4376 break;
4377
4378 case 30:
4379 #line 421 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4380 {
4381 TParameter param = { 0, new TType };
4382 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
4383 (yyvsp[-1].interm).function->addParameter(param);
4384 (yyval.interm).function = (yyvsp[-1].interm).function;
4385 (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode);
4386 }
4387 #line 4388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4388 break;
4389
4390 case 31:
4391 #line 428 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4392 {
4393 TParameter param = { 0, new TType };
4394 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType());
4395 (yyvsp[-2].interm).function->addParameter(param);
4396 (yyval.interm).function = (yyvsp[-2].interm).function;
4397 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
4398 }
4399 #line 4400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4400 break;
4401
4402 case 32:
4403 #line 438 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4404 {
4405 (yyval.interm) = (yyvsp[-1].interm);
4406 }
4407 #line 4408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4408 break;
4409
4410 case 33:
4411 #line 446 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4412 {
4413 // Constructor
4414 (yyval.interm).intermNode = 0;
4415 (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
4416 }
4417 #line 4418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4418 break;
4419
4420 case 34:
4421 #line 451 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4422 {
4423 //
4424 // Should be a method or subroutine call, but we haven't recognized the arguments yet.
4425 //
4426 (yyval.interm).function = 0;
4427 (yyval.interm).intermNode = 0;
4428
4429 TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode();
4430 if (method) {
4431 (yyval.interm).function = new TFunction(&method->getMethodName(), TType(EbtInt), EOpArrayLength);
4432 (yyval.interm).intermNode = method->getObject();
4433 } else {
4434 TIntermSymbol* symbol = (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode();
4435 if (symbol) {
4436 parseContext.reservedErrorCheck(symbol->getLoc(), symbol->getName());
4437 TFunction *function = new TFunction(&symbol->getName(), TType(EbtVoid));
4438 (yyval.interm).function = function;
4439 } else
4440 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "function call, method, or subroutine call expected", "", "");
4441 }
4442
4443 if ((yyval.interm).function == 0) {
4444 // error recover
4445 TString empty("");
4446 (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull);
4447 }
4448 }
4449 #line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4450 break;
4451
4452 case 35:
4453 #line 478 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4454 {
4455 // Constructor
4456 (yyval.interm).intermNode = 0;
4457 (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type));
4458 }
4459 #line 4460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4460 break;
4461
4462 case 36:
4463 #line 486 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4464 {
4465 parseContext.variableCheck((yyvsp[0].interm.intermTypedNode));
4466 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4467 if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode())
4468 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), "");
4469 }
4470 #line 4471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4471 break;
4472
4473 case 37:
4474 #line 492 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4475 {
4476 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode));
4477 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode));
4478 }
4479 #line 4480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4480 break;
4481
4482 case 38:
4483 #line 496 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4484 {
4485 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode));
4486 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode));
4487 }
4488 #line 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4489 break;
4490
4491 case 39:
4492 #line 500 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4493 {
4494 if ((yyvsp[-1].interm).op != EOpNull) {
4495 char errorOp[2] = {0, 0};
4496 switch((yyvsp[-1].interm).op) {
4497 case EOpNegative: errorOp[0] = '-'; break;
4498 case EOpLogicalNot: errorOp[0] = '!'; break;
4499 case EOpBitwiseNot: errorOp[0] = '~'; break;
4500 default: break; // some compilers want this
4501 }
4502 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].interm).loc, errorOp, (yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode));
4503 } else {
4504 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4505 if ((yyval.interm.intermTypedNode)->getAsConstantUnion())
4506 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression();
4507 }
4508 }
4509 #line 4510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4510 break;
4511
4512 case 40:
4513 #line 520 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4514 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; }
4515 #line 4516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4516 break;
4517
4518 case 41:
4519 #line 521 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4520 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; }
4521 #line 4522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4522 break;
4523
4524 case 42:
4525 #line 522 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4526 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; }
4527 #line 4528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4528 break;
4529
4530 case 43:
4531 #line 523 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4532 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot;
4533 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); }
4534 #line 4535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4535 break;
4536
4537 case 44:
4538 #line 529 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4539 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4540 #line 4541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4541 break;
4542
4543 case 45:
4544 #line 530 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4545 {
4546 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4547 if ((yyval.interm.intermTypedNode) == 0)
4548 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4549 }
4550 #line 4551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4551 break;
4552
4553 case 46:
4554 #line 535 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4555 {
4556 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4557 if ((yyval.interm.intermTypedNode) == 0)
4558 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4559 }
4560 #line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4561 break;
4562
4563 case 47:
4564 #line 540 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4565 {
4566 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%");
4567 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4568 if ((yyval.interm.intermTypedNode) == 0)
4569 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4570 }
4571 #line 4572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4572 break;
4573
4574 case 48:
4575 #line 549 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4576 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4577 #line 4578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4578 break;
4579
4580 case 49:
4581 #line 550 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4582 {
4583 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4584 if ((yyval.interm.intermTypedNode) == 0)
4585 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4586 }
4587 #line 4588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4588 break;
4589
4590 case 50:
4591 #line 555 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4592 {
4593 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4594 if ((yyval.interm.intermTypedNode) == 0)
4595 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4596 }
4597 #line 4598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4598 break;
4599
4600 case 51:
4601 #line 563 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4602 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4603 #line 4604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4604 break;
4605
4606 case 52:
4607 #line 564 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4608 {
4609 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left");
4610 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4611 if ((yyval.interm.intermTypedNode) == 0)
4612 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4613 }
4614 #line 4615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4615 break;
4616
4617 case 53:
4618 #line 570 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4619 {
4620 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right");
4621 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4622 if ((yyval.interm.intermTypedNode) == 0)
4623 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4624 }
4625 #line 4626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4626 break;
4627
4628 case 54:
4629 #line 579 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4630 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4631 #line 4632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4632 break;
4633
4634 case 55:
4635 #line 580 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4636 {
4637 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4638 if ((yyval.interm.intermTypedNode) == 0)
4639 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4640 }
4641 #line 4642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4642 break;
4643
4644 case 56:
4645 #line 585 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4646 {
4647 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4648 if ((yyval.interm.intermTypedNode) == 0)
4649 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4650 }
4651 #line 4652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4652 break;
4653
4654 case 57:
4655 #line 590 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4656 {
4657 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4658 if ((yyval.interm.intermTypedNode) == 0)
4659 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4660 }
4661 #line 4662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4662 break;
4663
4664 case 58:
4665 #line 595 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4666 {
4667 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4668 if ((yyval.interm.intermTypedNode) == 0)
4669 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4670 }
4671 #line 4672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4672 break;
4673
4674 case 59:
4675 #line 603 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4676 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4677 #line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4678 break;
4679
4680 case 60:
4681 #line 604 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4682 {
4683 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
4684 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
4685 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "==");
4686 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "==", EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4687 if ((yyval.interm.intermTypedNode) == 0)
4688 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4689 }
4690 #line 4691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4691 break;
4692
4693 case 61:
4694 #line 612 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4695 {
4696 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison");
4697 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
4698 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!=");
4699 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "!=", EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4700 if ((yyval.interm.intermTypedNode) == 0)
4701 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4702 }
4703 #line 4704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4704 break;
4705
4706 case 62:
4707 #line 623 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4708 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4709 #line 4710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4710 break;
4711
4712 case 63:
4713 #line 624 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4714 {
4715 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and");
4716 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4717 if ((yyval.interm.intermTypedNode) == 0)
4718 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4719 }
4720 #line 4721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4721 break;
4722
4723 case 64:
4724 #line 633 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4725 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4726 #line 4727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4727 break;
4728
4729 case 65:
4730 #line 634 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4731 {
4732 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or");
4733 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4734 if ((yyval.interm.intermTypedNode) == 0)
4735 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4736 }
4737 #line 4738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4738 break;
4739
4740 case 66:
4741 #line 643 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4742 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4743 #line 4744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4744 break;
4745
4746 case 67:
4747 #line 644 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4748 {
4749 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or");
4750 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4751 if ((yyval.interm.intermTypedNode) == 0)
4752 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4753 }
4754 #line 4755 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4755 break;
4756
4757 case 68:
4758 #line 653 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4759 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4760 #line 4761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4761 break;
4762
4763 case 69:
4764 #line 654 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4765 {
4766 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4767 if ((yyval.interm.intermTypedNode) == 0)
4768 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4769 }
4770 #line 4771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4771 break;
4772
4773 case 70:
4774 #line 662 "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 71:
4780 #line 663 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4781 {
4782 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4783 if ((yyval.interm.intermTypedNode) == 0)
4784 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4785 }
4786 #line 4787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4787 break;
4788
4789 case 72:
4790 #line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4791 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4792 #line 4793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4793 break;
4794
4795 case 73:
4796 #line 672 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4797 {
4798 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
4799 if ((yyval.interm.intermTypedNode) == 0)
4800 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc);
4801 }
4802 #line 4803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4803 break;
4804
4805 case 74:
4806 #line 680 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4807 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4808 #line 4809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4809 break;
4810
4811 case 75:
4812 #line 681 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4813 {
4814 ++parseContext.controlFlowNestingLevel;
4815 }
4816 #line 4817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4817 break;
4818
4819 case 76:
4820 #line 684 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4821 {
4822 --parseContext.controlFlowNestingLevel;
4823 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode));
4824 parseContext.rValueErrorCheck((yyvsp[-4].lex).loc, "?", (yyvsp[-5].interm.intermTypedNode));
4825 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode));
4826 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[0].interm.intermTypedNode));
4827 (yyval.interm.intermTypedNode) = parseContext.intermediate.addSelection((yyvsp[-5].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-4].lex).loc);
4828 if ((yyval.interm.intermTypedNode) == 0) {
4829 parseContext.binaryOpError((yyvsp[-4].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
4830 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4831 }
4832 }
4833 #line 4834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4834 break;
4835
4836 case 77:
4837 #line 699 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4838 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4839 #line 4840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4840 break;
4841
4842 case 78:
4843 #line 700 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4844 {
4845 parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment");
4846 parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4847 parseContext.storage16BitAssignmentCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4848 parseContext.specializationCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=");
4849 parseContext.lValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode));
4850 parseContext.rValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[0].interm.intermTypedNode));
4851 (yyval.interm.intermTypedNode) = parseContext.intermediate.addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].interm).loc);
4852 if ((yyval.interm.intermTypedNode) == 0) {
4853 parseContext.assignError((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
4854 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
4855 }
4856 }
4857 #line 4858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4858 break;
4859
4860 case 79:
4861 #line 716 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4862 {
4863 (yyval.interm).loc = (yyvsp[0].lex).loc;
4864 (yyval.interm).op = EOpAssign;
4865 }
4866 #line 4867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4867 break;
4868
4869 case 80:
4870 #line 720 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4871 {
4872 (yyval.interm).loc = (yyvsp[0].lex).loc;
4873 (yyval.interm).op = EOpMulAssign;
4874 }
4875 #line 4876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4876 break;
4877
4878 case 81:
4879 #line 724 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4880 {
4881 (yyval.interm).loc = (yyvsp[0].lex).loc;
4882 (yyval.interm).op = EOpDivAssign;
4883 }
4884 #line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4885 break;
4886
4887 case 82:
4888 #line 728 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4889 {
4890 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%=");
4891 (yyval.interm).loc = (yyvsp[0].lex).loc;
4892 (yyval.interm).op = EOpModAssign;
4893 }
4894 #line 4895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4895 break;
4896
4897 case 83:
4898 #line 733 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4899 {
4900 (yyval.interm).loc = (yyvsp[0].lex).loc;
4901 (yyval.interm).op = EOpAddAssign;
4902 }
4903 #line 4904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4904 break;
4905
4906 case 84:
4907 #line 737 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4908 {
4909 (yyval.interm).loc = (yyvsp[0].lex).loc;
4910 (yyval.interm).op = EOpSubAssign;
4911 }
4912 #line 4913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4913 break;
4914
4915 case 85:
4916 #line 741 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4917 {
4918 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign");
4919 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign;
4920 }
4921 #line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4922 break;
4923
4924 case 86:
4925 #line 745 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4926 {
4927 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign");
4928 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign;
4929 }
4930 #line 4931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4931 break;
4932
4933 case 87:
4934 #line 749 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4935 {
4936 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign");
4937 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign;
4938 }
4939 #line 4940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4940 break;
4941
4942 case 88:
4943 #line 753 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4944 {
4945 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign");
4946 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign;
4947 }
4948 #line 4949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4949 break;
4950
4951 case 89:
4952 #line 757 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4953 {
4954 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign");
4955 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign;
4956 }
4957 #line 4958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4958 break;
4959
4960 case 90:
4961 #line 764 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4962 {
4963 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4964 }
4965 #line 4966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4966 break;
4967
4968 case 91:
4969 #line 767 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4970 {
4971 parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode));
4972 (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc);
4973 if ((yyval.interm.intermTypedNode) == 0) {
4974 parseContext.binaryOpError((yyvsp[-1].lex).loc, ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
4975 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4976 }
4977 }
4978 #line 4979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4979 break;
4980
4981 case 92:
4982 #line 778 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4983 {
4984 parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), "");
4985 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4986 }
4987 #line 4988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4988 break;
4989
4990 case 93:
4991 #line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */
4992 {
4993 parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */);
4994 (yyval.interm.intermNode) = 0;
4995 // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature
4996 }
4997 #line 4998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
4998 break;
4999
5000 case 94:
5001 #line 790 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5002 {
5003 if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate())
5004 (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence);
5005 (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode;
5006 }
5007 #line 5008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5008 break;
5009
5010 case 95:
5011 #line 795 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5012 {
5013 parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement");
5014
5015 // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope
5016 parseContext.symbolTable.setPreviousDefaultPrecisions(&parseContext.defaultPrecision[0]);
5017 parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision);
5018 (yyval.interm.intermNode) = 0;
5019 }
5020 #line 5021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5021 break;
5022
5023 case 96:
5024 #line 803 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5025 {
5026 parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList);
5027 (yyval.interm.intermNode) = 0;
5028 }
5029 #line 5030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5030 break;
5031
5032 case 97:
5033 #line 807 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5034 {
5035 parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string);
5036 (yyval.interm.intermNode) = 0;
5037 }
5038 #line 5039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5039 break;
5040
5041 case 98:
5042 #line 811 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5043 {
5044 parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes);
5045 (yyval.interm.intermNode) = 0;
5046 }
5047 #line 5048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5048 break;
5049
5050 case 99:
5051 #line 815 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5052 {
5053 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
5054 parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type));
5055 (yyval.interm.intermNode) = 0;
5056 }
5057 #line 5058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5058 break;
5059
5060 case 100:
5061 #line 820 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5062 {
5063 parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers);
5064 parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string);
5065 (yyval.interm.intermNode) = 0;
5066 }
5067 #line 5068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5068 break;
5069
5070 case 101:
5071 #line 825 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5072 {
5073 parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers);
5074 (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string);
5075 parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList));
5076 (yyval.interm.intermNode) = 0;
5077 }
5078 #line 5079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5079 break;
5080
5081 case 102:
5082 #line 834 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5083 { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); }
5084 #line 5085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5085 break;
5086
5087 case 103:
5088 #line 834 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5089 {
5090 --parseContext.structNestingLevel;
5091 parseContext.blockName = (yyvsp[-4].lex).string;
5092 parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier);
5093 parseContext.checkNoShaderLayouts((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).shaderQualifiers);
5094 parseContext.currentBlockQualifier = (yyvsp[-5].interm.type).qualifier;
5095 (yyval.interm).loc = (yyvsp[-5].interm.type).loc;
5096 (yyval.interm).typeList = (yyvsp[-1].interm.typeList);
5097 }
5098 #line 5099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5099 break;
5100
5101 case 104:
5102 #line 845 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5103 {
5104 (yyval.interm.identifierList) = new TIdentifierList;
5105 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
5106 }
5107 #line 5108 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5108 break;
5109
5110 case 105:
5111 #line 849 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5112 {
5113 (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList);
5114 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string);
5115 }
5116 #line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5117 break;
5118
5119 case 106:
5120 #line 856 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5121 {
5122 (yyval.interm).function = (yyvsp[-1].interm.function);
5123 (yyval.interm).loc = (yyvsp[0].lex).loc;
5124 }
5125 #line 5126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5126 break;
5127
5128 case 107:
5129 #line 863 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5130 {
5131 (yyval.interm.function) = (yyvsp[0].interm.function);
5132 }
5133 #line 5134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5134 break;
5135
5136 case 108:
5137 #line 866 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5138 {
5139 (yyval.interm.function) = (yyvsp[0].interm.function);
5140 }
5141 #line 5142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5142 break;
5143
5144 case 109:
5145 #line 873 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5146 {
5147 // Add the parameter
5148 (yyval.interm.function) = (yyvsp[-1].interm.function);
5149 if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid)
5150 (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param);
5151 else
5152 delete (yyvsp[0].interm).param.type;
5153 }
5154 #line 5155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5155 break;
5156
5157 case 110:
5158 #line 881 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5159 {
5160 //
5161 // Only first parameter of one-parameter functions can be void
5162 // The check for named parameters not being void is done in parameter_declarator
5163 //
5164 if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) {
5165 //
5166 // This parameter > first is void
5167 //
5168 parseContext.error((yyvsp[-1].lex).loc, "cannot be an argument type except for '(void)'", "void", "");
5169 delete (yyvsp[0].interm).param.type;
5170 } else {
5171 // Add the parameter
5172 (yyval.interm.function) = (yyvsp[-2].interm.function);
5173 (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
5174 }
5175 }
5176 #line 5177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5177 break;
5178
5179 case 111:
5180 #line 901 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5181 {
5182 if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) {
5183 parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return",
5184 GetStorageQualifierString((yyvsp[-2].interm.type).qualifier.storage), "");
5185 }
5186 if ((yyvsp[-2].interm.type).arraySizes)
5187 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
5188
5189 // Add the function as a prototype after parsing it (we do not support recursion)
5190 TFunction *function;
5191 TType type((yyvsp[-2].interm.type));
5192
5193 // Potentially rename shader entry point function. No-op most of the time.
5194 parseContext.renameShaderFunction((yyvsp[-1].lex).string);
5195
5196 // Make the function
5197 function = new TFunction((yyvsp[-1].lex).string, type);
5198 (yyval.interm.function) = function;
5199 }
5200 #line 5201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5201 break;
5202
5203 case 112:
5204 #line 924 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5205 {
5206 if ((yyvsp[-1].interm.type).arraySizes) {
5207 parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5208 parseContext.profileRequires((yyvsp[-1].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5209 parseContext.arraySizeRequiredCheck((yyvsp[-1].interm.type).loc, *(yyvsp[-1].interm.type).arraySizes);
5210 }
5211 if ((yyvsp[-1].interm.type).basicType == EbtVoid) {
5212 parseContext.error((yyvsp[0].lex).loc, "illegal use of type 'void'", (yyvsp[0].lex).string->c_str(), "");
5213 }
5214 parseContext.reservedErrorCheck((yyvsp[0].lex).loc, *(yyvsp[0].lex).string);
5215
5216 TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))};
5217 (yyval.interm).loc = (yyvsp[0].lex).loc;
5218 (yyval.interm).param = param;
5219 }
5220 #line 5221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5221 break;
5222
5223 case 113:
5224 #line 939 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5225 {
5226 if ((yyvsp[-2].interm.type).arraySizes) {
5227 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5228 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5229 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
5230 }
5231 TType* type = new TType((yyvsp[-2].interm.type));
5232 type->transferArraySizes((yyvsp[0].interm).arraySizes);
5233 type->copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
5234
5235 parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, type->getArraySizes());
5236 parseContext.arraySizeRequiredCheck((yyvsp[0].interm).loc, *(yyvsp[0].interm).arraySizes);
5237 parseContext.reservedErrorCheck((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string);
5238
5239 TParameter param = { (yyvsp[-1].lex).string, type };
5240
5241 (yyval.interm).loc = (yyvsp[-1].lex).loc;
5242 (yyval.interm).param = param;
5243 }
5244 #line 5245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5245 break;
5246
5247 case 114:
5248 #line 964 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5249 {
5250 (yyval.interm) = (yyvsp[0].interm);
5251 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
5252 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
5253 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5254
5255 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5256 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
5257 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
5258
5259 }
5260 #line 5261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5261 break;
5262
5263 case 115:
5264 #line 975 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5265 {
5266 (yyval.interm) = (yyvsp[0].interm);
5267
5268 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
5269 parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
5270 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5271 }
5272 #line 5273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5273 break;
5274
5275 case 116:
5276 #line 985 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5277 {
5278 (yyval.interm) = (yyvsp[0].interm);
5279 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone)
5280 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision;
5281 parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5282
5283 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5284 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type);
5285 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type);
5286 }
5287 #line 5288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5288 break;
5289
5290 case 117:
5291 #line 995 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5292 {
5293 (yyval.interm) = (yyvsp[0].interm);
5294
5295 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type);
5296 parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type);
5297 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier());
5298 }
5299 #line 5300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5300 break;
5301
5302 case 118:
5303 #line 1005 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5304 {
5305 TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
5306 (yyval.interm).param = param;
5307 if ((yyvsp[0].interm.type).arraySizes)
5308 parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes);
5309 }
5310 #line 5311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5311 break;
5312
5313 case 119:
5314 #line 1014 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5315 {
5316 (yyval.interm) = (yyvsp[0].interm);
5317 }
5318 #line 5319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5319 break;
5320
5321 case 120:
5322 #line 1017 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5323 {
5324 (yyval.interm) = (yyvsp[-2].interm);
5325 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type);
5326 }
5327 #line 5328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5328 break;
5329
5330 case 121:
5331 #line 1021 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5332 {
5333 (yyval.interm) = (yyvsp[-3].interm);
5334 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes);
5335 }
5336 #line 5337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5337 break;
5338
5339 case 122:
5340 #line 1025 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5341 {
5342 (yyval.interm).type = (yyvsp[-5].interm).type;
5343 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
5344 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
5345 }
5346 #line 5347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5347 break;
5348
5349 case 123:
5350 #line 1030 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5351 {
5352 (yyval.interm).type = (yyvsp[-4].interm).type;
5353 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode));
5354 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc);
5355 }
5356 #line 5357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5357 break;
5358
5359 case 124:
5360 #line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5361 {
5362 (yyval.interm).type = (yyvsp[0].interm.type);
5363 (yyval.interm).intermNode = 0;
5364 parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type);
5365 }
5366 #line 5367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5367 break;
5368
5369 case 125:
5370 #line 1043 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5371 {
5372 (yyval.interm).type = (yyvsp[-1].interm.type);
5373 (yyval.interm).intermNode = 0;
5374 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type));
5375 }
5376 #line 5377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5377 break;
5378
5379 case 126:
5380 #line 1048 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5381 {
5382 (yyval.interm).type = (yyvsp[-2].interm.type);
5383 (yyval.interm).intermNode = 0;
5384 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes);
5385 }
5386 #line 5387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5387 break;
5388
5389 case 127:
5390 #line 1053 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5391 {
5392 (yyval.interm).type = (yyvsp[-4].interm.type);
5393 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode));
5394 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
5395 }
5396 #line 5397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5397 break;
5398
5399 case 128:
5400 #line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5401 {
5402 (yyval.interm).type = (yyvsp[-3].interm.type);
5403 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
5404 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc);
5405 }
5406 #line 5407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5407 break;
5408
5409 case 129:
5410 #line 1067 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5411 {
5412 (yyval.interm.type) = (yyvsp[0].interm.type);
5413
5414 parseContext.globalQualifierTypeCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyval.interm.type));
5415 if ((yyvsp[0].interm.type).arraySizes) {
5416 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5417 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5418 }
5419
5420 parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier);
5421 }
5422 #line 5423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5423 break;
5424
5425 case 130:
5426 #line 1078 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5427 {
5428 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier);
5429 parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type));
5430
5431 if ((yyvsp[0].interm.type).arraySizes) {
5432 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
5433 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
5434 }
5435
5436 if ((yyvsp[0].interm.type).arraySizes && parseContext.arrayQualifierError((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).qualifier))
5437 (yyvsp[0].interm.type).arraySizes = nullptr;
5438
5439 parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers);
5440 (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers);
5441 parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true);
5442 parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier);
5443
5444 (yyval.interm.type) = (yyvsp[0].interm.type);
5445
5446 if (! (yyval.interm.type).qualifier.isInterpolation() &&
5447 ((parseContext.language == EShLangVertex && (yyval.interm.type).qualifier.storage == EvqVaryingOut) ||
5448 (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn)))
5449 (yyval.interm.type).qualifier.smooth = true;
5450 }
5451 #line 5452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5452 break;
5453
5454 case 131:
5455 #line 1105 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5456 {
5457 parseContext.globalCheck((yyvsp[0].lex).loc, "invariant");
5458 parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant");
5459 (yyval.interm.type).init((yyvsp[0].lex).loc);
5460 (yyval.interm.type).qualifier.invariant = true;
5461 }
5462 #line 5463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5463 break;
5464
5465 case 132:
5466 #line 1114 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5467 {
5468 parseContext.globalCheck((yyvsp[0].lex).loc, "smooth");
5469 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth");
5470 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "smooth");
5471 (yyval.interm.type).init((yyvsp[0].lex).loc);
5472 (yyval.interm.type).qualifier.smooth = true;
5473 }
5474 #line 5475 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5475 break;
5476
5477 case 133:
5478 #line 1121 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5479 {
5480 parseContext.globalCheck((yyvsp[0].lex).loc, "flat");
5481 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat");
5482 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "flat");
5483 (yyval.interm.type).init((yyvsp[0].lex).loc);
5484 (yyval.interm.type).qualifier.flat = true;
5485 }
5486 #line 5487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5487 break;
5488
5489 case 134:
5490 #line 1128 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5491 {
5492 parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective");
5493 #ifdef NV_EXTENSIONS
5494 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective");
5495 #else
5496 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "noperspective");
5497 #endif
5498 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "noperspective");
5499 (yyval.interm.type).init((yyvsp[0].lex).loc);
5500 (yyval.interm.type).qualifier.nopersp = true;
5501 }
5502 #line 5503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5503 break;
5504
5505 case 135:
5506 #line 1139 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5507 {
5508 #ifdef AMD_EXTENSIONS
5509 parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD");
5510 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
5511 parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation");
5512 (yyval.interm.type).init((yyvsp[0].lex).loc);
5513 (yyval.interm.type).qualifier.explicitInterp = true;
5514 #endif
5515 }
5516 #line 5517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5517 break;
5518
5519 case 136:
5520 #line 1148 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5521 {
5522 #ifdef NV_EXTENSIONS
5523 parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV");
5524 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5525 parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5526 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric");
5527 (yyval.interm.type).init((yyvsp[0].lex).loc);
5528 (yyval.interm.type).qualifier.pervertexNV = true;
5529 #endif
5530 }
5531 #line 5532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5532 break;
5533
5534 case 137:
5535 #line 1158 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5536 {
5537 #ifdef NV_EXTENSIONS
5538 // No need for profile version or extension check. Shader stage already checks both.
5539 parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV");
5540 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangFragmentMask | EShLangMeshNVMask), "perprimitiveNV");
5541 // Fragment shader stage doesn't check for extension. So we explicitly add below extension check.
5542 if (parseContext.language == EShLangFragment)
5543 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_NV_mesh_shader, "perprimitiveNV");
5544 (yyval.interm.type).init((yyvsp[0].lex).loc);
5545 (yyval.interm.type).qualifier.perPrimitiveNV = true;
5546 #endif
5547 }
5548 #line 5549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5549 break;
5550
5551 case 138:
5552 #line 1170 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5553 {
5554 #ifdef NV_EXTENSIONS
5555 // No need for profile version or extension check. Shader stage already checks both.
5556 parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV");
5557 parseContext.requireStage((yyvsp[0].lex).loc, EShLangMeshNV, "perviewNV");
5558 (yyval.interm.type).init((yyvsp[0].lex).loc);
5559 (yyval.interm.type).qualifier.perViewNV = true;
5560 #endif
5561 }
5562 #line 5563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5563 break;
5564
5565 case 139:
5566 #line 1179 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5567 {
5568 #ifdef NV_EXTENSIONS
5569 // No need for profile version or extension check. Shader stage already checks both.
5570 parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV");
5571 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask), "taskNV");
5572 (yyval.interm.type).init((yyvsp[0].lex).loc);
5573 (yyval.interm.type).qualifier.perTaskNV = true;
5574 #endif
5575 }
5576 #line 5577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5577 break;
5578
5579 case 140:
5580 #line 1191 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5581 {
5582 (yyval.interm.type) = (yyvsp[-1].interm.type);
5583 }
5584 #line 5585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5585 break;
5586
5587 case 141:
5588 #line 1197 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5589 {
5590 (yyval.interm.type) = (yyvsp[0].interm.type);
5591 }
5592 #line 5593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5593 break;
5594
5595 case 142:
5596 #line 1200 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5597 {
5598 (yyval.interm.type) = (yyvsp[-2].interm.type);
5599 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
5600 parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
5601 }
5602 #line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5603 break;
5604
5605 case 143:
5606 #line 1207 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5607 {
5608 (yyval.interm.type).init((yyvsp[0].lex).loc);
5609 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string);
5610 }
5611 #line 5612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5612 break;
5613
5614 case 144:
5615 #line 1211 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5616 {
5617 (yyval.interm.type).init((yyvsp[-2].lex).loc);
5618 parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode));
5619 }
5620 #line 5621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5621 break;
5622
5623 case 145:
5624 #line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5625 { // because "shared" is both an identifier and a keyword
5626 (yyval.interm.type).init((yyvsp[0].lex).loc);
5627 TString strShared("shared");
5628 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared);
5629 }
5630 #line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5631 break;
5632
5633 case 146:
5634 #line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5635 {
5636 parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise");
5637 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise");
5638 (yyval.interm.type).init((yyvsp[0].lex).loc);
5639 (yyval.interm.type).qualifier.noContraction = true;
5640 }
5641 #line 5642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5642 break;
5643
5644 case 147:
5645 #line 1232 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5646 {
5647 (yyval.interm.type) = (yyvsp[0].interm.type);
5648 }
5649 #line 5650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5650 break;
5651
5652 case 148:
5653 #line 1235 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5654 {
5655 (yyval.interm.type) = (yyvsp[-1].interm.type);
5656 if ((yyval.interm.type).basicType == EbtVoid)
5657 (yyval.interm.type).basicType = (yyvsp[0].interm.type).basicType;
5658
5659 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers);
5660 parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false);
5661 }
5662 #line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5663 break;
5664
5665 case 149:
5666 #line 1246 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5667 {
5668 (yyval.interm.type) = (yyvsp[0].interm.type);
5669 }
5670 #line 5671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5671 break;
5672
5673 case 150:
5674 #line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5675 {
5676 (yyval.interm.type) = (yyvsp[0].interm.type);
5677 }
5678 #line 5679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5679 break;
5680
5681 case 151:
5682 #line 1252 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5683 {
5684 parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision);
5685 (yyval.interm.type) = (yyvsp[0].interm.type);
5686 }
5687 #line 5688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5688 break;
5689
5690 case 152:
5691 #line 1256 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5692 {
5693 // allow inheritance of storage qualifier from block declaration
5694 (yyval.interm.type) = (yyvsp[0].interm.type);
5695 }
5696 #line 5697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5697 break;
5698
5699 case 153:
5700 #line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5701 {
5702 // allow inheritance of storage qualifier from block declaration
5703 (yyval.interm.type) = (yyvsp[0].interm.type);
5704 }
5705 #line 5706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5706 break;
5707
5708 case 154:
5709 #line 1264 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5710 {
5711 // allow inheritance of storage qualifier from block declaration
5712 (yyval.interm.type) = (yyvsp[0].interm.type);
5713 }
5714 #line 5715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5715 break;
5716
5717 case 155:
5718 #line 1268 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5719 {
5720 (yyval.interm.type) = (yyvsp[0].interm.type);
5721 }
5722 #line 5723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5723 break;
5724
5725 case 156:
5726 #line 1274 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5727 {
5728 (yyval.interm.type).init((yyvsp[0].lex).loc);
5729 (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant
5730 }
5731 #line 5732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5732 break;
5733
5734 case 157:
5735 #line 1278 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5736 {
5737 parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute");
5738 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute");
5739 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "attribute");
5740 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "attribute");
5741 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "attribute");
5742
5743 parseContext.globalCheck((yyvsp[0].lex).loc, "attribute");
5744
5745 (yyval.interm.type).init((yyvsp[0].lex).loc);
5746 (yyval.interm.type).qualifier.storage = EvqVaryingIn;
5747 }
5748 #line 5749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5749 break;
5750
5751 case 158:
5752 #line 1290 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5753 {
5754 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying");
5755 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying");
5756 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "varying");
5757 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "varying");
5758
5759 parseContext.globalCheck((yyvsp[0].lex).loc, "varying");
5760
5761 (yyval.interm.type).init((yyvsp[0].lex).loc);
5762 if (parseContext.language == EShLangVertex)
5763 (yyval.interm.type).qualifier.storage = EvqVaryingOut;
5764 else
5765 (yyval.interm.type).qualifier.storage = EvqVaryingIn;
5766 }
5767 #line 5768 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5768 break;
5769
5770 case 159:
5771 #line 1304 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5772 {
5773 parseContext.globalCheck((yyvsp[0].lex).loc, "inout");
5774 (yyval.interm.type).init((yyvsp[0].lex).loc);
5775 (yyval.interm.type).qualifier.storage = EvqInOut;
5776 }
5777 #line 5778 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5778 break;
5779
5780 case 160:
5781 #line 1309 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5782 {
5783 parseContext.globalCheck((yyvsp[0].lex).loc, "in");
5784 (yyval.interm.type).init((yyvsp[0].lex).loc);
5785 // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later
5786 (yyval.interm.type).qualifier.storage = EvqIn;
5787 }
5788 #line 5789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5789 break;
5790
5791 case 161:
5792 #line 1315 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5793 {
5794 parseContext.globalCheck((yyvsp[0].lex).loc, "out");
5795 (yyval.interm.type).init((yyvsp[0].lex).loc);
5796 // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later
5797 (yyval.interm.type).qualifier.storage = EvqOut;
5798 }
5799 #line 5800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5800 break;
5801
5802 case 162:
5803 #line 1321 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5804 {
5805 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid");
5806 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid");
5807 parseContext.globalCheck((yyvsp[0].lex).loc, "centroid");
5808 (yyval.interm.type).init((yyvsp[0].lex).loc);
5809 (yyval.interm.type).qualifier.centroid = true;
5810 }
5811 #line 5812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5812 break;
5813
5814 case 163:
5815 #line 1328 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5816 {
5817 parseContext.globalCheck((yyvsp[0].lex).loc, "patch");
5818 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch");
5819 (yyval.interm.type).init((yyvsp[0].lex).loc);
5820 (yyval.interm.type).qualifier.patch = true;
5821 }
5822 #line 5823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5823 break;
5824
5825 case 164:
5826 #line 1334 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5827 {
5828 parseContext.globalCheck((yyvsp[0].lex).loc, "sample");
5829 (yyval.interm.type).init((yyvsp[0].lex).loc);
5830 (yyval.interm.type).qualifier.sample = true;
5831 }
5832 #line 5833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5833 break;
5834
5835 case 165:
5836 #line 1339 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5837 {
5838 parseContext.globalCheck((yyvsp[0].lex).loc, "uniform");
5839 (yyval.interm.type).init((yyvsp[0].lex).loc);
5840 (yyval.interm.type).qualifier.storage = EvqUniform;
5841 }
5842 #line 5843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5843 break;
5844
5845 case 166:
5846 #line 1344 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5847 {
5848 parseContext.globalCheck((yyvsp[0].lex).loc, "buffer");
5849 (yyval.interm.type).init((yyvsp[0].lex).loc);
5850 (yyval.interm.type).qualifier.storage = EvqBuffer;
5851 }
5852 #line 5853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5853 break;
5854
5855 case 167:
5856 #line 1349 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5857 {
5858 #ifdef NV_EXTENSIONS
5859 parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV");
5860 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangClosestHitNVMask
5861 | EShLangAnyHitNVMask), "hitAttributeNV");
5862 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV");
5863 (yyval.interm.type).init((yyvsp[0].lex).loc);
5864 (yyval.interm.type).qualifier.storage = EvqHitAttrNV;
5865 #endif
5866 }
5867 #line 5868 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5868 break;
5869
5870 case 168:
5871 #line 1359 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5872 {
5873 #ifdef NV_EXTENSIONS
5874 parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV");
5875 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask |
5876 EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNV");
5877 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV");
5878 (yyval.interm.type).init((yyvsp[0].lex).loc);
5879 (yyval.interm.type).qualifier.storage = EvqPayloadNV;
5880 #endif
5881 }
5882 #line 5883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5883 break;
5884
5885 case 169:
5886 #line 1369 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5887 {
5888 #ifdef NV_EXTENSIONS
5889 parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV");
5890 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitNVMask |
5891 EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNV");
5892 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV");
5893 (yyval.interm.type).init((yyvsp[0].lex).loc);
5894 (yyval.interm.type).qualifier.storage = EvqPayloadInNV;
5895 #endif
5896 }
5897 #line 5898 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5898 break;
5899
5900 case 170:
5901 #line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5902 {
5903 #ifdef NV_EXTENSIONS
5904 parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV");
5905 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask |
5906 EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask), "callableDataNV");
5907 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataNV");
5908 (yyval.interm.type).init((yyvsp[0].lex).loc);
5909 (yyval.interm.type).qualifier.storage = EvqCallableDataNV;
5910 #endif
5911 }
5912 #line 5913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5913 break;
5914
5915 case 171:
5916 #line 1389 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5917 {
5918 #ifdef NV_EXTENSIONS
5919 parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV");
5920 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV");
5921 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV");
5922 (yyval.interm.type).init((yyvsp[0].lex).loc);
5923 (yyval.interm.type).qualifier.storage = EvqCallableDataInNV;
5924 #endif
5925 }
5926 #line 5927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5927 break;
5928
5929 case 172:
5930 #line 1398 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5931 {
5932 parseContext.globalCheck((yyvsp[0].lex).loc, "shared");
5933 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared");
5934 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared");
5935 #ifdef NV_EXTENSIONS
5936 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared");
5937 #else
5938 parseContext.requireStage((yyvsp[0].lex).loc, EShLangCompute, "shared");
5939 #endif
5940 (yyval.interm.type).init((yyvsp[0].lex).loc);
5941 (yyval.interm.type).qualifier.storage = EvqShared;
5942 }
5943 #line 5944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5944 break;
5945
5946 case 173:
5947 #line 1410 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5948 {
5949 (yyval.interm.type).init((yyvsp[0].lex).loc);
5950 (yyval.interm.type).qualifier.coherent = true;
5951 }
5952 #line 5953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5953 break;
5954
5955 case 174:
5956 #line 1414 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5957 {
5958 (yyval.interm.type).init((yyvsp[0].lex).loc);
5959 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent");
5960 (yyval.interm.type).qualifier.devicecoherent = true;
5961 }
5962 #line 5963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5963 break;
5964
5965 case 175:
5966 #line 1419 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5967 {
5968 (yyval.interm.type).init((yyvsp[0].lex).loc);
5969 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent");
5970 (yyval.interm.type).qualifier.queuefamilycoherent = true;
5971 }
5972 #line 5973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5973 break;
5974
5975 case 176:
5976 #line 1424 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5977 {
5978 (yyval.interm.type).init((yyvsp[0].lex).loc);
5979 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent");
5980 (yyval.interm.type).qualifier.workgroupcoherent = true;
5981 }
5982 #line 5983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5983 break;
5984
5985 case 177:
5986 #line 1429 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5987 {
5988 (yyval.interm.type).init((yyvsp[0].lex).loc);
5989 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent");
5990 (yyval.interm.type).qualifier.subgroupcoherent = true;
5991 }
5992 #line 5993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
5993 break;
5994
5995 case 178:
5996 #line 1434 "MachineIndependent/glslang.y" /* yacc.c:1646 */
5997 {
5998 (yyval.interm.type).init((yyvsp[0].lex).loc);
5999 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate");
6000 (yyval.interm.type).qualifier.nonprivate = true;
6001 }
6002 #line 6003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6003 break;
6004
6005 case 179:
6006 #line 1439 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6007 {
6008 (yyval.interm.type).init((yyvsp[0].lex).loc);
6009 (yyval.interm.type).qualifier.volatil = true;
6010 }
6011 #line 6012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6012 break;
6013
6014 case 180:
6015 #line 1443 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6016 {
6017 (yyval.interm.type).init((yyvsp[0].lex).loc);
6018 (yyval.interm.type).qualifier.restrict = true;
6019 }
6020 #line 6021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6021 break;
6022
6023 case 181:
6024 #line 1447 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6025 {
6026 (yyval.interm.type).init((yyvsp[0].lex).loc);
6027 (yyval.interm.type).qualifier.readonly = true;
6028 }
6029 #line 6030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6030 break;
6031
6032 case 182:
6033 #line 1451 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6034 {
6035 (yyval.interm.type).init((yyvsp[0].lex).loc);
6036 (yyval.interm.type).qualifier.writeonly = true;
6037 }
6038 #line 6039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6039 break;
6040
6041 case 183:
6042 #line 1455 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6043 {
6044 parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine");
6045 parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine");
6046 parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine");
6047 (yyval.interm.type).init((yyvsp[0].lex).loc);
6048 }
6049 #line 6050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6050 break;
6051
6052 case 184:
6053 #line 1461 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6054 {
6055 parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine");
6056 parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine");
6057 parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine");
6058 (yyval.interm.type).init((yyvsp[-3].lex).loc);
6059 }
6060 #line 6061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6061 break;
6062
6063 case 185:
6064 #line 1470 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6065 {
6066 (yyval.interm.type).init((yyvsp[0].lex).loc);
6067 (yyval.interm.type).qualifier.nonUniform = true;
6068 }
6069 #line 6070 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6070 break;
6071
6072 case 186:
6073 #line 1477 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6074 {
6075 // TODO
6076 }
6077 #line 6078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6078 break;
6079
6080 case 187:
6081 #line 1480 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6082 {
6083 // TODO: 4.0 semantics: subroutines
6084 // 1) make sure each identifier is a type declared earlier with SUBROUTINE
6085 // 2) save all of the identifiers for future comparison with the declared function
6086 }
6087 #line 6088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6088 break;
6089
6090 case 188:
6091 #line 1488 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6092 {
6093 (yyval.interm.type) = (yyvsp[0].interm.type);
6094 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
6095 }
6096 #line 6097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6097 break;
6098
6099 case 189:
6100 #line 1492 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6101 {
6102 parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes);
6103 (yyval.interm.type) = (yyvsp[-1].interm.type);
6104 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type));
6105 (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes;
6106 }
6107 #line 6108 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6108 break;
6109
6110 case 190:
6111 #line 1501 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6112 {
6113 (yyval.interm).loc = (yyvsp[-1].lex).loc;
6114 (yyval.interm).arraySizes = new TArraySizes;
6115 (yyval.interm).arraySizes->addInnerSize();
6116 }
6117 #line 6118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6118 break;
6119
6120 case 191:
6121 #line 1506 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6122 {
6123 (yyval.interm).loc = (yyvsp[-2].lex).loc;
6124 (yyval.interm).arraySizes = new TArraySizes;
6125
6126 TArraySize size;
6127 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
6128 (yyval.interm).arraySizes->addInnerSize(size);
6129 }
6130 #line 6131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6131 break;
6132
6133 case 192:
6134 #line 1514 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6135 {
6136 (yyval.interm) = (yyvsp[-2].interm);
6137 (yyval.interm).arraySizes->addInnerSize();
6138 }
6139 #line 6140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6140 break;
6141
6142 case 193:
6143 #line 1518 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6144 {
6145 (yyval.interm) = (yyvsp[-3].interm);
6146
6147 TArraySize size;
6148 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size);
6149 (yyval.interm).arraySizes->addInnerSize(size);
6150 }
6151 #line 6152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6152 break;
6153
6154 case 194:
6155 #line 1528 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6156 {
6157 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6158 (yyval.interm.type).basicType = EbtVoid;
6159 }
6160 #line 6161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6161 break;
6162
6163 case 195:
6164 #line 1532 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6165 {
6166 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6167 (yyval.interm.type).basicType = EbtFloat;
6168 }
6169 #line 6170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6170 break;
6171
6172 case 196:
6173 #line 1536 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6174 {
6175 parseContext.doubleCheck((yyvsp[0].lex).loc, "double");
6176 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6177 (yyval.interm.type).basicType = EbtDouble;
6178 }
6179 #line 6180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6180 break;
6181
6182 case 197:
6183 #line 1541 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6184 {
6185 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel());
6186 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6187 (yyval.interm.type).basicType = EbtFloat16;
6188 }
6189 #line 6190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6190 break;
6191
6192 case 198:
6193 #line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6194 {
6195 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel());
6196 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6197 (yyval.interm.type).basicType = EbtFloat;
6198 }
6199 #line 6200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6200 break;
6201
6202 case 199:
6203 #line 1551 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6204 {
6205 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel());
6206 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6207 (yyval.interm.type).basicType = EbtDouble;
6208 }
6209 #line 6210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6210 break;
6211
6212 case 200:
6213 #line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6214 {
6215 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6216 (yyval.interm.type).basicType = EbtInt;
6217 }
6218 #line 6219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6219 break;
6220
6221 case 201:
6222 #line 1560 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6223 {
6224 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer");
6225 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6226 (yyval.interm.type).basicType = EbtUint;
6227 }
6228 #line 6229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6229 break;
6230
6231 case 202:
6232 #line 1565 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6233 {
6234 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6235 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6236 (yyval.interm.type).basicType = EbtInt8;
6237 }
6238 #line 6239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6239 break;
6240
6241 case 203:
6242 #line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6243 {
6244 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6245 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6246 (yyval.interm.type).basicType = EbtUint8;
6247 }
6248 #line 6249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6249 break;
6250
6251 case 204:
6252 #line 1575 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6253 {
6254 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6255 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6256 (yyval.interm.type).basicType = EbtInt16;
6257 }
6258 #line 6259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6259 break;
6260
6261 case 205:
6262 #line 1580 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6263 {
6264 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6265 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6266 (yyval.interm.type).basicType = EbtUint16;
6267 }
6268 #line 6269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6269 break;
6270
6271 case 206:
6272 #line 1585 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6273 {
6274 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel());
6275 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6276 (yyval.interm.type).basicType = EbtInt;
6277 }
6278 #line 6279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6279 break;
6280
6281 case 207:
6282 #line 1590 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6283 {
6284 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6285 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6286 (yyval.interm.type).basicType = EbtUint;
6287 }
6288 #line 6289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6289 break;
6290
6291 case 208:
6292 #line 1595 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6293 {
6294 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel());
6295 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6296 (yyval.interm.type).basicType = EbtInt64;
6297 }
6298 #line 6299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6299 break;
6300
6301 case 209:
6302 #line 1600 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6303 {
6304 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
6305 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6306 (yyval.interm.type).basicType = EbtUint64;
6307 }
6308 #line 6309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6309 break;
6310
6311 case 210:
6312 #line 1605 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6313 {
6314 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6315 (yyval.interm.type).basicType = EbtBool;
6316 }
6317 #line 6318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6318 break;
6319
6320 case 211:
6321 #line 1609 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6322 {
6323 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6324 (yyval.interm.type).basicType = EbtFloat;
6325 (yyval.interm.type).setVector(2);
6326 }
6327 #line 6328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6328 break;
6329
6330 case 212:
6331 #line 1614 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6332 {
6333 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6334 (yyval.interm.type).basicType = EbtFloat;
6335 (yyval.interm.type).setVector(3);
6336 }
6337 #line 6338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6338 break;
6339
6340 case 213:
6341 #line 1619 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6342 {
6343 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6344 (yyval.interm.type).basicType = EbtFloat;
6345 (yyval.interm.type).setVector(4);
6346 }
6347 #line 6348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6348 break;
6349
6350 case 214:
6351 #line 1624 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6352 {
6353 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6354 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6355 (yyval.interm.type).basicType = EbtDouble;
6356 (yyval.interm.type).setVector(2);
6357 }
6358 #line 6359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6359 break;
6360
6361 case 215:
6362 #line 1630 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6363 {
6364 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6365 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6366 (yyval.interm.type).basicType = EbtDouble;
6367 (yyval.interm.type).setVector(3);
6368 }
6369 #line 6370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6370 break;
6371
6372 case 216:
6373 #line 1636 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6374 {
6375 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector");
6376 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6377 (yyval.interm.type).basicType = EbtDouble;
6378 (yyval.interm.type).setVector(4);
6379 }
6380 #line 6381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6381 break;
6382
6383 case 217:
6384 #line 1642 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6385 {
6386 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6387 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6388 (yyval.interm.type).basicType = EbtFloat16;
6389 (yyval.interm.type).setVector(2);
6390 }
6391 #line 6392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6392 break;
6393
6394 case 218:
6395 #line 1648 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6396 {
6397 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6398 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6399 (yyval.interm.type).basicType = EbtFloat16;
6400 (yyval.interm.type).setVector(3);
6401 }
6402 #line 6403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6403 break;
6404
6405 case 219:
6406 #line 1654 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6407 {
6408 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel());
6409 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6410 (yyval.interm.type).basicType = EbtFloat16;
6411 (yyval.interm.type).setVector(4);
6412 }
6413 #line 6414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6414 break;
6415
6416 case 220:
6417 #line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6418 {
6419 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6420 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6421 (yyval.interm.type).basicType = EbtFloat;
6422 (yyval.interm.type).setVector(2);
6423 }
6424 #line 6425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6425 break;
6426
6427 case 221:
6428 #line 1666 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6429 {
6430 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6431 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6432 (yyval.interm.type).basicType = EbtFloat;
6433 (yyval.interm.type).setVector(3);
6434 }
6435 #line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6436 break;
6437
6438 case 222:
6439 #line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6440 {
6441 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel());
6442 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6443 (yyval.interm.type).basicType = EbtFloat;
6444 (yyval.interm.type).setVector(4);
6445 }
6446 #line 6447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6447 break;
6448
6449 case 223:
6450 #line 1678 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6451 {
6452 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6453 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6454 (yyval.interm.type).basicType = EbtDouble;
6455 (yyval.interm.type).setVector(2);
6456 }
6457 #line 6458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6458 break;
6459
6460 case 224:
6461 #line 1684 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6462 {
6463 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6464 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6465 (yyval.interm.type).basicType = EbtDouble;
6466 (yyval.interm.type).setVector(3);
6467 }
6468 #line 6469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6469 break;
6470
6471 case 225:
6472 #line 1690 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6473 {
6474 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel());
6475 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6476 (yyval.interm.type).basicType = EbtDouble;
6477 (yyval.interm.type).setVector(4);
6478 }
6479 #line 6480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6480 break;
6481
6482 case 226:
6483 #line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6484 {
6485 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6486 (yyval.interm.type).basicType = EbtBool;
6487 (yyval.interm.type).setVector(2);
6488 }
6489 #line 6490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6490 break;
6491
6492 case 227:
6493 #line 1701 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6494 {
6495 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6496 (yyval.interm.type).basicType = EbtBool;
6497 (yyval.interm.type).setVector(3);
6498 }
6499 #line 6500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6500 break;
6501
6502 case 228:
6503 #line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6504 {
6505 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6506 (yyval.interm.type).basicType = EbtBool;
6507 (yyval.interm.type).setVector(4);
6508 }
6509 #line 6510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6510 break;
6511
6512 case 229:
6513 #line 1711 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6514 {
6515 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6516 (yyval.interm.type).basicType = EbtInt;
6517 (yyval.interm.type).setVector(2);
6518 }
6519 #line 6520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6520 break;
6521
6522 case 230:
6523 #line 1716 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6524 {
6525 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6526 (yyval.interm.type).basicType = EbtInt;
6527 (yyval.interm.type).setVector(3);
6528 }
6529 #line 6530 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6530 break;
6531
6532 case 231:
6533 #line 1721 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6534 {
6535 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6536 (yyval.interm.type).basicType = EbtInt;
6537 (yyval.interm.type).setVector(4);
6538 }
6539 #line 6540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6540 break;
6541
6542 case 232:
6543 #line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6544 {
6545 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6546 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6547 (yyval.interm.type).basicType = EbtInt8;
6548 (yyval.interm.type).setVector(2);
6549 }
6550 #line 6551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6551 break;
6552
6553 case 233:
6554 #line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6555 {
6556 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6557 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6558 (yyval.interm.type).basicType = EbtInt8;
6559 (yyval.interm.type).setVector(3);
6560 }
6561 #line 6562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6562 break;
6563
6564 case 234:
6565 #line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6566 {
6567 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6568 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6569 (yyval.interm.type).basicType = EbtInt8;
6570 (yyval.interm.type).setVector(4);
6571 }
6572 #line 6573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6573 break;
6574
6575 case 235:
6576 #line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6577 {
6578 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6579 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6580 (yyval.interm.type).basicType = EbtInt16;
6581 (yyval.interm.type).setVector(2);
6582 }
6583 #line 6584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6584 break;
6585
6586 case 236:
6587 #line 1750 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6588 {
6589 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6590 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6591 (yyval.interm.type).basicType = EbtInt16;
6592 (yyval.interm.type).setVector(3);
6593 }
6594 #line 6595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6595 break;
6596
6597 case 237:
6598 #line 1756 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6599 {
6600 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6601 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6602 (yyval.interm.type).basicType = EbtInt16;
6603 (yyval.interm.type).setVector(4);
6604 }
6605 #line 6606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6606 break;
6607
6608 case 238:
6609 #line 1762 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6610 {
6611 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6612 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6613 (yyval.interm.type).basicType = EbtInt;
6614 (yyval.interm.type).setVector(2);
6615 }
6616 #line 6617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6617 break;
6618
6619 case 239:
6620 #line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6621 {
6622 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6623 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6624 (yyval.interm.type).basicType = EbtInt;
6625 (yyval.interm.type).setVector(3);
6626 }
6627 #line 6628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6628 break;
6629
6630 case 240:
6631 #line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6632 {
6633 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel());
6634 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6635 (yyval.interm.type).basicType = EbtInt;
6636 (yyval.interm.type).setVector(4);
6637 }
6638 #line 6639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6639 break;
6640
6641 case 241:
6642 #line 1780 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6643 {
6644 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6645 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6646 (yyval.interm.type).basicType = EbtInt64;
6647 (yyval.interm.type).setVector(2);
6648 }
6649 #line 6650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6650 break;
6651
6652 case 242:
6653 #line 1786 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6654 {
6655 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6656 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6657 (yyval.interm.type).basicType = EbtInt64;
6658 (yyval.interm.type).setVector(3);
6659 }
6660 #line 6661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6661 break;
6662
6663 case 243:
6664 #line 1792 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6665 {
6666 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
6667 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6668 (yyval.interm.type).basicType = EbtInt64;
6669 (yyval.interm.type).setVector(4);
6670 }
6671 #line 6672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6672 break;
6673
6674 case 244:
6675 #line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6676 {
6677 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6678 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6679 (yyval.interm.type).basicType = EbtUint;
6680 (yyval.interm.type).setVector(2);
6681 }
6682 #line 6683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6683 break;
6684
6685 case 245:
6686 #line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6687 {
6688 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6689 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6690 (yyval.interm.type).basicType = EbtUint;
6691 (yyval.interm.type).setVector(3);
6692 }
6693 #line 6694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6694 break;
6695
6696 case 246:
6697 #line 1810 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6698 {
6699 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector");
6700 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6701 (yyval.interm.type).basicType = EbtUint;
6702 (yyval.interm.type).setVector(4);
6703 }
6704 #line 6705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6705 break;
6706
6707 case 247:
6708 #line 1816 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6709 {
6710 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6711 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6712 (yyval.interm.type).basicType = EbtUint8;
6713 (yyval.interm.type).setVector(2);
6714 }
6715 #line 6716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6716 break;
6717
6718 case 248:
6719 #line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6720 {
6721 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6722 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6723 (yyval.interm.type).basicType = EbtUint8;
6724 (yyval.interm.type).setVector(3);
6725 }
6726 #line 6727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6727 break;
6728
6729 case 249:
6730 #line 1828 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6731 {
6732 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6733 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6734 (yyval.interm.type).basicType = EbtUint8;
6735 (yyval.interm.type).setVector(4);
6736 }
6737 #line 6738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6738 break;
6739
6740 case 250:
6741 #line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6742 {
6743 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6744 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6745 (yyval.interm.type).basicType = EbtUint16;
6746 (yyval.interm.type).setVector(2);
6747 }
6748 #line 6749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6749 break;
6750
6751 case 251:
6752 #line 1840 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6753 {
6754 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6755 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6756 (yyval.interm.type).basicType = EbtUint16;
6757 (yyval.interm.type).setVector(3);
6758 }
6759 #line 6760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6760 break;
6761
6762 case 252:
6763 #line 1846 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6764 {
6765 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6766 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6767 (yyval.interm.type).basicType = EbtUint16;
6768 (yyval.interm.type).setVector(4);
6769 }
6770 #line 6771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6771 break;
6772
6773 case 253:
6774 #line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6775 {
6776 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6777 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6778 (yyval.interm.type).basicType = EbtUint;
6779 (yyval.interm.type).setVector(2);
6780 }
6781 #line 6782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6782 break;
6783
6784 case 254:
6785 #line 1858 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6786 {
6787 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6788 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6789 (yyval.interm.type).basicType = EbtUint;
6790 (yyval.interm.type).setVector(3);
6791 }
6792 #line 6793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6793 break;
6794
6795 case 255:
6796 #line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6797 {
6798 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6799 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6800 (yyval.interm.type).basicType = EbtUint;
6801 (yyval.interm.type).setVector(4);
6802 }
6803 #line 6804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6804 break;
6805
6806 case 256:
6807 #line 1870 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6808 {
6809 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6811 (yyval.interm.type).basicType = EbtUint64;
6812 (yyval.interm.type).setVector(2);
6813 }
6814 #line 6815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6815 break;
6816
6817 case 257:
6818 #line 1876 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6819 {
6820 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6821 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6822 (yyval.interm.type).basicType = EbtUint64;
6823 (yyval.interm.type).setVector(3);
6824 }
6825 #line 6826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6826 break;
6827
6828 case 258:
6829 #line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6830 {
6831 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
6832 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6833 (yyval.interm.type).basicType = EbtUint64;
6834 (yyval.interm.type).setVector(4);
6835 }
6836 #line 6837 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6837 break;
6838
6839 case 259:
6840 #line 1888 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6841 {
6842 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6843 (yyval.interm.type).basicType = EbtFloat;
6844 (yyval.interm.type).setMatrix(2, 2);
6845 }
6846 #line 6847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6847 break;
6848
6849 case 260:
6850 #line 1893 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6851 {
6852 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6853 (yyval.interm.type).basicType = EbtFloat;
6854 (yyval.interm.type).setMatrix(3, 3);
6855 }
6856 #line 6857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6857 break;
6858
6859 case 261:
6860 #line 1898 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6861 {
6862 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6863 (yyval.interm.type).basicType = EbtFloat;
6864 (yyval.interm.type).setMatrix(4, 4);
6865 }
6866 #line 6867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6867 break;
6868
6869 case 262:
6870 #line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6871 {
6872 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6873 (yyval.interm.type).basicType = EbtFloat;
6874 (yyval.interm.type).setMatrix(2, 2);
6875 }
6876 #line 6877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6877 break;
6878
6879 case 263:
6880 #line 1908 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6881 {
6882 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6883 (yyval.interm.type).basicType = EbtFloat;
6884 (yyval.interm.type).setMatrix(2, 3);
6885 }
6886 #line 6887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6887 break;
6888
6889 case 264:
6890 #line 1913 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6891 {
6892 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6893 (yyval.interm.type).basicType = EbtFloat;
6894 (yyval.interm.type).setMatrix(2, 4);
6895 }
6896 #line 6897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6897 break;
6898
6899 case 265:
6900 #line 1918 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6901 {
6902 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6903 (yyval.interm.type).basicType = EbtFloat;
6904 (yyval.interm.type).setMatrix(3, 2);
6905 }
6906 #line 6907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6907 break;
6908
6909 case 266:
6910 #line 1923 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6911 {
6912 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6913 (yyval.interm.type).basicType = EbtFloat;
6914 (yyval.interm.type).setMatrix(3, 3);
6915 }
6916 #line 6917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6917 break;
6918
6919 case 267:
6920 #line 1928 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6921 {
6922 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6923 (yyval.interm.type).basicType = EbtFloat;
6924 (yyval.interm.type).setMatrix(3, 4);
6925 }
6926 #line 6927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6927 break;
6928
6929 case 268:
6930 #line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6931 {
6932 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6933 (yyval.interm.type).basicType = EbtFloat;
6934 (yyval.interm.type).setMatrix(4, 2);
6935 }
6936 #line 6937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6937 break;
6938
6939 case 269:
6940 #line 1938 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6941 {
6942 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6943 (yyval.interm.type).basicType = EbtFloat;
6944 (yyval.interm.type).setMatrix(4, 3);
6945 }
6946 #line 6947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6947 break;
6948
6949 case 270:
6950 #line 1943 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6951 {
6952 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6953 (yyval.interm.type).basicType = EbtFloat;
6954 (yyval.interm.type).setMatrix(4, 4);
6955 }
6956 #line 6957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6957 break;
6958
6959 case 271:
6960 #line 1948 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6961 {
6962 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
6963 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6964 (yyval.interm.type).basicType = EbtDouble;
6965 (yyval.interm.type).setMatrix(2, 2);
6966 }
6967 #line 6968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6968 break;
6969
6970 case 272:
6971 #line 1954 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6972 {
6973 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
6974 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6975 (yyval.interm.type).basicType = EbtDouble;
6976 (yyval.interm.type).setMatrix(3, 3);
6977 }
6978 #line 6979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6979 break;
6980
6981 case 273:
6982 #line 1960 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6983 {
6984 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
6985 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6986 (yyval.interm.type).basicType = EbtDouble;
6987 (yyval.interm.type).setMatrix(4, 4);
6988 }
6989 #line 6990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
6990 break;
6991
6992 case 274:
6993 #line 1966 "MachineIndependent/glslang.y" /* yacc.c:1646 */
6994 {
6995 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
6996 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
6997 (yyval.interm.type).basicType = EbtDouble;
6998 (yyval.interm.type).setMatrix(2, 2);
6999 }
7000 #line 7001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7001 break;
7002
7003 case 275:
7004 #line 1972 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7005 {
7006 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix");
7007 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7008 (yyval.interm.type).basicType = EbtDouble;
7009 (yyval.interm.type).setMatrix(2, 3);
7010 }
7011 #line 7012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7012 break;
7013
7014 case 276:
7015 #line 1978 "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, 4);
7021 }
7022 #line 7023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7023 break;
7024
7025 case 277:
7026 #line 1984 "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, 2);
7032 }
7033 #line 7034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7034 break;
7035
7036 case 278:
7037 #line 1990 "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(3, 3);
7043 }
7044 #line 7045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7045 break;
7046
7047 case 279:
7048 #line 1996 "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(3, 4);
7054 }
7055 #line 7056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7056 break;
7057
7058 case 280:
7059 #line 2002 "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(4, 2);
7065 }
7066 #line 7067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7067 break;
7068
7069 case 281:
7070 #line 2008 "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(4, 3);
7076 }
7077 #line 7078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7078 break;
7079
7080 case 282:
7081 #line 2014 "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(4, 4);
7087 }
7088 #line 7089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7089 break;
7090
7091 case 283:
7092 #line 2020 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7093 {
7094 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7095 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7096 (yyval.interm.type).basicType = EbtFloat16;
7097 (yyval.interm.type).setMatrix(2, 2);
7098 }
7099 #line 7100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7100 break;
7101
7102 case 284:
7103 #line 2026 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7104 {
7105 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7106 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7107 (yyval.interm.type).basicType = EbtFloat16;
7108 (yyval.interm.type).setMatrix(3, 3);
7109 }
7110 #line 7111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7111 break;
7112
7113 case 285:
7114 #line 2032 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7115 {
7116 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7117 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7118 (yyval.interm.type).basicType = EbtFloat16;
7119 (yyval.interm.type).setMatrix(4, 4);
7120 }
7121 #line 7122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7122 break;
7123
7124 case 286:
7125 #line 2038 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7126 {
7127 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7128 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7129 (yyval.interm.type).basicType = EbtFloat16;
7130 (yyval.interm.type).setMatrix(2, 2);
7131 }
7132 #line 7133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7133 break;
7134
7135 case 287:
7136 #line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7137 {
7138 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel());
7139 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7140 (yyval.interm.type).basicType = EbtFloat16;
7141 (yyval.interm.type).setMatrix(2, 3);
7142 }
7143 #line 7144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7144 break;
7145
7146 case 288:
7147 #line 2050 "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, 4);
7153 }
7154 #line 7155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7155 break;
7156
7157 case 289:
7158 #line 2056 "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, 2);
7164 }
7165 #line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7166 break;
7167
7168 case 290:
7169 #line 2062 "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(3, 3);
7175 }
7176 #line 7177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7177 break;
7178
7179 case 291:
7180 #line 2068 "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(3, 4);
7186 }
7187 #line 7188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7188 break;
7189
7190 case 292:
7191 #line 2074 "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(4, 2);
7197 }
7198 #line 7199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7199 break;
7200
7201 case 293:
7202 #line 2080 "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(4, 3);
7208 }
7209 #line 7210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7210 break;
7211
7212 case 294:
7213 #line 2086 "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(4, 4);
7219 }
7220 #line 7221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7221 break;
7222
7223 case 295:
7224 #line 2092 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7225 {
7226 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7227 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7228 (yyval.interm.type).basicType = EbtFloat;
7229 (yyval.interm.type).setMatrix(2, 2);
7230 }
7231 #line 7232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7232 break;
7233
7234 case 296:
7235 #line 2098 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7236 {
7237 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7238 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7239 (yyval.interm.type).basicType = EbtFloat;
7240 (yyval.interm.type).setMatrix(3, 3);
7241 }
7242 #line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7243 break;
7244
7245 case 297:
7246 #line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7247 {
7248 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7249 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7250 (yyval.interm.type).basicType = EbtFloat;
7251 (yyval.interm.type).setMatrix(4, 4);
7252 }
7253 #line 7254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7254 break;
7255
7256 case 298:
7257 #line 2110 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7258 {
7259 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7260 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7261 (yyval.interm.type).basicType = EbtFloat;
7262 (yyval.interm.type).setMatrix(2, 2);
7263 }
7264 #line 7265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7265 break;
7266
7267 case 299:
7268 #line 2116 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7269 {
7270 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel());
7271 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7272 (yyval.interm.type).basicType = EbtFloat;
7273 (yyval.interm.type).setMatrix(2, 3);
7274 }
7275 #line 7276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7276 break;
7277
7278 case 300:
7279 #line 2122 "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, 4);
7285 }
7286 #line 7287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7287 break;
7288
7289 case 301:
7290 #line 2128 "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, 2);
7296 }
7297 #line 7298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7298 break;
7299
7300 case 302:
7301 #line 2134 "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(3, 3);
7307 }
7308 #line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7309 break;
7310
7311 case 303:
7312 #line 2140 "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(3, 4);
7318 }
7319 #line 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7320 break;
7321
7322 case 304:
7323 #line 2146 "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(4, 2);
7329 }
7330 #line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7331 break;
7332
7333 case 305:
7334 #line 2152 "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(4, 3);
7340 }
7341 #line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7342 break;
7343
7344 case 306:
7345 #line 2158 "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(4, 4);
7351 }
7352 #line 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7353 break;
7354
7355 case 307:
7356 #line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7357 {
7358 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7359 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7360 (yyval.interm.type).basicType = EbtDouble;
7361 (yyval.interm.type).setMatrix(2, 2);
7362 }
7363 #line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7364 break;
7365
7366 case 308:
7367 #line 2170 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7368 {
7369 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7370 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7371 (yyval.interm.type).basicType = EbtDouble;
7372 (yyval.interm.type).setMatrix(3, 3);
7373 }
7374 #line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7375 break;
7376
7377 case 309:
7378 #line 2176 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7379 {
7380 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7381 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7382 (yyval.interm.type).basicType = EbtDouble;
7383 (yyval.interm.type).setMatrix(4, 4);
7384 }
7385 #line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7386 break;
7387
7388 case 310:
7389 #line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7390 {
7391 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7392 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7393 (yyval.interm.type).basicType = EbtDouble;
7394 (yyval.interm.type).setMatrix(2, 2);
7395 }
7396 #line 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7397 break;
7398
7399 case 311:
7400 #line 2188 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7401 {
7402 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel());
7403 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7404 (yyval.interm.type).basicType = EbtDouble;
7405 (yyval.interm.type).setMatrix(2, 3);
7406 }
7407 #line 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7408 break;
7409
7410 case 312:
7411 #line 2194 "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, 4);
7417 }
7418 #line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7419 break;
7420
7421 case 313:
7422 #line 2200 "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, 2);
7428 }
7429 #line 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7430 break;
7431
7432 case 314:
7433 #line 2206 "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(3, 3);
7439 }
7440 #line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7441 break;
7442
7443 case 315:
7444 #line 2212 "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(3, 4);
7450 }
7451 #line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7452 break;
7453
7454 case 316:
7455 #line 2218 "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(4, 2);
7461 }
7462 #line 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7463 break;
7464
7465 case 317:
7466 #line 2224 "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(4, 3);
7472 }
7473 #line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7474 break;
7475
7476 case 318:
7477 #line 2230 "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(4, 4);
7483 }
7484 #line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7485 break;
7486
7487 case 319:
7488 #line 2236 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7489 {
7490 #ifdef NV_EXTENSIONS
7491 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7492 (yyval.interm.type).basicType = EbtAccStructNV;
7493 #endif
7494 }
7495 #line 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7496 break;
7497
7498 case 320:
7499 #line 2242 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7500 {
7501 parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types");
7502 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7503 (yyval.interm.type).basicType = EbtAtomicUint;
7504 }
7505 #line 7506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7506 break;
7507
7508 case 321:
7509 #line 2247 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7510 {
7511 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7512 (yyval.interm.type).basicType = EbtSampler;
7513 (yyval.interm.type).sampler.set(EbtFloat, Esd1D);
7514 }
7515 #line 7516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7516 break;
7517
7518 case 322:
7519 #line 2252 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7520 {
7521 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7522 (yyval.interm.type).basicType = EbtSampler;
7523 (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
7524 }
7525 #line 7526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7526 break;
7527
7528 case 323:
7529 #line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7530 {
7531 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7532 (yyval.interm.type).basicType = EbtSampler;
7533 (yyval.interm.type).sampler.set(EbtFloat, Esd3D);
7534 }
7535 #line 7536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7536 break;
7537
7538 case 324:
7539 #line 2262 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7540 {
7541 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7542 (yyval.interm.type).basicType = EbtSampler;
7543 (yyval.interm.type).sampler.set(EbtFloat, EsdCube);
7544 }
7545 #line 7546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7546 break;
7547
7548 case 325:
7549 #line 2267 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7550 {
7551 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7552 (yyval.interm.type).basicType = EbtSampler;
7553 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true);
7554 }
7555 #line 7556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7556 break;
7557
7558 case 326:
7559 #line 2272 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7560 {
7561 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7562 (yyval.interm.type).basicType = EbtSampler;
7563 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true);
7564 }
7565 #line 7566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7566 break;
7567
7568 case 327:
7569 #line 2277 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7570 {
7571 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7572 (yyval.interm.type).basicType = EbtSampler;
7573 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true);
7574 }
7575 #line 7576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7576 break;
7577
7578 case 328:
7579 #line 2282 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7580 {
7581 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7582 (yyval.interm.type).basicType = EbtSampler;
7583 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true);
7584 }
7585 #line 7586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7586 break;
7587
7588 case 329:
7589 #line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7590 {
7591 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7592 (yyval.interm.type).basicType = EbtSampler;
7593 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true);
7594 }
7595 #line 7596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7596 break;
7597
7598 case 330:
7599 #line 2292 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7600 {
7601 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7602 (yyval.interm.type).basicType = EbtSampler;
7603 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true);
7604 }
7605 #line 7606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7606 break;
7607
7608 case 331:
7609 #line 2297 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7610 {
7611 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7612 (yyval.interm.type).basicType = EbtSampler;
7613 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true);
7614 }
7615 #line 7616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7616 break;
7617
7618 case 332:
7619 #line 2302 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7620 {
7621 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7622 (yyval.interm.type).basicType = EbtSampler;
7623 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true);
7624 }
7625 #line 7626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7626 break;
7627
7628 case 333:
7629 #line 2307 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7630 {
7631 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7632 (yyval.interm.type).basicType = EbtSampler;
7633 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true);
7634 }
7635 #line 7636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7636 break;
7637
7638 case 334:
7639 #line 2312 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7640 {
7641 #ifdef AMD_EXTENSIONS
7642 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7643 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7644 (yyval.interm.type).basicType = EbtSampler;
7645 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D);
7646 #endif
7647 }
7648 #line 7649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7649 break;
7650
7651 case 335:
7652 #line 2320 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7653 {
7654 #ifdef AMD_EXTENSIONS
7655 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7656 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7657 (yyval.interm.type).basicType = EbtSampler;
7658 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D);
7659 #endif
7660 }
7661 #line 7662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7662 break;
7663
7664 case 336:
7665 #line 2328 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7666 {
7667 #ifdef AMD_EXTENSIONS
7668 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7669 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7670 (yyval.interm.type).basicType = EbtSampler;
7671 (yyval.interm.type).sampler.set(EbtFloat16, Esd3D);
7672 #endif
7673 }
7674 #line 7675 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7675 break;
7676
7677 case 337:
7678 #line 2336 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7679 {
7680 #ifdef AMD_EXTENSIONS
7681 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7682 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7683 (yyval.interm.type).basicType = EbtSampler;
7684 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube);
7685 #endif
7686 }
7687 #line 7688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7688 break;
7689
7690 case 338:
7691 #line 2344 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7692 {
7693 #ifdef AMD_EXTENSIONS
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, false, true);
7698 #endif
7699 }
7700 #line 7701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7701 break;
7702
7703 case 339:
7704 #line 2352 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7705 {
7706 #ifdef AMD_EXTENSIONS
7707 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7708 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7709 (yyval.interm.type).basicType = EbtSampler;
7710 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true);
7711 #endif
7712 }
7713 #line 7714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7714 break;
7715
7716 case 340:
7717 #line 2360 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7718 {
7719 #ifdef AMD_EXTENSIONS
7720 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7721 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7722 (yyval.interm.type).basicType = EbtSampler;
7723 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true);
7724 #endif
7725 }
7726 #line 7727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7727 break;
7728
7729 case 341:
7730 #line 2368 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7731 {
7732 #ifdef AMD_EXTENSIONS
7733 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7734 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7735 (yyval.interm.type).basicType = EbtSampler;
7736 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true);
7737 #endif
7738 }
7739 #line 7740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7740 break;
7741
7742 case 342:
7743 #line 2376 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7744 {
7745 #ifdef AMD_EXTENSIONS
7746 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7747 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7748 (yyval.interm.type).basicType = EbtSampler;
7749 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true);
7750 #endif
7751 }
7752 #line 7753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7753 break;
7754
7755 case 343:
7756 #line 2384 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7757 {
7758 #ifdef AMD_EXTENSIONS
7759 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7760 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7761 (yyval.interm.type).basicType = EbtSampler;
7762 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true);
7763 #endif
7764 }
7765 #line 7766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7766 break;
7767
7768 case 344:
7769 #line 2392 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7770 {
7771 #ifdef AMD_EXTENSIONS
7772 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7773 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7774 (yyval.interm.type).basicType = EbtSampler;
7775 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true);
7776 #endif
7777 }
7778 #line 7779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7779 break;
7780
7781 case 345:
7782 #line 2400 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7783 {
7784 #ifdef AMD_EXTENSIONS
7785 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7786 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7787 (yyval.interm.type).basicType = EbtSampler;
7788 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true);
7789 #endif
7790 }
7791 #line 7792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7792 break;
7793
7794 case 346:
7795 #line 2408 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7796 {
7797 #ifdef AMD_EXTENSIONS
7798 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7799 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7800 (yyval.interm.type).basicType = EbtSampler;
7801 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true);
7802 #endif
7803 }
7804 #line 7805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7805 break;
7806
7807 case 347:
7808 #line 2416 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7809 {
7810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7811 (yyval.interm.type).basicType = EbtSampler;
7812 (yyval.interm.type).sampler.set(EbtInt, Esd1D);
7813 }
7814 #line 7815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7815 break;
7816
7817 case 348:
7818 #line 2421 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7819 {
7820 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7821 (yyval.interm.type).basicType = EbtSampler;
7822 (yyval.interm.type).sampler.set(EbtInt, Esd2D);
7823 }
7824 #line 7825 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7825 break;
7826
7827 case 349:
7828 #line 2426 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7829 {
7830 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7831 (yyval.interm.type).basicType = EbtSampler;
7832 (yyval.interm.type).sampler.set(EbtInt, Esd3D);
7833 }
7834 #line 7835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7835 break;
7836
7837 case 350:
7838 #line 2431 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7839 {
7840 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7841 (yyval.interm.type).basicType = EbtSampler;
7842 (yyval.interm.type).sampler.set(EbtInt, EsdCube);
7843 }
7844 #line 7845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7845 break;
7846
7847 case 351:
7848 #line 2436 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7849 {
7850 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7851 (yyval.interm.type).basicType = EbtSampler;
7852 (yyval.interm.type).sampler.set(EbtInt, Esd1D, true);
7853 }
7854 #line 7855 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7855 break;
7856
7857 case 352:
7858 #line 2441 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7859 {
7860 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7861 (yyval.interm.type).basicType = EbtSampler;
7862 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true);
7863 }
7864 #line 7865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7865 break;
7866
7867 case 353:
7868 #line 2446 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7869 {
7870 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7871 (yyval.interm.type).basicType = EbtSampler;
7872 (yyval.interm.type).sampler.set(EbtInt, EsdCube, true);
7873 }
7874 #line 7875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7875 break;
7876
7877 case 354:
7878 #line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7879 {
7880 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7881 (yyval.interm.type).basicType = EbtSampler;
7882 (yyval.interm.type).sampler.set(EbtUint, Esd1D);
7883 }
7884 #line 7885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7885 break;
7886
7887 case 355:
7888 #line 2456 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7889 {
7890 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7891 (yyval.interm.type).basicType = EbtSampler;
7892 (yyval.interm.type).sampler.set(EbtUint, Esd2D);
7893 }
7894 #line 7895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7895 break;
7896
7897 case 356:
7898 #line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7899 {
7900 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7901 (yyval.interm.type).basicType = EbtSampler;
7902 (yyval.interm.type).sampler.set(EbtUint, Esd3D);
7903 }
7904 #line 7905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7905 break;
7906
7907 case 357:
7908 #line 2466 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7909 {
7910 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7911 (yyval.interm.type).basicType = EbtSampler;
7912 (yyval.interm.type).sampler.set(EbtUint, EsdCube);
7913 }
7914 #line 7915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7915 break;
7916
7917 case 358:
7918 #line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7919 {
7920 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7921 (yyval.interm.type).basicType = EbtSampler;
7922 (yyval.interm.type).sampler.set(EbtUint, Esd1D, true);
7923 }
7924 #line 7925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7925 break;
7926
7927 case 359:
7928 #line 2476 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7929 {
7930 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7931 (yyval.interm.type).basicType = EbtSampler;
7932 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true);
7933 }
7934 #line 7935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7935 break;
7936
7937 case 360:
7938 #line 2481 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7939 {
7940 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7941 (yyval.interm.type).basicType = EbtSampler;
7942 (yyval.interm.type).sampler.set(EbtUint, EsdCube, true);
7943 }
7944 #line 7945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7945 break;
7946
7947 case 361:
7948 #line 2486 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7949 {
7950 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7951 (yyval.interm.type).basicType = EbtSampler;
7952 (yyval.interm.type).sampler.set(EbtFloat, EsdRect);
7953 }
7954 #line 7955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7955 break;
7956
7957 case 362:
7958 #line 2491 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7959 {
7960 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7961 (yyval.interm.type).basicType = EbtSampler;
7962 (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true);
7963 }
7964 #line 7965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7965 break;
7966
7967 case 363:
7968 #line 2496 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7969 {
7970 #ifdef AMD_EXTENSIONS
7971 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7972 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7973 (yyval.interm.type).basicType = EbtSampler;
7974 (yyval.interm.type).sampler.set(EbtFloat16, EsdRect);
7975 #endif
7976 }
7977 #line 7978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7978 break;
7979
7980 case 364:
7981 #line 2504 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7982 {
7983 #ifdef AMD_EXTENSIONS
7984 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
7985 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7986 (yyval.interm.type).basicType = EbtSampler;
7987 (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true);
7988 #endif
7989 }
7990 #line 7991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
7991 break;
7992
7993 case 365:
7994 #line 2512 "MachineIndependent/glslang.y" /* yacc.c:1646 */
7995 {
7996 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
7997 (yyval.interm.type).basicType = EbtSampler;
7998 (yyval.interm.type).sampler.set(EbtInt, EsdRect);
7999 }
8000 #line 8001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8001 break;
8002
8003 case 366:
8004 #line 2517 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8005 {
8006 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8007 (yyval.interm.type).basicType = EbtSampler;
8008 (yyval.interm.type).sampler.set(EbtUint, EsdRect);
8009 }
8010 #line 8011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8011 break;
8012
8013 case 367:
8014 #line 2522 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8015 {
8016 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8017 (yyval.interm.type).basicType = EbtSampler;
8018 (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer);
8019 }
8020 #line 8021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8021 break;
8022
8023 case 368:
8024 #line 2527 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8025 {
8026 #ifdef AMD_EXTENSIONS
8027 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8028 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8029 (yyval.interm.type).basicType = EbtSampler;
8030 (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer);
8031 #endif
8032 }
8033 #line 8034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8034 break;
8035
8036 case 369:
8037 #line 2535 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8038 {
8039 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8040 (yyval.interm.type).basicType = EbtSampler;
8041 (yyval.interm.type).sampler.set(EbtInt, EsdBuffer);
8042 }
8043 #line 8044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8044 break;
8045
8046 case 370:
8047 #line 2540 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8048 {
8049 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8050 (yyval.interm.type).basicType = EbtSampler;
8051 (yyval.interm.type).sampler.set(EbtUint, EsdBuffer);
8052 }
8053 #line 8054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8054 break;
8055
8056 case 371:
8057 #line 2545 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8058 {
8059 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8060 (yyval.interm.type).basicType = EbtSampler;
8061 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true);
8062 }
8063 #line 8064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8064 break;
8065
8066 case 372:
8067 #line 2550 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8068 {
8069 #ifdef AMD_EXTENSIONS
8070 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8071 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8072 (yyval.interm.type).basicType = EbtSampler;
8073 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true);
8074 #endif
8075 }
8076 #line 8077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8077 break;
8078
8079 case 373:
8080 #line 2558 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8081 {
8082 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8083 (yyval.interm.type).basicType = EbtSampler;
8084 (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true);
8085 }
8086 #line 8087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8087 break;
8088
8089 case 374:
8090 #line 2563 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8091 {
8092 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8093 (yyval.interm.type).basicType = EbtSampler;
8094 (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true);
8095 }
8096 #line 8097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8097 break;
8098
8099 case 375:
8100 #line 2568 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8101 {
8102 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8103 (yyval.interm.type).basicType = EbtSampler;
8104 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true);
8105 }
8106 #line 8107 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8107 break;
8108
8109 case 376:
8110 #line 2573 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8111 {
8112 #ifdef AMD_EXTENSIONS
8113 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
8114 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8115 (yyval.interm.type).basicType = EbtSampler;
8116 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true);
8117 #endif
8118 }
8119 #line 8120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8120 break;
8121
8122 case 377:
8123 #line 2581 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8124 {
8125 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8126 (yyval.interm.type).basicType = EbtSampler;
8127 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true);
8128 }
8129 #line 8130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8130 break;
8131
8132 case 378:
8133 #line 2586 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8134 {
8135 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8136 (yyval.interm.type).basicType = EbtSampler;
8137 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true);
8138 }
8139 #line 8140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8140 break;
8141
8142 case 379:
8143 #line 2591 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8144 {
8145 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8146 (yyval.interm.type).basicType = EbtSampler;
8147 (yyval.interm.type).sampler.setPureSampler(false);
8148 }
8149 #line 8150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8150 break;
8151
8152 case 380:
8153 #line 2596 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8154 {
8155 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8156 (yyval.interm.type).basicType = EbtSampler;
8157 (yyval.interm.type).sampler.setPureSampler(true);
8158 }
8159 #line 8160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8160 break;
8161
8162 case 381:
8163 #line 2601 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8164 {
8165 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8166 (yyval.interm.type).basicType = EbtSampler;
8167 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D);
8168 }
8169 #line 8170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8170 break;
8171
8172 case 382:
8173 #line 2606 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8174 {
8175 #ifdef AMD_EXTENSIONS
8176 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8177 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8178 (yyval.interm.type).basicType = EbtSampler;
8179 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D);
8180 #endif
8181 }
8182 #line 8183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8183 break;
8184
8185 case 383:
8186 #line 2614 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8187 {
8188 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8189 (yyval.interm.type).basicType = EbtSampler;
8190 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D);
8191 }
8192 #line 8193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8193 break;
8194
8195 case 384:
8196 #line 2619 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8197 {
8198 #ifdef AMD_EXTENSIONS
8199 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8200 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8201 (yyval.interm.type).basicType = EbtSampler;
8202 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D);
8203 #endif
8204 }
8205 #line 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8206 break;
8207
8208 case 385:
8209 #line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8210 {
8211 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8212 (yyval.interm.type).basicType = EbtSampler;
8213 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D);
8214 }
8215 #line 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8216 break;
8217
8218 case 386:
8219 #line 2632 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8220 {
8221 #ifdef AMD_EXTENSIONS
8222 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8223 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8224 (yyval.interm.type).basicType = EbtSampler;
8225 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D);
8226 #endif
8227 }
8228 #line 8229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8229 break;
8230
8231 case 387:
8232 #line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8233 {
8234 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8235 (yyval.interm.type).basicType = EbtSampler;
8236 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube);
8237 }
8238 #line 8239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8239 break;
8240
8241 case 388:
8242 #line 2645 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8243 {
8244 #ifdef AMD_EXTENSIONS
8245 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8246 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8247 (yyval.interm.type).basicType = EbtSampler;
8248 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube);
8249 #endif
8250 }
8251 #line 8252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8252 break;
8253
8254 case 389:
8255 #line 2653 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8256 {
8257 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8258 (yyval.interm.type).basicType = EbtSampler;
8259 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true);
8260 }
8261 #line 8262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8262 break;
8263
8264 case 390:
8265 #line 2658 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8266 {
8267 #ifdef AMD_EXTENSIONS
8268 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8269 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8270 (yyval.interm.type).basicType = EbtSampler;
8271 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true);
8272 #endif
8273 }
8274 #line 8275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8275 break;
8276
8277 case 391:
8278 #line 2666 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8279 {
8280 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8281 (yyval.interm.type).basicType = EbtSampler;
8282 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true);
8283 }
8284 #line 8285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8285 break;
8286
8287 case 392:
8288 #line 2671 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8289 {
8290 #ifdef AMD_EXTENSIONS
8291 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8292 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8293 (yyval.interm.type).basicType = EbtSampler;
8294 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true);
8295 #endif
8296 }
8297 #line 8298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8298 break;
8299
8300 case 393:
8301 #line 2679 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8302 {
8303 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8304 (yyval.interm.type).basicType = EbtSampler;
8305 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true);
8306 }
8307 #line 8308 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8308 break;
8309
8310 case 394:
8311 #line 2684 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8312 {
8313 #ifdef AMD_EXTENSIONS
8314 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8315 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8316 (yyval.interm.type).basicType = EbtSampler;
8317 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true);
8318 #endif
8319 }
8320 #line 8321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8321 break;
8322
8323 case 395:
8324 #line 2692 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8325 {
8326 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8327 (yyval.interm.type).basicType = EbtSampler;
8328 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D);
8329 }
8330 #line 8331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8331 break;
8332
8333 case 396:
8334 #line 2697 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8335 {
8336 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8337 (yyval.interm.type).basicType = EbtSampler;
8338 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D);
8339 }
8340 #line 8341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8341 break;
8342
8343 case 397:
8344 #line 2702 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8345 {
8346 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8347 (yyval.interm.type).basicType = EbtSampler;
8348 (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D);
8349 }
8350 #line 8351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8351 break;
8352
8353 case 398:
8354 #line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8355 {
8356 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8357 (yyval.interm.type).basicType = EbtSampler;
8358 (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube);
8359 }
8360 #line 8361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8361 break;
8362
8363 case 399:
8364 #line 2712 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8365 {
8366 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8367 (yyval.interm.type).basicType = EbtSampler;
8368 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true);
8369 }
8370 #line 8371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8371 break;
8372
8373 case 400:
8374 #line 2717 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8375 {
8376 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8377 (yyval.interm.type).basicType = EbtSampler;
8378 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true);
8379 }
8380 #line 8381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8381 break;
8382
8383 case 401:
8384 #line 2722 "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(EbtInt, EsdCube, true);
8389 }
8390 #line 8391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8391 break;
8392
8393 case 402:
8394 #line 2727 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8395 {
8396 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8397 (yyval.interm.type).basicType = EbtSampler;
8398 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D);
8399 }
8400 #line 8401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8401 break;
8402
8403 case 403:
8404 #line 2732 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8405 {
8406 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8407 (yyval.interm.type).basicType = EbtSampler;
8408 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D);
8409 }
8410 #line 8411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8411 break;
8412
8413 case 404:
8414 #line 2737 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8415 {
8416 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8417 (yyval.interm.type).basicType = EbtSampler;
8418 (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D);
8419 }
8420 #line 8421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8421 break;
8422
8423 case 405:
8424 #line 2742 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8425 {
8426 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8427 (yyval.interm.type).basicType = EbtSampler;
8428 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube);
8429 }
8430 #line 8431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8431 break;
8432
8433 case 406:
8434 #line 2747 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8435 {
8436 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8437 (yyval.interm.type).basicType = EbtSampler;
8438 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true);
8439 }
8440 #line 8441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8441 break;
8442
8443 case 407:
8444 #line 2752 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8445 {
8446 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8447 (yyval.interm.type).basicType = EbtSampler;
8448 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true);
8449 }
8450 #line 8451 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8451 break;
8452
8453 case 408:
8454 #line 2757 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8455 {
8456 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8457 (yyval.interm.type).basicType = EbtSampler;
8458 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true);
8459 }
8460 #line 8461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8461 break;
8462
8463 case 409:
8464 #line 2762 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8465 {
8466 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8467 (yyval.interm.type).basicType = EbtSampler;
8468 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect);
8469 }
8470 #line 8471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8471 break;
8472
8473 case 410:
8474 #line 2767 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8475 {
8476 #ifdef AMD_EXTENSIONS
8477 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8478 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8479 (yyval.interm.type).basicType = EbtSampler;
8480 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect);
8481 #endif
8482 }
8483 #line 8484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8484 break;
8485
8486 case 411:
8487 #line 2775 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8488 {
8489 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8490 (yyval.interm.type).basicType = EbtSampler;
8491 (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect);
8492 }
8493 #line 8494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8494 break;
8495
8496 case 412:
8497 #line 2780 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8498 {
8499 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8500 (yyval.interm.type).basicType = EbtSampler;
8501 (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect);
8502 }
8503 #line 8504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8504 break;
8505
8506 case 413:
8507 #line 2785 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8508 {
8509 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8510 (yyval.interm.type).basicType = EbtSampler;
8511 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer);
8512 }
8513 #line 8514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8514 break;
8515
8516 case 414:
8517 #line 2790 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8518 {
8519 #ifdef AMD_EXTENSIONS
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 #endif
8525 }
8526 #line 8527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8527 break;
8528
8529 case 415:
8530 #line 2798 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8531 {
8532 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8533 (yyval.interm.type).basicType = EbtSampler;
8534 (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer);
8535 }
8536 #line 8537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8537 break;
8538
8539 case 416:
8540 #line 2803 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8541 {
8542 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8543 (yyval.interm.type).basicType = EbtSampler;
8544 (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer);
8545 }
8546 #line 8547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8547 break;
8548
8549 case 417:
8550 #line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8551 {
8552 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8553 (yyval.interm.type).basicType = EbtSampler;
8554 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true);
8555 }
8556 #line 8557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8557 break;
8558
8559 case 418:
8560 #line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8561 {
8562 #ifdef AMD_EXTENSIONS
8563 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8564 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8565 (yyval.interm.type).basicType = EbtSampler;
8566 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
8567 #endif
8568 }
8569 #line 8570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8570 break;
8571
8572 case 419:
8573 #line 2821 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8574 {
8575 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8576 (yyval.interm.type).basicType = EbtSampler;
8577 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true);
8578 }
8579 #line 8580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8580 break;
8581
8582 case 420:
8583 #line 2826 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8584 {
8585 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8586 (yyval.interm.type).basicType = EbtSampler;
8587 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true);
8588 }
8589 #line 8590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8590 break;
8591
8592 case 421:
8593 #line 2831 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8594 {
8595 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8596 (yyval.interm.type).basicType = EbtSampler;
8597 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true);
8598 }
8599 #line 8600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8600 break;
8601
8602 case 422:
8603 #line 2836 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8604 {
8605 #ifdef AMD_EXTENSIONS
8606 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
8607 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8608 (yyval.interm.type).basicType = EbtSampler;
8609 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
8610 #endif
8611 }
8612 #line 8613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8613 break;
8614
8615 case 423:
8616 #line 2844 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8617 {
8618 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8619 (yyval.interm.type).basicType = EbtSampler;
8620 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true);
8621 }
8622 #line 8623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8623 break;
8624
8625 case 424:
8626 #line 2849 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8627 {
8628 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8629 (yyval.interm.type).basicType = EbtSampler;
8630 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true);
8631 }
8632 #line 8633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8633 break;
8634
8635 case 425:
8636 #line 2854 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8637 {
8638 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8639 (yyval.interm.type).basicType = EbtSampler;
8640 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D);
8641 }
8642 #line 8643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8643 break;
8644
8645 case 426:
8646 #line 2859 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8647 {
8648 #ifdef AMD_EXTENSIONS
8649 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8650 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8651 (yyval.interm.type).basicType = EbtSampler;
8652 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D);
8653 #endif
8654 }
8655 #line 8656 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8656 break;
8657
8658 case 427:
8659 #line 2867 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8660 {
8661 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8662 (yyval.interm.type).basicType = EbtSampler;
8663 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D);
8664 }
8665 #line 8666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8666 break;
8667
8668 case 428:
8669 #line 2872 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8670 {
8671 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8672 (yyval.interm.type).basicType = EbtSampler;
8673 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D);
8674 }
8675 #line 8676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8676 break;
8677
8678 case 429:
8679 #line 2877 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8680 {
8681 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8682 (yyval.interm.type).basicType = EbtSampler;
8683 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D);
8684 }
8685 #line 8686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8686 break;
8687
8688 case 430:
8689 #line 2882 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8690 {
8691 #ifdef AMD_EXTENSIONS
8692 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8693 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8694 (yyval.interm.type).basicType = EbtSampler;
8695 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D);
8696 #endif
8697 }
8698 #line 8699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8699 break;
8700
8701 case 431:
8702 #line 2890 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8703 {
8704 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8705 (yyval.interm.type).basicType = EbtSampler;
8706 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D);
8707 }
8708 #line 8709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8709 break;
8710
8711 case 432:
8712 #line 2895 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8713 {
8714 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8715 (yyval.interm.type).basicType = EbtSampler;
8716 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D);
8717 }
8718 #line 8719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8719 break;
8720
8721 case 433:
8722 #line 2900 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8723 {
8724 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8725 (yyval.interm.type).basicType = EbtSampler;
8726 (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D);
8727 }
8728 #line 8729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8729 break;
8730
8731 case 434:
8732 #line 2905 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8733 {
8734 #ifdef AMD_EXTENSIONS
8735 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8736 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8737 (yyval.interm.type).basicType = EbtSampler;
8738 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D);
8739 #endif
8740 }
8741 #line 8742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8742 break;
8743
8744 case 435:
8745 #line 2913 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8746 {
8747 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8748 (yyval.interm.type).basicType = EbtSampler;
8749 (yyval.interm.type).sampler.setImage(EbtInt, Esd3D);
8750 }
8751 #line 8752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8752 break;
8753
8754 case 436:
8755 #line 2918 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8756 {
8757 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8758 (yyval.interm.type).basicType = EbtSampler;
8759 (yyval.interm.type).sampler.setImage(EbtUint, Esd3D);
8760 }
8761 #line 8762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8762 break;
8763
8764 case 437:
8765 #line 2923 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8766 {
8767 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8768 (yyval.interm.type).basicType = EbtSampler;
8769 (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect);
8770 }
8771 #line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8772 break;
8773
8774 case 438:
8775 #line 2928 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8776 {
8777 #ifdef AMD_EXTENSIONS
8778 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8779 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8780 (yyval.interm.type).basicType = EbtSampler;
8781 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect);
8782 #endif
8783 }
8784 #line 8785 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8785 break;
8786
8787 case 439:
8788 #line 2936 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8789 {
8790 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8791 (yyval.interm.type).basicType = EbtSampler;
8792 (yyval.interm.type).sampler.setImage(EbtInt, EsdRect);
8793 }
8794 #line 8795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8795 break;
8796
8797 case 440:
8798 #line 2941 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8799 {
8800 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8801 (yyval.interm.type).basicType = EbtSampler;
8802 (yyval.interm.type).sampler.setImage(EbtUint, EsdRect);
8803 }
8804 #line 8805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8805 break;
8806
8807 case 441:
8808 #line 2946 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8809 {
8810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8811 (yyval.interm.type).basicType = EbtSampler;
8812 (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube);
8813 }
8814 #line 8815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8815 break;
8816
8817 case 442:
8818 #line 2951 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8819 {
8820 #ifdef AMD_EXTENSIONS
8821 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8822 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8823 (yyval.interm.type).basicType = EbtSampler;
8824 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube);
8825 #endif
8826 }
8827 #line 8828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8828 break;
8829
8830 case 443:
8831 #line 2959 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8832 {
8833 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8834 (yyval.interm.type).basicType = EbtSampler;
8835 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube);
8836 }
8837 #line 8838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8838 break;
8839
8840 case 444:
8841 #line 2964 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8842 {
8843 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8844 (yyval.interm.type).basicType = EbtSampler;
8845 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube);
8846 }
8847 #line 8848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8848 break;
8849
8850 case 445:
8851 #line 2969 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8852 {
8853 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8854 (yyval.interm.type).basicType = EbtSampler;
8855 (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer);
8856 }
8857 #line 8858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8858 break;
8859
8860 case 446:
8861 #line 2974 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8862 {
8863 #ifdef AMD_EXTENSIONS
8864 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8865 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8866 (yyval.interm.type).basicType = EbtSampler;
8867 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer);
8868 #endif
8869 }
8870 #line 8871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8871 break;
8872
8873 case 447:
8874 #line 2982 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8875 {
8876 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8877 (yyval.interm.type).basicType = EbtSampler;
8878 (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer);
8879 }
8880 #line 8881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8881 break;
8882
8883 case 448:
8884 #line 2987 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8885 {
8886 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8887 (yyval.interm.type).basicType = EbtSampler;
8888 (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer);
8889 }
8890 #line 8891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8891 break;
8892
8893 case 449:
8894 #line 2992 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8895 {
8896 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8897 (yyval.interm.type).basicType = EbtSampler;
8898 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true);
8899 }
8900 #line 8901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8901 break;
8902
8903 case 450:
8904 #line 2997 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8905 {
8906 #ifdef AMD_EXTENSIONS
8907 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8908 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8909 (yyval.interm.type).basicType = EbtSampler;
8910 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true);
8911 #endif
8912 }
8913 #line 8914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8914 break;
8915
8916 case 451:
8917 #line 3005 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8918 {
8919 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8920 (yyval.interm.type).basicType = EbtSampler;
8921 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true);
8922 }
8923 #line 8924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8924 break;
8925
8926 case 452:
8927 #line 3010 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8928 {
8929 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8930 (yyval.interm.type).basicType = EbtSampler;
8931 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true);
8932 }
8933 #line 8934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8934 break;
8935
8936 case 453:
8937 #line 3015 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8938 {
8939 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8940 (yyval.interm.type).basicType = EbtSampler;
8941 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true);
8942 }
8943 #line 8944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8944 break;
8945
8946 case 454:
8947 #line 3020 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8948 {
8949 #ifdef AMD_EXTENSIONS
8950 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8951 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8952 (yyval.interm.type).basicType = EbtSampler;
8953 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true);
8954 #endif
8955 }
8956 #line 8957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8957 break;
8958
8959 case 455:
8960 #line 3028 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8961 {
8962 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8963 (yyval.interm.type).basicType = EbtSampler;
8964 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true);
8965 }
8966 #line 8967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8967 break;
8968
8969 case 456:
8970 #line 3033 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8971 {
8972 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8973 (yyval.interm.type).basicType = EbtSampler;
8974 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true);
8975 }
8976 #line 8977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8977 break;
8978
8979 case 457:
8980 #line 3038 "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(EbtFloat, EsdCube, true);
8985 }
8986 #line 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
8987 break;
8988
8989 case 458:
8990 #line 3043 "MachineIndependent/glslang.y" /* yacc.c:1646 */
8991 {
8992 #ifdef AMD_EXTENSIONS
8993 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
8994 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
8995 (yyval.interm.type).basicType = EbtSampler;
8996 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true);
8997 #endif
8998 }
8999 #line 9000 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9000 break;
9001
9002 case 459:
9003 #line 3051 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9004 {
9005 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9006 (yyval.interm.type).basicType = EbtSampler;
9007 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true);
9008 }
9009 #line 9010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9010 break;
9011
9012 case 460:
9013 #line 3056 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9014 {
9015 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9016 (yyval.interm.type).basicType = EbtSampler;
9017 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true);
9018 }
9019 #line 9020 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9020 break;
9021
9022 case 461:
9023 #line 3061 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9024 {
9025 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9026 (yyval.interm.type).basicType = EbtSampler;
9027 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true);
9028 }
9029 #line 9030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9030 break;
9031
9032 case 462:
9033 #line 3066 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9034 {
9035 #ifdef AMD_EXTENSIONS
9036 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
9037 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9038 (yyval.interm.type).basicType = EbtSampler;
9039 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true);
9040 #endif
9041 }
9042 #line 9043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9043 break;
9044
9045 case 463:
9046 #line 3074 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9047 {
9048 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9049 (yyval.interm.type).basicType = EbtSampler;
9050 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true);
9051 }
9052 #line 9053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9053 break;
9054
9055 case 464:
9056 #line 3079 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9057 {
9058 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9059 (yyval.interm.type).basicType = EbtSampler;
9060 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true);
9061 }
9062 #line 9063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9063 break;
9064
9065 case 465:
9066 #line 3084 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9067 {
9068 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9069 (yyval.interm.type).basicType = EbtSampler;
9070 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true);
9071 }
9072 #line 9073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9073 break;
9074
9075 case 466:
9076 #line 3089 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9077 {
9078 #ifdef AMD_EXTENSIONS
9079 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
9080 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9081 (yyval.interm.type).basicType = EbtSampler;
9082 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true);
9083 #endif
9084 }
9085 #line 9086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9086 break;
9087
9088 case 467:
9089 #line 3097 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9090 {
9091 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9092 (yyval.interm.type).basicType = EbtSampler;
9093 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true);
9094 }
9095 #line 9096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9096 break;
9097
9098 case 468:
9099 #line 3102 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9100 {
9101 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9102 (yyval.interm.type).basicType = EbtSampler;
9103 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true);
9104 }
9105 #line 9106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9106 break;
9107
9108 case 469:
9109 #line 3107 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9110 { // GL_OES_EGL_image_external
9111 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9112 (yyval.interm.type).basicType = EbtSampler;
9113 (yyval.interm.type).sampler.set(EbtFloat, Esd2D);
9114 (yyval.interm.type).sampler.external = true;
9115 }
9116 #line 9117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9117 break;
9118
9119 case 470:
9120 #line 3113 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9121 {
9122 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9123 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9124 (yyval.interm.type).basicType = EbtSampler;
9125 (yyval.interm.type).sampler.setSubpass(EbtFloat);
9126 }
9127 #line 9128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9128 break;
9129
9130 case 471:
9131 #line 3119 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9132 {
9133 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9134 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9135 (yyval.interm.type).basicType = EbtSampler;
9136 (yyval.interm.type).sampler.setSubpass(EbtFloat, true);
9137 }
9138 #line 9139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9139 break;
9140
9141 case 472:
9142 #line 3125 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9143 {
9144 #ifdef AMD_EXTENSIONS
9145 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
9146 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9147 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9148 (yyval.interm.type).basicType = EbtSampler;
9149 (yyval.interm.type).sampler.setSubpass(EbtFloat16);
9150 #endif
9151 }
9152 #line 9153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9153 break;
9154
9155 case 473:
9156 #line 3134 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9157 {
9158 #ifdef AMD_EXTENSIONS
9159 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
9160 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9161 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9162 (yyval.interm.type).basicType = EbtSampler;
9163 (yyval.interm.type).sampler.setSubpass(EbtFloat16, true);
9164 #endif
9165 }
9166 #line 9167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9167 break;
9168
9169 case 474:
9170 #line 3143 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9171 {
9172 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9173 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9174 (yyval.interm.type).basicType = EbtSampler;
9175 (yyval.interm.type).sampler.setSubpass(EbtInt);
9176 }
9177 #line 9178 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9178 break;
9179
9180 case 475:
9181 #line 3149 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9182 {
9183 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9184 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9185 (yyval.interm.type).basicType = EbtSampler;
9186 (yyval.interm.type).sampler.setSubpass(EbtInt, true);
9187 }
9188 #line 9189 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9189 break;
9190
9191 case 476:
9192 #line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9193 {
9194 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9195 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9196 (yyval.interm.type).basicType = EbtSampler;
9197 (yyval.interm.type).sampler.setSubpass(EbtUint);
9198 }
9199 #line 9200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9200 break;
9201
9202 case 477:
9203 #line 3161 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9204 {
9205 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input");
9206 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9207 (yyval.interm.type).basicType = EbtSampler;
9208 (yyval.interm.type).sampler.setSubpass(EbtUint, true);
9209 }
9210 #line 9211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9211 break;
9212
9213 case 478:
9214 #line 3167 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9215 {
9216 (yyval.interm.type) = (yyvsp[0].interm.type);
9217 (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
9218 parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type));
9219 }
9220 #line 9221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9221 break;
9222
9223 case 479:
9224 #line 3172 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9225 {
9226 //
9227 // This is for user defined type names. The lexical phase looked up the
9228 // type.
9229 //
9230 if (const TVariable* variable = ((yyvsp[0].lex).symbol)->getAsVariable()) {
9231 const TType& structure = variable->getType();
9232 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9233 (yyval.interm.type).basicType = EbtStruct;
9234 (yyval.interm.type).userDef = &structure;
9235 } else
9236 parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), "");
9237 }
9238 #line 9239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9239 break;
9240
9241 case 480:
9242 #line 3188 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9243 {
9244 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier");
9245 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9246 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh);
9247 }
9248 #line 9249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9249 break;
9250
9251 case 481:
9252 #line 3193 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9253 {
9254 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier");
9255 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9256 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium);
9257 }
9258 #line 9259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9259 break;
9260
9261 case 482:
9262 #line 3198 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9263 {
9264 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier");
9265 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel());
9266 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow);
9267 }
9268 #line 9269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9269 break;
9270
9271 case 483:
9272 #line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9273 { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); }
9274 #line 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9275 break;
9276
9277 case 484:
9278 #line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9279 {
9280 TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string);
9281 parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure);
9282 TVariable* userTypeDef = new TVariable((yyvsp[-4].lex).string, *structure, true);
9283 if (! parseContext.symbolTable.insert(*userTypeDef))
9284 parseContext.error((yyvsp[-4].lex).loc, "redefinition", (yyvsp[-4].lex).string->c_str(), "struct");
9285 (yyval.interm.type).init((yyvsp[-5].lex).loc);
9286 (yyval.interm.type).basicType = EbtStruct;
9287 (yyval.interm.type).userDef = structure;
9288 --parseContext.structNestingLevel;
9289 }
9290 #line 9291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9291 break;
9292
9293 case 485:
9294 #line 3217 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9295 { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); }
9296 #line 9297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9297 break;
9298
9299 case 486:
9300 #line 3217 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9301 {
9302 TType* structure = new TType((yyvsp[-1].interm.typeList), TString(""));
9303 (yyval.interm.type).init((yyvsp[-4].lex).loc);
9304 (yyval.interm.type).basicType = EbtStruct;
9305 (yyval.interm.type).userDef = structure;
9306 --parseContext.structNestingLevel;
9307 }
9308 #line 9309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9309 break;
9310
9311 case 487:
9312 #line 3227 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9313 {
9314 (yyval.interm.typeList) = (yyvsp[0].interm.typeList);
9315 }
9316 #line 9317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9317 break;
9318
9319 case 488:
9320 #line 3230 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9321 {
9322 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9323 for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) {
9324 for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) {
9325 if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName())
9326 parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str());
9327 }
9328 (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]);
9329 }
9330 }
9331 #line 9332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9332 break;
9333
9334 case 489:
9335 #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9336 {
9337 if ((yyvsp[-2].interm.type).arraySizes) {
9338 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
9339 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
9340 if (parseContext.profile == EEsProfile)
9341 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
9342 }
9343
9344 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9345
9346 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
9347 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
9348
9349 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
9350 TType type((yyvsp[-2].interm.type));
9351 type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
9352 type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
9353 type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
9354 parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
9355 (*(yyval.interm.typeList))[i].type->shallowCopy(type);
9356 }
9357 }
9358 #line 9359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9359 break;
9360
9361 case 490:
9362 #line 3265 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9363 {
9364 if ((yyvsp[-2].interm.type).arraySizes) {
9365 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
9366 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type");
9367 if (parseContext.profile == EEsProfile)
9368 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes);
9369 }
9370
9371 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList);
9372
9373 parseContext.memberQualifierCheck((yyvsp[-3].interm.type));
9374 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType);
9375 parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true);
9376 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier);
9377
9378 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) {
9379 TType type((yyvsp[-2].interm.type));
9380 type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName());
9381 type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes());
9382 type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes);
9383 parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes());
9384 (*(yyval.interm.typeList))[i].type->shallowCopy(type);
9385 }
9386 }
9387 #line 9388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9388 break;
9389
9390 case 491:
9391 #line 3292 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9392 {
9393 (yyval.interm.typeList) = new TTypeList;
9394 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
9395 }
9396 #line 9397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9397 break;
9398
9399 case 492:
9400 #line 3296 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9401 {
9402 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine));
9403 }
9404 #line 9405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9405 break;
9406
9407 case 493:
9408 #line 3302 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9409 {
9410 (yyval.interm.typeLine).type = new TType(EbtVoid);
9411 (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc;
9412 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string);
9413 }
9414 #line 9415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9415 break;
9416
9417 case 494:
9418 #line 3307 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9419 {
9420 parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes);
9421
9422 (yyval.interm.typeLine).type = new TType(EbtVoid);
9423 (yyval.interm.typeLine).loc = (yyvsp[-1].lex).loc;
9424 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string);
9425 (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes);
9426 }
9427 #line 9428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9428 break;
9429
9430 case 495:
9431 #line 3318 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9432 {
9433 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9434 }
9435 #line 9436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9436 break;
9437
9438 case 496:
9439 #line 3321 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9440 {
9441 const char* initFeature = "{ } style initializers";
9442 parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature);
9443 parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
9444 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
9445 }
9446 #line 9447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9447 break;
9448
9449 case 497:
9450 #line 3327 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9451 {
9452 const char* initFeature = "{ } style initializers";
9453 parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature);
9454 parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature);
9455 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode);
9456 }
9457 #line 9458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9458 break;
9459
9460 case 498:
9461 #line 3336 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9462 {
9463 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc());
9464 }
9465 #line 9466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9466 break;
9467
9468 case 499:
9469 #line 3339 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9470 {
9471 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode));
9472 }
9473 #line 9474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9474 break;
9475
9476 case 500:
9477 #line 3345 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9478 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9479 #line 9480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9480 break;
9481
9482 case 501:
9483 #line 3349 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9484 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9485 #line 9486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9486 break;
9487
9488 case 502:
9489 #line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9490 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9491 #line 9492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9492 break;
9493
9494 case 503:
9495 #line 3356 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9496 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9497 #line 9498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9498 break;
9499
9500 case 504:
9501 #line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9502 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9503 #line 9504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9504 break;
9505
9506 case 505:
9507 #line 3358 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9508 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9509 #line 9510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9510 break;
9511
9512 case 506:
9513 #line 3359 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9514 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9515 #line 9516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9516 break;
9517
9518 case 507:
9519 #line 3360 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9520 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9521 #line 9522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9522 break;
9523
9524 case 508:
9525 #line 3361 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9526 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9527 #line 9528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9528 break;
9529
9530 case 509:
9531 #line 3362 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9532 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9533 #line 9534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9534 break;
9535
9536 case 510:
9537 #line 3366 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9538 { (yyval.interm.intermNode) = 0; }
9539 #line 9540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9540 break;
9541
9542 case 511:
9543 #line 3367 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9544 {
9545 parseContext.symbolTable.push();
9546 ++parseContext.statementNestingLevel;
9547 }
9548 #line 9549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9549 break;
9550
9551 case 512:
9552 #line 3371 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9553 {
9554 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9555 --parseContext.statementNestingLevel;
9556 }
9557 #line 9558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9558 break;
9559
9560 case 513:
9561 #line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9562 {
9563 if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate())
9564 (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9565 (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode);
9566 }
9567 #line 9568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9568 break;
9569
9570 case 514:
9571 #line 3383 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9572 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9573 #line 9574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9574 break;
9575
9576 case 515:
9577 #line 3384 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9578 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
9579 #line 9580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9580 break;
9581
9582 case 516:
9583 #line 3388 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9584 {
9585 ++parseContext.controlFlowNestingLevel;
9586 }
9587 #line 9588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9588 break;
9589
9590 case 517:
9591 #line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9592 {
9593 --parseContext.controlFlowNestingLevel;
9594 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9595 }
9596 #line 9597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9597 break;
9598
9599 case 518:
9600 #line 3395 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9601 {
9602 parseContext.symbolTable.push();
9603 ++parseContext.statementNestingLevel;
9604 ++parseContext.controlFlowNestingLevel;
9605 }
9606 #line 9607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9607 break;
9608
9609 case 519:
9610 #line 3400 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9611 {
9612 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9613 --parseContext.statementNestingLevel;
9614 --parseContext.controlFlowNestingLevel;
9615 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9616 }
9617 #line 9618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9618 break;
9619
9620 case 520:
9621 #line 3409 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9622 {
9623 (yyval.interm.intermNode) = 0;
9624 }
9625 #line 9626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9626 break;
9627
9628 case 521:
9629 #line 3412 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9630 {
9631 if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate())
9632 (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9633 (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode);
9634 }
9635 #line 9636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9636 break;
9637
9638 case 522:
9639 #line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9640 {
9641 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode));
9642 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
9643 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
9644 parseContext.wrapupSwitchSubsequence(0, (yyvsp[0].interm.intermNode));
9645 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case
9646 }
9647 }
9648 #line 9649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9649 break;
9650
9651 case 523:
9652 #line 3428 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9653 {
9654 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase ||
9655 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) {
9656 parseContext.wrapupSwitchSubsequence((yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0, (yyvsp[0].interm.intermNode));
9657 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case
9658 } else
9659 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
9660 }
9661 #line 9662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9662 break;
9663
9664 case 524:
9665 #line 3439 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9666 { (yyval.interm.intermNode) = 0; }
9667 #line 9668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9668 break;
9669
9670 case 525:
9671 #line 3440 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9672 { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
9673 #line 9674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9674 break;
9675
9676 case 526:
9677 #line 3444 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9678 {
9679 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9680 }
9681 #line 9682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9682 break;
9683
9684 case 527:
9685 #line 3447 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9686 {
9687 parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9688 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9689 }
9690 #line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9691 break;
9692
9693 case 528:
9694 #line 3453 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9695 {
9696 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode));
9697 (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc);
9698 }
9699 #line 9700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9700 break;
9701
9702 case 529:
9703 #line 3460 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9704 {
9705 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
9706 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
9707 }
9708 #line 9709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9709 break;
9710
9711 case 530:
9712 #line 3464 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9713 {
9714 (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
9715 (yyval.interm.nodePair).node2 = 0;
9716 }
9717 #line 9718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9718 break;
9719
9720 case 531:
9721 #line 3472 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9722 {
9723 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9724 parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode));
9725 }
9726 #line 9727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9727 break;
9728
9729 case 532:
9730 #line 3476 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9731 {
9732 parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type));
9733
9734 TType type((yyvsp[-3].interm.type));
9735 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode));
9736 if (initNode)
9737 (yyval.interm.intermTypedNode) = initNode->getAsTyped();
9738 else
9739 (yyval.interm.intermTypedNode) = 0;
9740 }
9741 #line 9742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9742 break;
9743
9744 case 533:
9745 #line 3489 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9746 {
9747 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9748 }
9749 #line 9750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9750 break;
9751
9752 case 534:
9753 #line 3492 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9754 {
9755 parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9756 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9757 }
9758 #line 9759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9759 break;
9760
9761 case 535:
9762 #line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9763 {
9764 // start new switch sequence on the switch stack
9765 ++parseContext.controlFlowNestingLevel;
9766 ++parseContext.statementNestingLevel;
9767 parseContext.switchSequenceStack.push_back(new TIntermSequence);
9768 parseContext.switchLevel.push_back(parseContext.statementNestingLevel);
9769 parseContext.symbolTable.push();
9770 }
9771 #line 9772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9772 break;
9773
9774 case 536:
9775 #line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9776 {
9777 (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0);
9778 delete parseContext.switchSequenceStack.back();
9779 parseContext.switchSequenceStack.pop_back();
9780 parseContext.switchLevel.pop_back();
9781 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9782 --parseContext.statementNestingLevel;
9783 --parseContext.controlFlowNestingLevel;
9784 }
9785 #line 9786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9786 break;
9787
9788 case 537:
9789 #line 3518 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9790 {
9791 (yyval.interm.intermNode) = 0;
9792 }
9793 #line 9794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9794 break;
9795
9796 case 538:
9797 #line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9798 {
9799 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9800 }
9801 #line 9802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9802 break;
9803
9804 case 539:
9805 #line 3527 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9806 {
9807 (yyval.interm.intermNode) = 0;
9808 if (parseContext.switchLevel.size() == 0)
9809 parseContext.error((yyvsp[-2].lex).loc, "cannot appear outside switch statement", "case", "");
9810 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
9811 parseContext.error((yyvsp[-2].lex).loc, "cannot be nested inside control flow", "case", "");
9812 else {
9813 parseContext.constantValueCheck((yyvsp[-1].interm.intermTypedNode), "case");
9814 parseContext.integerCheck((yyvsp[-1].interm.intermTypedNode), "case");
9815 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc);
9816 }
9817 }
9818 #line 9819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9819 break;
9820
9821 case 540:
9822 #line 3539 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9823 {
9824 (yyval.interm.intermNode) = 0;
9825 if (parseContext.switchLevel.size() == 0)
9826 parseContext.error((yyvsp[-1].lex).loc, "cannot appear outside switch statement", "default", "");
9827 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel)
9828 parseContext.error((yyvsp[-1].lex).loc, "cannot be nested inside control flow", "default", "");
9829 else
9830 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc);
9831 }
9832 #line 9833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9833 break;
9834
9835 case 541:
9836 #line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9837 {
9838 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9839 }
9840 #line 9841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9841 break;
9842
9843 case 542:
9844 #line 3554 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9845 {
9846 parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode));
9847 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9848 }
9849 #line 9850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9850 break;
9851
9852 case 543:
9853 #line 3560 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9854 {
9855 if (! parseContext.limits.whileLoops)
9856 parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", "");
9857 parseContext.symbolTable.push();
9858 ++parseContext.loopNestingLevel;
9859 ++parseContext.statementNestingLevel;
9860 ++parseContext.controlFlowNestingLevel;
9861 }
9862 #line 9863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9863 break;
9864
9865 case 544:
9866 #line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9867 {
9868 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9869 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc);
9870 --parseContext.loopNestingLevel;
9871 --parseContext.statementNestingLevel;
9872 --parseContext.controlFlowNestingLevel;
9873 }
9874 #line 9875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9875 break;
9876
9877 case 545:
9878 #line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9879 {
9880 ++parseContext.loopNestingLevel;
9881 ++parseContext.statementNestingLevel;
9882 ++parseContext.controlFlowNestingLevel;
9883 }
9884 #line 9885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9885 break;
9886
9887 case 546:
9888 #line 3580 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9889 {
9890 if (! parseContext.limits.whileLoops)
9891 parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", "");
9892
9893 parseContext.boolCheck((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode));
9894
9895 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[-5].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, false, (yyvsp[-4].lex).loc);
9896 --parseContext.loopNestingLevel;
9897 --parseContext.statementNestingLevel;
9898 --parseContext.controlFlowNestingLevel;
9899 }
9900 #line 9901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9901 break;
9902
9903 case 547:
9904 #line 3591 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9905 {
9906 parseContext.symbolTable.push();
9907 ++parseContext.loopNestingLevel;
9908 ++parseContext.statementNestingLevel;
9909 ++parseContext.controlFlowNestingLevel;
9910 }
9911 #line 9912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9912 break;
9913
9914 case 548:
9915 #line 3597 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9916 {
9917 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
9918 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc);
9919 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);
9920 if (! parseContext.limits.nonInductiveForLoops)
9921 parseContext.inductiveLoopCheck((yyvsp[-6].lex).loc, (yyvsp[-3].interm.intermNode), forLoop);
9922 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyval.interm.intermNode), forLoop, (yyvsp[-6].lex).loc);
9923 (yyval.interm.intermNode)->getAsAggregate()->setOperator(EOpSequence);
9924 --parseContext.loopNestingLevel;
9925 --parseContext.statementNestingLevel;
9926 --parseContext.controlFlowNestingLevel;
9927 }
9928 #line 9929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9929 break;
9930
9931 case 549:
9932 #line 3612 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9933 {
9934 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9935 }
9936 #line 9937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9937 break;
9938
9939 case 550:
9940 #line 3615 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9941 {
9942 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
9943 }
9944 #line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9945 break;
9946
9947 case 551:
9948 #line 3621 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9949 {
9950 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
9951 }
9952 #line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9953 break;
9954
9955 case 552:
9956 #line 3624 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9957 {
9958 (yyval.interm.intermTypedNode) = 0;
9959 }
9960 #line 9961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9961 break;
9962
9963 case 553:
9964 #line 3630 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9965 {
9966 (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
9967 (yyval.interm.nodePair).node2 = 0;
9968 }
9969 #line 9970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9970 break;
9971
9972 case 554:
9973 #line 3634 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9974 {
9975 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
9976 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
9977 }
9978 #line 9979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9979 break;
9980
9981 case 555:
9982 #line 3641 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9983 {
9984 if (parseContext.loopNestingLevel <= 0)
9985 parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", "");
9986 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc);
9987 }
9988 #line 9989 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9989 break;
9990
9991 case 556:
9992 #line 3646 "MachineIndependent/glslang.y" /* yacc.c:1646 */
9993 {
9994 if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0)
9995 parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", "");
9996 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc);
9997 }
9998 #line 9999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
9999 break;
10000
10001 case 557:
10002 #line 3651 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10003 {
10004 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc);
10005 if (parseContext.currentFunctionType->getBasicType() != EbtVoid)
10006 parseContext.error((yyvsp[-1].lex).loc, "non-void function must return a value", "return", "");
10007 if (parseContext.inMain)
10008 parseContext.postEntryPointReturn = true;
10009 }
10010 #line 10011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10011 break;
10012
10013 case 558:
10014 #line 3658 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10015 {
10016 (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode));
10017 }
10018 #line 10019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10019 break;
10020
10021 case 559:
10022 #line 3661 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10023 {
10024 parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard");
10025 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc);
10026 }
10027 #line 10028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10028 break;
10029
10030 case 560:
10031 #line 3670 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10032 {
10033 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10034 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
10035 }
10036 #line 10037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10037 break;
10038
10039 case 561:
10040 #line 3674 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10041 {
10042 if ((yyvsp[0].interm.intermNode) != nullptr) {
10043 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode));
10044 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode));
10045 }
10046 }
10047 #line 10048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10048 break;
10049
10050 case 562:
10051 #line 3683 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10052 {
10053 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10054 }
10055 #line 10056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10056 break;
10057
10058 case 563:
10059 #line 3686 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10060 {
10061 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
10062 }
10063 #line 10064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10064 break;
10065
10066 case 564:
10067 #line 3689 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10068 {
10069 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon");
10070 parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon");
10071 (yyval.interm.intermNode) = nullptr;
10072 }
10073 #line 10074 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10074 break;
10075
10076 case 565:
10077 #line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10078 {
10079 (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */);
10080 (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function);
10081 }
10082 #line 10083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10083 break;
10084
10085 case 566:
10086 #line 3701 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10087 {
10088 // May be best done as post process phase on intermediate code
10089 if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue)
10090 parseContext.error((yyvsp[-2].interm).loc, "function does not return a value:", "", (yyvsp[-2].interm).function->getName().c_str());
10091 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]);
10092 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermNode));
10093 parseContext.intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[-2].interm).function->getType(), (yyvsp[-2].interm).loc);
10094 (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[-2].interm).function->getMangledName().c_str());
10095
10096 // store the pragma information for debug and optimize and other vendor specific
10097 // information. This information can be queried from the parse tree
10098 (yyval.interm.intermNode)->getAsAggregate()->setOptimize(parseContext.contextPragma.optimize);
10099 (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug);
10100 (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable);
10101 }
10102 #line 10103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10103 break;
10104
10105 case 567:
10106 #line 3719 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10107 {
10108 (yyval.interm.attributes) = (yyvsp[-2].interm.attributes);
10109 parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute");
10110 }
10111 #line 10112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10112 break;
10113
10114 case 568:
10115 #line 3725 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10116 {
10117 (yyval.interm.attributes) = (yyvsp[0].interm.attributes);
10118 }
10119 #line 10120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10120 break;
10121
10122 case 569:
10123 #line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10124 {
10125 (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes));
10126 }
10127 #line 10128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10128 break;
10129
10130 case 570:
10131 #line 3733 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10132 {
10133 (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string);
10134 }
10135 #line 10136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10136 break;
10137
10138 case 571:
10139 #line 3736 "MachineIndependent/glslang.y" /* yacc.c:1646 */
10140 {
10141 (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode));
10142 }
10143 #line 10144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10144 break;
10145
10146
10147 #line 10148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */
10148 default: break;
10149 }
10150 /* User semantic actions sometimes alter yychar, and that requires
10151 that yytoken be updated with the new translation. We take the
10152 approach of translating immediately before every use of yytoken.
10153 One alternative is translating here after every semantic action,
10154 but that translation would be missed if the semantic action invokes
10155 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10156 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
10157 incorrect destructor might then be invoked immediately. In the
10158 case of YYERROR or YYBACKUP, subsequent parser actions might lead
10159 to an incorrect destructor call or verbose syntax error message
10160 before the lookahead is translated. */
10161 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10162
10163 YYPOPSTACK (yylen);
10164 yylen = 0;
10165 YY_STACK_PRINT (yyss, yyssp);
10166
10167 *++yyvsp = yyval;
10168
10169 /* Now 'shift' the result of the reduction. Determine what state
10170 that goes to, based on the state we popped back to and the rule
10171 number reduced by. */
10172
10173 yyn = yyr1[yyn];
10174
10175 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10176 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10177 yystate = yytable[yystate];
10178 else
10179 yystate = yydefgoto[yyn - YYNTOKENS];
10180
10181 goto yynewstate;
10182
10183
10184 /*--------------------------------------.
10185 | yyerrlab -- here on detecting error. |
10186 `--------------------------------------*/
10187 yyerrlab:
10188 /* Make sure we have latest lookahead translation. See comments at
10189 user semantic actions for why this is necessary. */
10190 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10191
10192 /* If not already recovering from an error, report this error. */
10193 if (!yyerrstatus)
10194 {
10195 ++yynerrs;
10196 #if ! YYERROR_VERBOSE
10197 yyerror (pParseContext, YY_("syntax error"));
10198 #else
10199 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10200 yyssp, yytoken)
10201 {
10202 char const *yymsgp = YY_("syntax error");
10203 int yysyntax_error_status;
10204 yysyntax_error_status = YYSYNTAX_ERROR;
10205 if (yysyntax_error_status == 0)
10206 yymsgp = yymsg;
10207 else if (yysyntax_error_status == 1)
10208 {
10209 if (yymsg != yymsgbuf)
10210 YYSTACK_FREE (yymsg);
10211 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
10212 if (!yymsg)
10213 {
10214 yymsg = yymsgbuf;
10215 yymsg_alloc = sizeof yymsgbuf;
10216 yysyntax_error_status = 2;
10217 }
10218 else
10219 {
10220 yysyntax_error_status = YYSYNTAX_ERROR;
10221 yymsgp = yymsg;
10222 }
10223 }
10224 yyerror (pParseContext, yymsgp);
10225 if (yysyntax_error_status == 2)
10226 goto yyexhaustedlab;
10227 }
10228 # undef YYSYNTAX_ERROR
10229 #endif
10230 }
10231
10232
10233
10234 if (yyerrstatus == 3)
10235 {
10236 /* If just tried and failed to reuse lookahead token after an
10237 error, discard it. */
10238
10239 if (yychar <= YYEOF)
10240 {
10241 /* Return failure if at end of input. */
10242 if (yychar == YYEOF)
10243 YYABORT;
10244 }
10245 else
10246 {
10247 yydestruct ("Error: discarding",
10248 yytoken, &yylval, pParseContext);
10249 yychar = YYEMPTY;
10250 }
10251 }
10252
10253 /* Else will try to reuse lookahead token after shifting the error
10254 token. */
10255 goto yyerrlab1;
10256
10257
10258 /*---------------------------------------------------.
10259 | yyerrorlab -- error raised explicitly by YYERROR. |
10260 `---------------------------------------------------*/
10261 yyerrorlab:
10262
10263 /* Pacify compilers like GCC when the user code never invokes
10264 YYERROR and the label yyerrorlab therefore never appears in user
10265 code. */
10266 if (/*CONSTCOND*/ 0)
10267 goto yyerrorlab;
10268
10269 /* Do not reclaim the symbols of the rule whose action triggered
10270 this YYERROR. */
10271 YYPOPSTACK (yylen);
10272 yylen = 0;
10273 YY_STACK_PRINT (yyss, yyssp);
10274 yystate = *yyssp;
10275 goto yyerrlab1;
10276
10277
10278 /*-------------------------------------------------------------.
10279 | yyerrlab1 -- common code for both syntax error and YYERROR. |
10280 `-------------------------------------------------------------*/
10281 yyerrlab1:
10282 yyerrstatus = 3; /* Each real token shifted decrements this. */
10283
10284 for (;;)
10285 {
10286 yyn = yypact[yystate];
10287 if (!yypact_value_is_default (yyn))
10288 {
10289 yyn += YYTERROR;
10290 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10291 {
10292 yyn = yytable[yyn];
10293 if (0 < yyn)
10294 break;
10295 }
10296 }
10297
10298 /* Pop the current state because it cannot handle the error token. */
10299 if (yyssp == yyss)
10300 YYABORT;
10301
10302
10303 yydestruct ("Error: popping",
10304 yystos[yystate], yyvsp, pParseContext);
10305 YYPOPSTACK (1);
10306 yystate = *yyssp;
10307 YY_STACK_PRINT (yyss, yyssp);
10308 }
10309
10310 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
10311 *++yyvsp = yylval;
10312 YY_IGNORE_MAYBE_UNINITIALIZED_END
10313
10314
10315 /* Shift the error token. */
10316 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10317
10318 yystate = yyn;
10319 goto yynewstate;
10320
10321
10322 /*-------------------------------------.
10323 | yyacceptlab -- YYACCEPT comes here. |
10324 `-------------------------------------*/
10325 yyacceptlab:
10326 yyresult = 0;
10327 goto yyreturn;
10328
10329 /*-----------------------------------.
10330 | yyabortlab -- YYABORT comes here. |
10331 `-----------------------------------*/
10332 yyabortlab:
10333 yyresult = 1;
10334 goto yyreturn;
10335
10336 #if !defined yyoverflow || YYERROR_VERBOSE
10337 /*-------------------------------------------------.
10338 | yyexhaustedlab -- memory exhaustion comes here. |
10339 `-------------------------------------------------*/
10340 yyexhaustedlab:
10341 yyerror (pParseContext, YY_("memory exhausted"));
10342 yyresult = 2;
10343 /* Fall through. */
10344 #endif
10345
10346 yyreturn:
10347 if (yychar != YYEMPTY)
10348 {
10349 /* Make sure we have latest lookahead translation. See comments at
10350 user semantic actions for why this is necessary. */
10351 yytoken = YYTRANSLATE (yychar);
10352 yydestruct ("Cleanup: discarding lookahead",
10353 yytoken, &yylval, pParseContext);
10354 }
10355 /* Do not reclaim the symbols of the rule whose action triggered
10356 this YYABORT or YYACCEPT. */
10357 YYPOPSTACK (yylen);
10358 YY_STACK_PRINT (yyss, yyssp);
10359 while (yyssp != yyss)
10360 {
10361 yydestruct ("Cleanup: popping",
10362 yystos[*yyssp], yyvsp, pParseContext);
10363 YYPOPSTACK (1);
10364 }
10365 #ifndef yyoverflow
10366 if (yyss != yyssa)
10367 YYSTACK_FREE (yyss);
10368 #endif
10369 #if YYERROR_VERBOSE
10370 if (yymsg != yymsgbuf)
10371 YYSTACK_FREE (yymsg);
10372 #endif
10373 return yyresult;
10374 }
10375 #line 3740 "MachineIndependent/glslang.y" /* yacc.c:1906 */
10376
10377