diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionString.error.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionString.error.vert.out new file mode 100644 index 0000000000..c253eb31a6 --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionString.error.vert.out @@ -0,0 +1,13 @@ +spv.intrinsicsSpirvInstructionString.error.vert +ERROR: 0:9: 'userFunc' : 'spirv_string' can only be used as a parameter of a function defined with 'spirv_instruction' for argument 1 +ERROR: 0:12: 'makeString' : 'spirv_string' cannot be used as a function return type +ERROR: 0:15: 'outParam' : 'spirv_string' parameter cannot have a qualifier other than 'in' for argument 1 +ERROR: 0:18: 'arrParam' : 'spirv_string' cannot be formed into an array for argument 1 +ERROR: 0:21: 'byRefParam' : 'spirv_string' parameter cannot have a qualifier other than 'in' for argument 1 +ERROR: 0:31: 'spirv_string' : a literal string cannot be matched to a 'spirv_by_reference' or 'spirv_literal' variadic tail +ERROR: 0:34: 'spirv_string' : a literal string cannot be matched to a 'spirv_by_reference' or 'spirv_literal' variadic tail +ERROR: 0:37: 'string' : embedded NUL character not allowed in string literal +ERROR: 8 compilation errors. No code generated. + + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionString.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionString.vert.out new file mode 100644 index 0000000000..8bdc2cbdeb --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionString.vert.out @@ -0,0 +1,35 @@ +spv.intrinsicsSpirvInstructionString.vert +Validation failed +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 20 + + Capability Shader + Extension "SPV_KHR_non_semantic_info" + 1: ExtInstImport "GLSL.std.450" + 7: ExtInstImport "NonSemantic.EXAMPLE.DebugMarker" + 15: ExtInstImport "Fictional.TestExtInstSet" + MemoryModel Logical GLSL450 + EntryPoint Vertex 4 "main" + 6: String "begin" + 10: String "end" + 12: String "" + 14: String "named" + Source GLSL 460 + SourceExtension "GL_EXT_spirv_intrinsics" + SourceExtension "GL_EXT_spirv_intrinsics_string" + Name 4 "main" + 2: TypeVoid + 3: TypeFunction 2 + 17: TypeInt 32 1 + 18: 17(int) Constant 42 + 4(main): 2 Function None 3 + 5: Label + 8: 2 ExtInst 7(NonSemantic.EXAMPLE.DebugMarker) 1(Round) 6 + 9: 2 ExtInst 7(NonSemantic.EXAMPLE.DebugMarker) 1(Round) 6 + 11: 2 ExtInst 7(NonSemantic.EXAMPLE.DebugMarker) 1(Round) 10 + 13: 2 ExtInst 7(NonSemantic.EXAMPLE.DebugMarker) 1(Round) 12 + 16: 2 ExtInst 15(Fictional.TestExtInstSet) 2(RoundEven) 14 + 19: 2 ExtInst 15(Fictional.TestExtInstSet) 3(Trunc) 18 + Return + FunctionEnd diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionStringVariadic.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionStringVariadic.vert.out new file mode 100644 index 0000000000..76b820ed4d --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionStringVariadic.vert.out @@ -0,0 +1,50 @@ +spv.intrinsicsSpirvInstructionStringVariadic.vert +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 27 + + Capability Shader + Extension "SPV_KHR_non_semantic_info" + 1: ExtInstImport "GLSL.std.450" + 15: ExtInstImport "NonSemantic.DebugPrintf" + MemoryModel Logical GLSL450 + EntryPoint Vertex 4 "main" + 14: String "no arguments +" + 17: String "x = %f +" + 20: String "x = %f, n = %d +" + 24: String "tail string = %s +" + 25: String "ok" + Source GLSL 460 + SourceExtension "GL_EXT_spirv_intrinsics" + SourceExtension "GL_EXT_spirv_intrinsics_string" + SourceExtension "GL_EXT_spirv_intrinsics_variadic" + Name 4 "main" + Name 8 "x" + Name 12 "n" + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypePointer Function 6(float) + 9: 6(float) Constant 1065353216 + 10: TypeInt 32 1 + 11: TypePointer Function 10(int) + 13: 10(int) Constant 3 + 4(main): 2 Function None 3 + 5: Label + 8(x): 7(ptr) Variable Function + 12(n): 11(ptr) Variable Function + Store 8(x) 9 + Store 12(n) 13 + 16: 2 ExtInst 15(NonSemantic.DebugPrintf) 1(DebugPrintf) 14 + 18: 6(float) Load 8(x) + 19: 2 ExtInst 15(NonSemantic.DebugPrintf) 1(DebugPrintf) 17 18 + 21: 6(float) Load 8(x) + 22: 10(int) Load 12(n) + 23: 2 ExtInst 15(NonSemantic.DebugPrintf) 1(DebugPrintf) 20 21 22 + 26: 2 ExtInst 15(NonSemantic.DebugPrintf) 1(DebugPrintf) 24 25 + Return + FunctionEnd diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.error.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.error.vert.out new file mode 100644 index 0000000000..0efbedc532 --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.error.vert.out @@ -0,0 +1,10 @@ +spv.intrinsicsSpirvInstructionVariadic.error.vert +ERROR: 0:10: 'userFunc' : variadic '...' can only be used on functions defined with 'spirv_instruction' +ERROR: 0:19: 'requal' : overloaded functions must have the same qualifier on the variadic tail +ERROR: 0:29: 'spirv_literal' : Non front-end constant expressions cannot be passed for a 'spirv_literal' variadic argument. +ERROR: 0:35: 'amb' : ambiguous best function under implicit type conversion +ERROR: 0:38: 'literal string as a variadic SPIR-V instruction argument' : required extension not requested: GL_EXT_spirv_intrinsics_string +ERROR: 5 compilation errors. No code generated. + + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert.out new file mode 100644 index 0000000000..6ea724eee2 --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert.out @@ -0,0 +1,8 @@ +spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert +ERROR: 0:6: '' : syntax error, unexpected COMMA, expecting RIGHT_PAREN +ERROR: 1 compilation errors. No code generated. + + +ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert.out new file mode 100644 index 0000000000..a4b110464c --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert.out @@ -0,0 +1,8 @@ +spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert +ERROR: 0:7: '' : syntax error, unexpected DOT +ERROR: 1 compilation errors. No code generated. + + +ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point + +SPIR-V is not generated for failed compile or link diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.vert.out new file mode 100644 index 0000000000..585c2a5b21 --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.vert.out @@ -0,0 +1,60 @@ +spv.intrinsicsSpirvInstructionVariadic.vert +Validation failed +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 33 + + Capability Shader + 1: ExtInstImport "GLSL.std.450" + 22: ExtInstImport "Fictional.TestExtInstSet" + MemoryModel Logical GLSL450 + EntryPoint Vertex 4 "main" 8 11 + Source GLSL 460 + SourceExtension "GL_EXT_spirv_intrinsics" + SourceExtension "GL_EXT_spirv_intrinsics_variadic" + Name 4 "main" + Name 8 "floatOut" + Name 11 "vec4In" + Name 16 "base" + Name 18 "arg" + Name 27 "p" + Name 29 "q" + Decorate 8(floatOut) Location 0 + Decorate 11(vec4In) Location 0 + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypePointer Output 6(float) + 8(floatOut): 7(ptr) Variable Output + 9: TypeVector 6(float) 4 + 10: TypePointer Input 9(fvec4) + 11(vec4In): 10(ptr) Variable Input + 14: TypeInt 32 0 + 15: TypePointer Function 14(int) + 17: 14(int) Constant 1 + 19: 14(int) Constant 7 + 26: TypePointer Function 6(float) + 28: 6(float) Constant 1065353216 + 30: 6(float) Constant 1073741824 + 4(main): 2 Function None 3 + 5: Label + 16(base): 15(ptr) Variable Function + 18(arg): 15(ptr) Variable Function + 27(p): 26(ptr) Variable Function + 29(q): 26(ptr) Variable Function + 12: 9(fvec4) Load 11(vec4In) + 13: 6(float) CompositeExtract 12 2 + Store 8(floatOut) 13 + Store 16(base) 17 + Store 18(arg) 19 + 20: 14(int) Load 16(base) + 21: 14(int) Load 18(arg) + 23: 2 ExtInst 22(Fictional.TestExtInstSet) 1(Round) 20 21 + 24: 14(int) Load 16(base) + 25: 2 ExtInst 22(Fictional.TestExtInstSet) 1(Round) 24 + Store 27(p) 28 + Store 29(q) 30 + 31: 2 ExtInst 22(Fictional.TestExtInstSet) 2(RoundEven) 27(p) 29(q) + 32: 2 ExtInst 22(Fictional.TestExtInstSet) 2(RoundEven) 27(p) + Return + FunctionEnd diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic330.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic330.vert.out new file mode 100644 index 0000000000..4191283bd9 --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadic330.vert.out @@ -0,0 +1,91 @@ +spv.intrinsicsSpirvInstructionVariadic330.vert +Validation failed +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 60 + + Capability Shader + 1: ExtInstImport "GLSL.std.450" + 22: ExtInstImport "Fictional.TestExtInstSet" + MemoryModel Logical GLSL450 + EntryPoint Vertex 4 "main" 8 11 + Source GLSL 330 + SourceExtension "GL_EXT_spirv_intrinsics" + SourceExtension "GL_EXT_spirv_intrinsics_variadic" + Name 4 "main" + Name 8 "floatOut" + Name 11 "vec4In" + Name 16 "base" + Name 18 "arg" + Name 27 "p" + Name 29 "q" + Name 35 "i" + Name 37 "f" + Decorate 8(floatOut) Location 0 + Decorate 11(vec4In) Location 0 + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeFloat 32 + 7: TypePointer Output 6(float) + 8(floatOut): 7(ptr) Variable Output + 9: TypeVector 6(float) 4 + 10: TypePointer Input 9(fvec4) + 11(vec4In): 10(ptr) Variable Input + 14: TypeInt 32 0 + 15: TypePointer Function 14(int) + 17: 14(int) Constant 1 + 19: 14(int) Constant 7 + 26: TypePointer Function 6(float) + 28: 6(float) Constant 1065353216 + 30: 6(float) Constant 1073741824 + 33: TypeInt 32 1 + 34: TypePointer Function 33(int) + 36: 33(int) Constant 1 + 4(main): 2 Function None 3 + 5: Label + 16(base): 15(ptr) Variable Function + 18(arg): 15(ptr) Variable Function + 27(p): 26(ptr) Variable Function + 29(q): 26(ptr) Variable Function + 35(i): 34(ptr) Variable Function + 37(f): 26(ptr) Variable Function + 12: 9(fvec4) Load 11(vec4In) + 13: 6(float) CompositeExtract 12 2 + Store 8(floatOut) 13 + Store 16(base) 17 + Store 18(arg) 19 + 20: 14(int) Load 16(base) + 21: 14(int) Load 18(arg) + 23: 2 ExtInst 22(Fictional.TestExtInstSet) 1(Round) 20 21 + 24: 14(int) Load 16(base) + 25: 2 ExtInst 22(Fictional.TestExtInstSet) 1(Round) 24 + Store 27(p) 28 + Store 29(q) 30 + 31: 2 ExtInst 22(Fictional.TestExtInstSet) 2(RoundEven) 27(p) 29(q) + 32: 2 ExtInst 22(Fictional.TestExtInstSet) 2(RoundEven) 27(p) + Store 35(i) 36 + Store 37(f) 28 + 38: 33(int) Load 35(i) + 39: 2 ExtInst 22(Fictional.TestExtInstSet) 10(Fract) 38 + 40: 6(float) Load 37(f) + 41: 2 ExtInst 22(Fictional.TestExtInstSet) 20(Cosh) 40 + 42: 33(int) Load 35(i) + 43: 33(int) Load 35(i) + 44: 33(int) Load 35(i) + 45: 2 ExtInst 22(Fictional.TestExtInstSet) 10(Fract) 42 43 44 + 46: 33(int) Load 35(i) + 47: 2 ExtInst 22(Fictional.TestExtInstSet) 30(Log2) 46 + 48: 33(int) Load 35(i) + 49: 33(int) Load 35(i) + 50: 2 ExtInst 22(Fictional.TestExtInstSet) 40(FMax) 48 49 + 51: 33(int) Load 35(i) + 52: 6(float) ConvertSToF 51 + 53: 33(int) Load 35(i) + 54: 2 ExtInst 22(Fictional.TestExtInstSet) 50(Fma) 52 53 + 55: 33(int) Load 35(i) + 56: 6(float) ConvertSToF 55 + 57: 33(int) Load 35(i) + 58: 33(int) Load 35(i) + 59: 2 ExtInst 22(Fictional.TestExtInstSet) 60(UnpackSnorm2x16) 56 57 58 + Return + FunctionEnd diff --git a/Test/baseResults/spv.intrinsicsSpirvInstructionVariadicOverload.vert.out b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadicOverload.vert.out new file mode 100644 index 0000000000..f6ea762e1f --- /dev/null +++ b/Test/baseResults/spv.intrinsicsSpirvInstructionVariadicOverload.vert.out @@ -0,0 +1,55 @@ +spv.intrinsicsSpirvInstructionVariadicOverload.vert +Validation failed +// Module Version 10000 +// Generated by (magic number): 8000b +// Id's are bound by 35 + + Capability Shader + 1: ExtInstImport "GLSL.std.450" + 15: ExtInstImport "Fictional.TestExtInstSet" + MemoryModel Logical GLSL450 + EntryPoint Vertex 4 "main" + Source GLSL 460 + SourceExtension "GL_EXT_spirv_intrinsics" + SourceExtension "GL_EXT_spirv_intrinsics_variadic" + Name 4 "main" + Name 8 "i" + Name 12 "f" + Name 25 "u" + 2: TypeVoid + 3: TypeFunction 2 + 6: TypeInt 32 1 + 7: TypePointer Function 6(int) + 9: 6(int) Constant 1 + 10: TypeFloat 32 + 11: TypePointer Function 10(float) + 13: 10(float) Constant 1065353216 + 23: TypeInt 32 0 + 24: TypePointer Function 23(int) + 26: 23(int) Constant 2 + 4(main): 2 Function None 3 + 5: Label + 8(i): 7(ptr) Variable Function + 12(f): 11(ptr) Variable Function + 25(u): 24(ptr) Variable Function + Store 8(i) 9 + Store 12(f) 13 + 14: 6(int) Load 8(i) + 16: 2 ExtInst 15(Fictional.TestExtInstSet) 10(Fract) 14 + 17: 10(float) Load 12(f) + 18: 2 ExtInst 15(Fictional.TestExtInstSet) 20(Cosh) 17 + 19: 6(int) Load 8(i) + 20: 6(int) Load 8(i) + 21: 6(int) Load 8(i) + 22: 2 ExtInst 15(Fictional.TestExtInstSet) 10(Fract) 19 20 21 + Store 25(u) 26 + 27: 23(int) Load 25(u) + 28: 2 ExtInst 15(Fictional.TestExtInstSet) 30(Log2) 27 + 29: 6(int) Load 8(i) + 30: 23(int) Bitcast 29 + 31: 2 ExtInst 15(Fictional.TestExtInstSet) 30(Log2) 30 + 32: 23(int) Load 25(u) + 33: 23(int) Load 25(u) + 34: 2 ExtInst 15(Fictional.TestExtInstSet) 40(FMax) 32 33 + Return + FunctionEnd diff --git a/Test/baseResults/validation_fails.txt b/Test/baseResults/validation_fails.txt index ebda3b2c7d..975a768978 100644 --- a/Test/baseResults/validation_fails.txt +++ b/Test/baseResults/validation_fails.txt @@ -69,6 +69,10 @@ Test/baseResults/spv.functionNestedOpaque.vert.out Test/baseResults/spv.imageAtomic64.frag.out Test/baseResults/spv.image.frag.out Test/baseResults/spv.int64.frag.out +Test/baseResults/spv.intrinsicsSpirvInstructionString.vert.out +Test/baseResults/spv.intrinsicsSpirvInstructionVariadic330.vert.out +Test/baseResults/spv.intrinsicsSpirvInstructionVariadicOverload.vert.out +Test/baseResults/spv.intrinsicsSpirvInstructionVariadic.vert.out Test/baseResults/spv.memoryQualifier.frag.out Test/baseResults/spv.newTexture.frag.out Test/baseResults/spv.nvgpushader5.frag.out diff --git a/Test/baseResults/variadic.comp.out b/Test/baseResults/variadic.comp.out index f4fa286164..b83c77b37d 100644 --- a/Test/baseResults/variadic.comp.out +++ b/Test/baseResults/variadic.comp.out @@ -1,26 +1,33 @@ variadic.comp -ERROR: 0:3: '...' : variadic argument specifier is only available for builtins -ERROR: 0:10: 'foo' : no matching overloaded function found -ERROR: 0:11: 'foo' : no matching overloaded function found -ERROR: 3 compilation errors. No code generated. +ERROR: 0:3: 'variadic SPIR-V instruction' : required extension not requested: GL_EXT_spirv_intrinsics_variadic +ERROR: 0:3: 'foo' : variadic '...' can only be used on functions defined with 'spirv_instruction' +ERROR: 2 compilation errors. No code generated. Shader version: 450 local_size = (1, 1, 1) ERROR: node is still EOpNull! -0:3 Function Definition: foo(i1; ( global void) +0:3 Function Definition: foo(i1;z ( global void) 0:3 Function Parameters: 0:3 'n' ( in int) 0:7 Function Definition: main( ( global void) 0:7 Function Parameters: 0:9 Sequence -0:9 Function Call: foo(i1; ( global void) +0:9 Function Call: foo(i1;z ( global void) 0:9 Constant: 0:9 7 (const int) -0:10 Constant: -0:10 0.000000 -0:11 Constant: -0:11 0.000000 +0:10 Function Call: foo(i1;z ( global void) +0:10 Constant: +0:10 8 (const int) +0:10 Constant: +0:10 43 (const int) +0:11 Function Call: foo(i1;z ( global void) +0:11 Constant: +0:11 9 (const int) +0:11 Constant: +0:11 42.000000 +0:11 Constant: +0:11 21.050000 0:? Linker Objects @@ -30,18 +37,26 @@ Linked compute stage: Shader version: 450 local_size = (1, 1, 1) ERROR: node is still EOpNull! -0:3 Function Definition: foo(i1; ( global void) +0:3 Function Definition: foo(i1;z ( global void) 0:3 Function Parameters: 0:3 'n' ( in int) 0:7 Function Definition: main( ( global void) 0:7 Function Parameters: 0:9 Sequence -0:9 Function Call: foo(i1; ( global void) +0:9 Function Call: foo(i1;z ( global void) 0:9 Constant: 0:9 7 (const int) -0:10 Constant: -0:10 0.000000 -0:11 Constant: -0:11 0.000000 +0:10 Function Call: foo(i1;z ( global void) +0:10 Constant: +0:10 8 (const int) +0:10 Constant: +0:10 43 (const int) +0:11 Function Call: foo(i1;z ( global void) +0:11 Constant: +0:11 9 (const int) +0:11 Constant: +0:11 42.000000 +0:11 Constant: +0:11 21.050000 0:? Linker Objects diff --git a/Test/spv.intrinsicsSpirvInstructionString.error.vert b/Test/spv.intrinsicsSpirvInstructionString.error.vert new file mode 100644 index 0000000000..197bf258b4 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionString.error.vert @@ -0,0 +1,38 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable +#extension GL_EXT_spirv_intrinsics_string : enable + +// ERROR: 'spirv_string' is only valid as a parameter of a 'spirv_instruction' +// function, never of an ordinary function. +void userFunc(spirv_string s); + +// ERROR: 'spirv_string' cannot be a function return type. +spirv_instruction(id = 1) spirv_string makeString(); + +// ERROR: a 'spirv_string' parameter may only be unqualified or 'in'. +spirv_instruction(id = 2) void outParam(out spirv_string s); + +// ERROR: there is no array of 'spirv_string'. +spirv_instruction(id = 3) void arrParam(spirv_string s[2]); + +// ERROR: 'spirv_by_reference' is not a permitted qualifier on 'spirv_string'. +spirv_instruction(id = 4) void byRefParam(spirv_by_reference spirv_string s); + +// Valid declarations whose variadic tails are abused at the call sites below. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 5) void litTail(spirv_literal ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 6) void refTail(spirv_by_reference ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 7) void stringArg(spirv_string s); + +void main() +{ + // ERROR: a literal string cannot be encoded into a 'spirv_literal' tail. + litTail("oops"); + + // ERROR: a literal string cannot be passed by SPIR-V pointer. + refTail("oops"); + + // ERROR: embedded NULs are not valid string literal contents. + stringArg("bad\000string"); +} diff --git a/Test/spv.intrinsicsSpirvInstructionString.vert b/Test/spv.intrinsicsSpirvInstructionString.vert new file mode 100644 index 0000000000..f0e43a42b3 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionString.vert @@ -0,0 +1,27 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_string : enable + +// Made-up instruction taking a 'spirv_string' parameter. +spirv_instruction(extensions = ["SPV_KHR_non_semantic_info"], + set = "NonSemantic.EXAMPLE.DebugMarker", id = 1) +void debugMarker(spirv_string label); + +// 'spirv_string' is a distinct type for overload resolution: a literal string +// selects this overload, an integer selects the other. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 2) +void tag(spirv_string s); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 3) +void tag(int i); + +void main() +{ + debugMarker("begin"); + debugMarker("begin"); // identical string: the OpString may be reused + debugMarker("end"); + debugMarker(""); // empty string: OpString with only the NUL terminator + + tag("named"); // selects tag(spirv_string) + tag(42); // selects tag(int) +} diff --git a/Test/spv.intrinsicsSpirvInstructionStringVariadic.vert b/Test/spv.intrinsicsSpirvInstructionStringVariadic.vert new file mode 100644 index 0000000000..ebbd2751a0 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionStringVariadic.vert @@ -0,0 +1,23 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable +#extension GL_EXT_spirv_intrinsics_string : enable + +// With GL_EXT_spirv_intrinsics_string and GL_EXT_spirv_intrinsics_variadic +// together, NonSemantic.DebugPrintf can be expressed. It is named differently +// here to avoid a naming conflict. +spirv_instruction(extensions = ["SPV_KHR_non_semantic_info"], + set = "NonSemantic.DebugPrintf", id = 1) +void printfStr(spirv_string format, ...); + +void main() +{ + float x = 1.0; + int n = 3; + + printfStr("no arguments\n"); // format only, empty tail + printfStr("x = %f\n", x); // one trailing argument + printfStr("x = %f, n = %d\n", x, n); // two trailing arguments + printfStr("tail string = %s\n", "ok"); +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadic.error.vert b/Test/spv.intrinsicsSpirvInstructionVariadic.error.vert new file mode 100644 index 0000000000..b7056a8505 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadic.error.vert @@ -0,0 +1,39 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +spirv_instruction(id = 81) +float extractComp(vec4 composite, spirv_literal ...); + +// The ellipsis is only valid on a 'spirv_instruction' declaration. +void userFunc(int n, ...); + +// Two variadic overloads that tie on their (identical) leading parameter. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 1) void amb(uint x, ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 2) void amb(uint x, uint y, ...); + +// ERROR: the same signature redeclared with a different qualifier on the tail. +// The tail qualifier is not part of the signature, so it must not change. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 3) void requal(float x, ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 3) void requal(float x, spirv_literal ...); + +spirv_instruction(set = "Fictional.TestExtInstSet", id = 4) void rawTail(...); + +layout(location = 0) in vec4 vec4In; +layout(location = 1) in int dyn; + +void main() +{ + // ERROR: a 'spirv_literal' trailing argument must be a front-end constant. + float f = extractComp(vec4In, dyn); + + // ERROR: ambiguous between amb(uint, ...) and amb(uint, uint, ...); the + // trailing tail does not disambiguate. + uint a = 1u; + uint b = 2u; + amb(a, b); + + // ERROR: string literals are not valid trailing variadic SPIR-V operands. + rawTail("oops"); +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert b/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert new file mode 100644 index 0000000000..09d426d381 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert @@ -0,0 +1,10 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +spirv_instruction(id = 1) void bad(..., int x); + +void main() +{ +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert b/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert new file mode 100644 index 0000000000..33b855bfbf --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert @@ -0,0 +1,15 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +spirv_instruction(id = 81) +float extractComp(vec4 composite, spirv_literal . . .); + +layout(location = 0) in vec4 vec4In; +layout(location = 0) out float floatOut; + +void main() +{ + floatOut = extractComp(vec4In, 2); +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadic.vert b/Test/spv.intrinsicsSpirvInstructionVariadic.vert new file mode 100644 index 0000000000..74aae0aa2d --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadic.vert @@ -0,0 +1,38 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +// Literal tail: each trailing argument is encoded as a literal operand. Here the +// trailing arguments are the literal index list of OpCompositeExtract. +spirv_instruction(id = 81) // OpCompositeExtract +float extractComp(vec4 composite, spirv_literal ...); + +// Default (by-id) tail: each trailing argument is encoded by . This is the +// form needed to express a printf-like instruction, shown here with a fictional +// extended instruction set. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 1) +void byId(uint base, ...); + +// By-reference tail: each trailing argument is passed as a SPIR-V pointer. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 2) +void byRef(spirv_by_reference ...); + +layout(location = 0) in vec4 vec4In; +layout(location = 0) out float floatOut; + +void main() +{ + // OpCompositeExtract with literal index 2. + floatOut = extractComp(vec4In, 2); + + uint base = 1u; + uint arg = 7u; + byId(base, arg); // two trailing arguments, by id + byId(base); // zero trailing arguments + + float p = 1.0; + float q = 2.0; + byRef(p, q); // trailing arguments passed by pointer + byRef(p); // single trailing argument: no fixed params, one operand +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadic330.vert b/Test/spv.intrinsicsSpirvInstructionVariadic330.vert new file mode 100644 index 0000000000..e057473992 --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadic330.vert @@ -0,0 +1,73 @@ +#version 330 + +// Same as spv.intrinsicsSpirvInstructionVariadic / ...Overload, but at a version +// that uses the findFunction120 overload resolver instead of findFunction400, to +// cover the variadic tail on that path. Implicit conversions are limited to those +// valid in GLSL 330 (e.g. int->float, but not int->uint). + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +// Literal tail: each trailing argument is encoded as a literal operand. +spirv_instruction(id = 81) // OpCompositeExtract +float extractComp(vec4 composite, spirv_literal ...); + +// Default (by-id) tail: each trailing argument is encoded by . +spirv_instruction(set = "Fictional.TestExtInstSet", id = 1) +void byId(uint base, ...); + +// By-reference tail: each trailing argument is passed as a SPIR-V pointer. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 2) +void byRef(spirv_by_reference ...); + +// A trailing variadic tail does not participate in overload resolution: a call is +// resolved on its fixed (leading) parameters. An exact match on the fixed +// parameter beats a match through implicit conversion. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 10) void pick(int x, ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 20) void pick(float x, ...); + +// A fixed-arity overload alongside a variadic one of the same name. When the two +// tie on the fixed parameter, the non-variadic is preferred; the variadic is +// selected only when the call supplies more arguments than the fixed form accepts. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 30) void pickArity(int x); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 40) void pickArity(int x, ...); + +// A fixed parameter still receives the ordinary implicit conversion when the +// call also supplies arguments for the variadic tail. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 50) void convertFirst(float x, ...); + +// Best-match ranking is still applied to fixed parameters shared by variadic +// overloads. The tail does not participate. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 60) void rank(float x, int y, ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 70) void rank(float x, float y, ...); + +in vec4 vec4In; +out float floatOut; + +void main() +{ + // OpCompositeExtract with literal index 2. + floatOut = extractComp(vec4In, 2); + + uint base = 1u; + uint arg = 7u; + byId(base, arg); // two trailing arguments, by id + byId(base); // zero trailing arguments + + float p = 1.0; + float q = 2.0; + byRef(p, q); // trailing arguments passed by pointer + byRef(p); // single trailing argument: no fixed params, one operand + + int i = 1; + float f = 1.0; + pick(i); // pick(int, ...) exact int beats int->float + pick(f); // pick(float, ...) + pick(i, i, i); // pick(int, ...) trailing arguments ignored by resolution + + pickArity(i); // pickArity(int) exact match, non-variadic preferred + pickArity(i, i); // pickArity(int, ...) only the variadic accepts two arguments + + convertFirst(i, i); // fixed argument converted, tail argument left as-is + rank(i, i, i); // rank(float, int, ...) wins on the second fixed arg +} diff --git a/Test/spv.intrinsicsSpirvInstructionVariadicOverload.vert b/Test/spv.intrinsicsSpirvInstructionVariadicOverload.vert new file mode 100644 index 0000000000..beb737950b --- /dev/null +++ b/Test/spv.intrinsicsSpirvInstructionVariadicOverload.vert @@ -0,0 +1,33 @@ +#version 460 + +#extension GL_EXT_spirv_intrinsics : enable +#extension GL_EXT_spirv_intrinsics_variadic : enable + +// A trailing variadic tail does not participate in overload resolution: a call +// is resolved on its fixed (leading) parameters using the ordinary rules. + +// Distinct leading parameter types are separated by the ordinary conversion +// rules; the tail plays no part. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 10) void pick(int x, ...); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 20) void pick(float x, ...); + +// A fixed-arity overload alongside a variadic one of the same name. When the two +// tie on the fixed parameter, the non-variadic is preferred -- whether the call's +// argument matches exactly or through an implicit conversion. The variadic is +// selected only when the call supplies more arguments than the fixed form accepts. +spirv_instruction(set = "Fictional.TestExtInstSet", id = 30) void pickArity(uint x); +spirv_instruction(set = "Fictional.TestExtInstSet", id = 40) void pickArity(uint x, ...); + +void main() +{ + int i = 1; + float f = 1.0; + pick(i); // pick(int, ...) exact int beats int->float + pick(f); // pick(float, ...) + pick(i, i, i); // pick(int, ...) trailing arguments ignored by resolution + + uint u = 2u; + pickArity(u); // pickArity(uint) exact match, non-variadic preferred + pickArity(i); // pickArity(uint) int->uint conversion, non-variadic still preferred + pickArity(u, u); // pickArity(uint, ...) only the variadic accepts two arguments +} diff --git a/glslang/Include/BaseTypes.h b/glslang/Include/BaseTypes.h index e681ca0dc7..759a0d873d 100644 --- a/glslang/Include/BaseTypes.h +++ b/glslang/Include/BaseTypes.h @@ -80,7 +80,7 @@ enum TBasicType { // SPIR-V type defined by spirv_type EbtSpirvType, - // HLSL types that live only temporarily. + // Only temporary, or in SPIR-V instruction function parameters. EbtString, EbtNumTypes diff --git a/glslang/MachineIndependent/ParseContextBase.cpp b/glslang/MachineIndependent/ParseContextBase.cpp index 50bec19f30..be2fde04e3 100644 --- a/glslang/MachineIndependent/ParseContextBase.cpp +++ b/glslang/MachineIndependent/ParseContextBase.cpp @@ -497,10 +497,19 @@ const TFunction* TParseContextBase::selectFunction( return enabled; }; + // The variadic tail (GL_EXT_spirv_intrinsics_variadic) does not participate in + // overload resolution: it is the lowest-priority discriminator. When 'can1' and + // 'can2' are otherwise equally ranked on their fixed parameters, a variadic + // candidate loses to a non-variadic one. + const auto variadicallyWorse = [&equivalentParams](const TFunction& can1, const TFunction& can2) -> bool { + return equivalentParams(can1, can2) && can1.isVariadic() && !can2.isVariadic(); + }; + const TFunction* incumbent = viableCandidates.front(); for (auto it = viableCandidates.begin() + 1; it != viableCandidates.end(); ++it) { const TFunction& candidate = *(*it); - if (betterParam(*incumbent, candidate) && ! betterParam(candidate, *incumbent)) + if ((betterParam(*incumbent, candidate) && ! betterParam(candidate, *incumbent)) || + variadicallyWorse(*incumbent, candidate)) incumbent = &candidate; } @@ -510,6 +519,11 @@ const TFunction* TParseContextBase::selectFunction( continue; const TFunction& candidate = *(*it); + // A variadic candidate that ties with the non-variadic incumbent is resolved + // in favor of the incumbent above, so it is not an ambiguity. + if (variadicallyWorse(candidate, *incumbent)) + continue; + // In the case of default parameters, it may have an identical initial set, which is // also ambiguous if ((betterParam(*incumbent, candidate) || equivalentParams(*incumbent, candidate)) && enabled(candidate)) diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp index 407317187d..b270641b58 100644 --- a/glslang/MachineIndependent/ParseHelper.cpp +++ b/glslang/MachineIndependent/ParseHelper.cpp @@ -1230,6 +1230,34 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct error(loc, "'spirv_literal' can only be used on functions defined with 'spirv_instruction' for argument", function.getName().c_str(), "%d", i + 1); } + // A variadic tail ('...') in a non-builtin declaration is only meaningful + // for a built-in function or for a 'spirv_instruction' function (as enabled + // by GL_EXT_spirv_intrinsics_variadic) + if (!parsingBuiltins && function.isVariadic() && function.getBuiltInOp() != EOpSpirvInst) + error(loc, "variadic '...' can only be used on functions defined with 'spirv_instruction'", + function.getName().c_str(), ""); + + // The 'spirv_string' pseudo-type (GL_EXT_spirv_intrinsics_string) may only + // appear as the type of a parameter of a 'spirv_instruction' function, with + // no qualifier other than 'in', and never as an array or as return type. + if (!parsingBuiltins) { + if (function.getType().getBasicType() == EbtString) + error(loc, "'spirv_string' cannot be used as a function return type", function.getName().c_str(), ""); + for (int i = 0; i < function.getParamCount(); ++i) { + const TType& paramType = *function[i].type; + if (paramType.getBasicType() != EbtString) + continue; + if (function.getBuiltInOp() != EOpSpirvInst) + error(loc, "'spirv_string' can only be used as a parameter of a function defined with " + "'spirv_instruction' for argument", function.getName().c_str(), "%d", i + 1); + if (paramType.isArray()) + error(loc, "'spirv_string' cannot be formed into an array for argument", + function.getName().c_str(), "%d", i + 1); + if (paramType.getQualifier().storage != EvqIn || paramType.getQualifier().isSpirvByReference()) + error(loc, "'spirv_string' parameter cannot have a qualifier other than 'in' for argument", + function.getName().c_str(), "%d", i + 1); + } + } // For function declaration with SPIR-V instruction qualifier, always ignore the built-in function and // respect this redeclared one. @@ -1254,6 +1282,14 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct if (*(*prevDec)[i].type != *function[i].type) parameterTypesDiffer = true; } + // The qualifier on a variadic tail is not part of the signature, so two + // declarations must agree on it. + if (function.isVariadic() && + (prevDec->isVariadicSpirvLiteral() != function.isVariadicSpirvLiteral() || + prevDec->isVariadicSpirvByReference() != function.isVariadicSpirvByReference())) { + error(loc, "overloaded functions must have the same qualifier on the variadic tail", + function.getName().c_str(), ""); + } if (!parameterTypesDiffer && prevDec->getType() != function.getType()) error(loc, "overloaded functions must have the same return type", function.getName().c_str(), ""); } @@ -1538,7 +1574,7 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction i == 1) { TStorageQualifier storage = arg->getAsTyped()->getType().getQualifier().storage; if (storage != EvqBuffer && storage != EvqShared) { - error(arguments->getLoc(), "buffer argument must be in buffer or shared storage", + error(arguments->getLoc(), "buffer argument must be in buffer or shared storage", fnCandidate->getName().c_str(), ""); } } @@ -2294,8 +2330,18 @@ TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNo const TFunction& function) { checkLocation(loc, function.getBuiltInOp()); + // A variadic call may not necessarily be able to be lowered to a unary node, + // so we look at the number of arguments actually passed in. + bool unary = function.getParamCount() == 1; + if (function.isVariadic()) { + TIntermAggregate* argList = arguments ? arguments->getAsAggregate() : nullptr; + if (argList != nullptr && argList->getOp() == EOpNull) + unary = argList->getSequence().size() == 1; + else + unary = arguments != nullptr; + } TIntermTyped *result = intermediate.addBuiltInFunctionCall(loc, function.getBuiltInOp(), - function.getParamCount() == 1, + unary, arguments, function.getType()); // EXT_descriptor_heap @@ -2333,24 +2379,69 @@ TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNo // Special handling for function call with SPIR-V instruction qualifier specified if (function.getBuiltInOp() == EOpSpirvInst) { + // Propagate spirv_by_reference/spirv_literal from parameters to arguments. + // For a variadic declaration, trailing arguments beyond the fixed parameters + // take the qualifier declared on the '...' tail, if any. + const int fixedParamCount = function.getParamCount(); + const bool tailByReference = function.isVariadicSpirvByReference(); + const bool tailLiteral = function.isVariadicSpirvLiteral(); if (auto agg = result->getAsAggregate()) { - // Propogate spirv_by_reference/spirv_literal from parameters to arguments auto& sequence = agg->getSequence(); for (unsigned i = 0; i < sequence.size(); ++i) { - if (function[i].type->getQualifier().isSpirvByReference()) + const bool byReference = static_cast(i) < fixedParamCount + ? function[i].type->getQualifier().isSpirvByReference() : tailByReference; + const bool literal = static_cast(i) < fixedParamCount + ? function[i].type->getQualifier().isSpirvLiteral() : tailLiteral; + const bool stringArg = sequence[i]->getAsTyped()->getBasicType() == EbtString; + if (stringArg && static_cast(i) >= fixedParamCount) + requireExtensions(loc, 1, &E_GL_EXT_spirv_intrinsics_string, + "literal string as a variadic SPIR-V instruction argument"); + // A literal string lowers to an OpString ; it cannot be encoded + // as an inline literal nor passed by SPIR-V pointer + if (stringArg && (byReference || literal)) + error(loc, "a literal string cannot be matched to a 'spirv_by_reference' or 'spirv_literal' " + "variadic tail", "spirv_string", ""); + if (byReference) sequence[i]->getAsTyped()->getQualifier().setSpirvByReference(); - if (function[i].type->getQualifier().isSpirvLiteral()) + if (literal) { sequence[i]->getAsTyped()->getQualifier().setSpirvLiteral(); + // Trailing 'spirv_literal' arguments must reduce to a front-end + // constant (fixed parameters are checked in handleFunctionCall). + if (static_cast(i) >= fixedParamCount && + !sequence[i]->getAsTyped()->getQualifier().isFrontEndConstant()) + error(loc, "Non front-end constant expressions cannot be passed for a 'spirv_literal' " + "variadic argument.", "spirv_literal", ""); + } } // Attach the function call to SPIR-V intruction agg->setSpirvInstruction(function.getSpirvInstruction()); } else if (auto unaryNode = result->getAsUnaryNode()) { - // Propogate spirv_by_reference/spirv_literal from parameters to arguments - if (function[0].type->getQualifier().isSpirvByReference()) + // A single-argument call: the argument is either the sole fixed + // parameter or, for a zero-fixed-parameter variadic, a trailing argument. + const bool byReference = fixedParamCount > 0 + ? function[0].type->getQualifier().isSpirvByReference() : tailByReference; + const bool literal = fixedParamCount > 0 + ? function[0].type->getQualifier().isSpirvLiteral() : tailLiteral; + const bool stringArg = unaryNode->getOperand()->getBasicType() == EbtString; + if (stringArg && fixedParamCount == 0) + requireExtensions(loc, 1, &E_GL_EXT_spirv_intrinsics_string, + "literal string as a variadic SPIR-V instruction argument"); + // A literal string lowers to an OpString ; it cannot be encoded + // as an inline literal nor passed by SPIR-V pointer + if (stringArg && (byReference || literal)) + error(loc, "a literal string cannot be matched to a 'spirv_by_reference' or 'spirv_literal' " + "variadic tail", "spirv_string", ""); + if (byReference) unaryNode->getOperand()->getQualifier().setSpirvByReference(); - if (function[0].type->getQualifier().isSpirvLiteral()) + if (literal) { unaryNode->getOperand()->getQualifier().setSpirvLiteral(); + // A lone trailing 'spirv_literal' argument (no fixed parameters) + // must reduce to a front-end constant. + if (fixedParamCount == 0 && !unaryNode->getOperand()->getQualifier().isFrontEndConstant()) + error(loc, "Non front-end constant expressions cannot be passed for a 'spirv_literal' " + "variadic argument.", "spirv_literal", ""); + } // Attach the function call to SPIR-V intruction unaryNode->setSpirvInstruction(function.getSpirvInstruction()); @@ -2403,7 +2494,12 @@ void TParseContext::computeBuiltinPrecisions(TIntermTyped& node, const TFunction return; if (TIntermUnary* unaryNode = node.getAsUnaryNode()) { - operationPrecision = std::max(function[0].type->getQualifier().precision, + // NB. A single-argument call to a variadic declaration with no fixed + // parameters produces a unary node even though there is no formal + // parameter to read a precision from. + TPrecisionQualifier paramPrecision = function.getParamCount() > 0 + ? function[0].type->getQualifier().precision : EpqNone; + operationPrecision = std::max(paramPrecision, unaryNode->getOperand()->getType().getQualifier().precision); if (function.getType().getBasicType() != EbtBool) resultPrecision = function.getType().getQualifier().precision == EpqNone ? @@ -2626,13 +2722,17 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction void TParseContext::addInputArgumentConversions(const TFunction& function, TIntermNode*& arguments) const { TIntermAggregate* aggregate = arguments->getAsAggregate(); + const bool multiArgumentList = aggregate != nullptr && aggregate->getOp() == EOpNull && + aggregate->getSequence().size() > 1; // Process each argument's conversion for (int i = 0; i < function.getParamCount(); ++i) { // At this early point there is a slight ambiguity between whether an aggregate 'arguments' // is the single argument itself or its children are the arguments. Only one argument // means take 'arguments' itself as the one argument. - TIntermTyped* arg = function.getParamCount() == 1 ? arguments->getAsTyped() : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped()); + TIntermTyped* arg = function.getParamCount() == 1 && !multiArgumentList + ? arguments->getAsTyped() + : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped()); if (*function[i].type != arg->getType()) { if (function[i].type->getQualifier().isParamInput() && !function[i].type->isCoopMat() && !function[i].type->isTensorARM() && @@ -2643,7 +2743,7 @@ void TParseContext::addInputArgumentConversions(const TFunction& function, TInte // convert to the correct type. arg = intermediate.addConversion(EOpFunctionCall, *function[i].type, arg); if (arg) { - if (function.getParamCount() == 1) + if (function.getParamCount() == 1 && !multiArgumentList) arguments = arg; else { if (aggregate) @@ -4940,7 +5040,8 @@ bool TParseContext::constructorTextureSamplerError(const TSourceLoc& loc, const return false; } -// Checks to see if a void variable has been declared and raise an error message for such a case +// Checks to see if a variable or struct/block-member declaration has been declared +// with a type that is invalid in that context, and raises an error for such a case. // // returns true in case of an error // @@ -4951,6 +5052,12 @@ bool TParseContext::voidErrorCheck(const TSourceLoc& loc, const TString& identif return true; } + if (basicType == EbtString) { + error(loc, "'spirv_string' can only be used as a 'spirv_instruction' function parameter", + identifier.c_str(), ""); + return true; + } + return false; } @@ -8488,10 +8595,45 @@ const TFunction* TParseContext::findFunction120(const TSourceLoc& loc, const TFu // a match, it is a semantic error if there are multiple ways to apply these conversions to make the call match // more than one function." - const TFunction* candidate = nullptr; TVector candidateList; symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn); + // Check whether we have a variadic function, if so, we will defer to the + // logic in selectFunction, which probably handles variadics. + bool hasVariadicCandidate = false; + for (auto it = candidateList.begin(); it != candidateList.end(); ++it) { + if ((*it)->isVariadic()) { + hasVariadicCandidate = true; + break; + } + } + + if (hasVariadicCandidate) { + const auto convertible = [this](const TType& from, const TType& to, TOperator, int) -> bool { + if (from == to) + return true; + if (from.isArray() || to.isArray() || !from.sameElementShape(to)) + return false; + return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); + }; + + // For desktop 120 through 330, the only better conversion rank this + // resolver has is exact match. Other valid implicit conversions tie. + const auto better = [](const TType& from, const TType& to1, const TType& to2) -> bool { + return from == to2 && !(from == to1); + }; + + bool tie = false; + const TFunction* candidate = selectFunction(candidateList, call, convertible, better, tie); + if (candidate == nullptr) + error(loc, "no matching overloaded function found", call.getName().c_str(), ""); + else if (tie) + error(loc, "ambiguous function signature match: multiple signatures match under implicit type conversion", call.getName().c_str(), ""); + + return candidate; + } + + const TFunction* candidate = nullptr; for (auto it = candidateList.begin(); it != candidateList.end(); ++it) { const TFunction& function = *(*it); @@ -10436,12 +10578,15 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T return intermediate.setAggregateOperator(newNode, op, type, loc); } -void TParseContext::makeVariadic(TFunction *F, const TSourceLoc &loc) { - if (parsingBuiltins) { - F->setVariadic(); - } else { - error(loc, "variadic argument specifier is only available for builtins", "...", ""); +void TParseContext::makeVariadic(TFunction *F, const TSourceLoc &loc, bool spirvLiteral, bool spirvByReference) { + if (!parsingBuiltins) { + requireExtensions(loc, 1, &E_GL_EXT_spirv_intrinsics_variadic, "variadic SPIR-V instruction"); } + F->setVariadic(); + if (spirvLiteral) + F->setVariadicSpirvLiteral(); + if (spirvByReference) + F->setVariadicSpirvByReference(); } TParameter TParseContext::getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer, diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h index aaa0a5916e..ef9431dc66 100644 --- a/glslang/MachineIndependent/ParseHelper.h +++ b/glslang/MachineIndependent/ParseHelper.h @@ -454,7 +454,7 @@ class TParseContext : public TParseContextBase { TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&); TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&); TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset); - void makeVariadic(TFunction *F, const TSourceLoc &loc); + void makeVariadic(TFunction *F, const TSourceLoc &loc, bool spirvLiteral = false, bool spirvByReference = false); TParameter getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer, const TSourceLoc& loc); void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to); diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp index 665a92e663..d6cdaeaec3 100644 --- a/glslang/MachineIndependent/Scan.cpp +++ b/glslang/MachineIndependent/Scan.cpp @@ -596,6 +596,7 @@ const std::unordered_map KeywordMap { {"spirv_storage_class",SPIRV_STORAGE_CLASS}, {"spirv_by_reference",SPIRV_BY_REFERENCE}, {"spirv_literal",SPIRV_LITERAL}, + {"spirv_string",SPIRV_STRING}, {"sampler2D",SAMPLER2D}, {"samplerCube",SAMPLERCUBE}, @@ -910,6 +911,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case PpAtomColonColon: parseContext.error(loc, "not supported", "::", ""); break; + case PpAtomEllipsis: return ELLIPSIS; case PpAtomConstString: parserToken->sType.lex.string = NewPoolTString(tokenText); return STRING_LITERAL; case PpAtomConstInt: parserToken->sType.lex.i = ppToken.ival; return INTCONSTANT; @@ -1942,6 +1944,13 @@ int TScanContext::tokenizeIdentifier() return keyword; return identifierOrType(); + case SPIRV_STRING: + // GL_EXT_spirv_intrinsics_string adds the 'spirv_string' pseudo-type + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics_string)) + return keyword; + return identifierOrType(); + case HITOBJECTNV: if (parseContext.symbolTable.atBuiltInLevel() || (!parseContext.isEsProfile() && parseContext.version >= 460 diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp index fd8a690f27..a22d989f42 100644 --- a/glslang/MachineIndependent/SymbolTable.cpp +++ b/glslang/MachineIndependent/SymbolTable.cpp @@ -85,6 +85,7 @@ void TType::buildMangledName(TString& mangledName) const case EbtAccStruct: mangledName += "as"; break; case EbtRayQuery: mangledName += "rq"; break; case EbtSpirvType: mangledName += "spv-t"; break; + case EbtString: mangledName += "str"; break; case EbtHitObjectNV: mangledName += "ho"; break; case EbtHitObjectEXT: mangledName += "ho"; break; case EbtTensorLayoutNV: mangledName += "tl"; break; @@ -445,6 +446,8 @@ TFunction::TFunction(const TFunction& copyOf) : TSymbol(copyOf) prototyped = copyOf.prototyped; implicitThis = copyOf.implicitThis; variadic = copyOf.variadic; + variadicSpirvByReference = copyOf.variadicSpirvByReference; + variadicSpirvLiteral = copyOf.variadicSpirvLiteral; illegalImplicitThis = copyOf.illegalImplicitThis; defaultParamCount = copyOf.defaultParamCount; spirvInst = copyOf.spirvInst; diff --git a/glslang/MachineIndependent/SymbolTable.h b/glslang/MachineIndependent/SymbolTable.h index 9161927493..6536b63811 100644 --- a/glslang/MachineIndependent/SymbolTable.h +++ b/glslang/MachineIndependent/SymbolTable.h @@ -255,12 +255,14 @@ class TFunction : public TSymbol { explicit TFunction(TOperator o) : TSymbol(nullptr), op(o), - defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0) { } + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), + variadicSpirvByReference(false), variadicSpirvLiteral(false), defaultParamCount(0) { } TFunction(const TString *name, const TType& retType, TOperator tOp = EOpNull) : TSymbol(name), mangledName(*name + '('), op(tOp), - defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0), + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), + variadicSpirvByReference(false), variadicSpirvLiteral(false), defaultParamCount(0), linkType(ELinkNone) { returnType.shallowCopy(retType); @@ -328,6 +330,10 @@ class TFunction : public TSymbol { mangledName += 'z'; } virtual bool isVariadic() const { return variadic; } + virtual void setVariadicSpirvByReference() { assert(writable); variadicSpirvByReference = true; } + virtual bool isVariadicSpirvByReference() const { return variadicSpirvByReference; } + virtual void setVariadicSpirvLiteral() { assert(writable); variadicSpirvLiteral = true; } + virtual bool isVariadicSpirvLiteral() const { return variadicSpirvLiteral; } // Return total number of parameters virtual int getParamCount() const { return static_cast(parameters.size()); } @@ -371,6 +377,8 @@ class TFunction : public TSymbol { // This is important for a static member function that has member variables in scope, // but is not allowed to use them, or see hidden symbols instead. bool variadic; + bool variadicSpirvByReference; // trailing variadic args passed by SPIR-V pointer + bool variadicSpirvLiteral; // trailing variadic args encoded as literals int defaultParamCount; TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp index 05f91a091c..7f4e6c16c7 100644 --- a/glslang/MachineIndependent/Versions.cpp +++ b/glslang/MachineIndependent/Versions.cpp @@ -384,6 +384,8 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_EXT_terminate_invocation] = EBhDisable; extensionBehavior[E_GL_EXT_shared_memory_block] = EBhDisable; extensionBehavior[E_GL_EXT_spirv_intrinsics] = EBhDisable; + extensionBehavior[E_GL_EXT_spirv_intrinsics_variadic] = EBhDisable; + extensionBehavior[E_GL_EXT_spirv_intrinsics_string] = EBhDisable; extensionBehavior[E_GL_EXT_mesh_shader] = EBhDisable; extensionBehavior[E_GL_EXT_opacity_micromap] = EBhDisable; extensionBehavior[E_GL_EXT_shader_quad_control] = EBhDisable; @@ -584,6 +586,8 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_EXT_ray_cull_mask 1\n" "#define GL_EXT_ray_tracing_position_fetch 1\n" "#define GL_EXT_spirv_intrinsics 1\n" + "#define GL_EXT_spirv_intrinsics_variadic 1\n" + "#define GL_EXT_spirv_intrinsics_string 1\n" "#define GL_EXT_mesh_shader 1\n" "#define GL_AMD_shader_ballot 1\n" diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h index 72f8696afd..dd7803e544 100644 --- a/glslang/MachineIndependent/Versions.h +++ b/glslang/MachineIndependent/Versions.h @@ -216,6 +216,8 @@ const char* const E_GL_EXT_null_initializer = "GL_EXT_null_initi const char* const E_GL_EXT_shared_memory_block = "GL_EXT_shared_memory_block"; const char* const E_GL_EXT_subgroup_uniform_control_flow = "GL_EXT_subgroup_uniform_control_flow"; const char* const E_GL_EXT_spirv_intrinsics = "GL_EXT_spirv_intrinsics"; +const char* const E_GL_EXT_spirv_intrinsics_variadic = "GL_EXT_spirv_intrinsics_variadic"; +const char* const E_GL_EXT_spirv_intrinsics_string = "GL_EXT_spirv_intrinsics_string"; const char* const E_GL_EXT_fragment_shader_barycentric = "GL_EXT_fragment_shader_barycentric"; const char* const E_GL_EXT_mesh_shader = "GL_EXT_mesh_shader"; const char* const E_GL_EXT_opacity_micromap = "GL_EXT_opacity_micromap"; diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y index dc06aaca58..5d13a697b5 100644 --- a/glslang/MachineIndependent/glslang.y +++ b/glslang/MachineIndependent/glslang.y @@ -252,7 +252,7 @@ extern int yylex(YYSTYPE*, TParseContext&); // spirv intrinsics %token SPIRV_INSTRUCTION SPIRV_EXECUTION_MODE SPIRV_EXECUTION_MODE_ID %token SPIRV_DECORATE SPIRV_DECORATE_ID SPIRV_DECORATE_STRING -%token SPIRV_TYPE SPIRV_STORAGE_CLASS SPIRV_BY_REFERENCE SPIRV_LITERAL +%token SPIRV_TYPE SPIRV_STORAGE_CLASS SPIRV_BY_REFERENCE SPIRV_LITERAL SPIRV_STRING %token ATTACHMENTEXT IATTACHMENTEXT UATTACHMENTEXT %token LEFT_OP RIGHT_OP @@ -262,7 +262,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token SUB_ASSIGN %token STRING_LITERAL -%token LEFT_PAREN RIGHT_PAREN LEFT_BRACKET RIGHT_BRACKET LEFT_BRACE RIGHT_BRACE DOT +%token LEFT_PAREN RIGHT_PAREN LEFT_BRACKET RIGHT_BRACKET LEFT_BRACE RIGHT_BRACE DOT ELLIPSIS %token COMMA COLON EQUAL SEMICOLON BANG DASH TILDE PLUS STAR SLASH PERCENT %token LEFT_ANGLE RIGHT_ANGLE VERTICAL_BAR CARET AMPERSAND QUESTION @@ -334,6 +334,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %type block_structure %type function_header function_declarator %type function_header_with_parameters +%type function_prototype_with_spirv_variadic_tail %type function_call_header_with_parameters function_call_header_no_parameters function_call_generic function_prototype %type function_call_or_method function_identifier function_call_header @@ -901,6 +902,13 @@ declaration $$ = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } + | spirv_instruction_qualifier function_prototype_with_spirv_variadic_tail SEMICOLON { + parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier"); + $2.function->setSpirvInstruction(*$1); // Attach SPIR-V intruction qualifier + parseContext.handleFunctionDeclarator($2.loc, *$2.function, true /* prototype */); + $$ = 0; + // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature + } | spirv_execution_mode_qualifier SEMICOLON { parseContext.globalCheck($2.loc, "SPIR-V execution mode qualifier"); parseContext.requireExtensions($2.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier"); @@ -993,6 +1001,45 @@ function_prototype parseContext.handleFunctionAttributes($3.loc, *$1); parseContext.handleFunctionAttributes($3.loc, *$4); } + | function_header ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $2.loc); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $3.loc; + } + | function_header_with_parameters COMMA ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $3.loc); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $4.loc; + } + ; + +function_prototype_with_spirv_variadic_tail + : function_header SPIRV_LITERAL ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $2.loc, true /* spirvLiteral */, false /* spirvByReference */); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $4.loc; + } + | function_header SPIRV_BY_REFERENCE ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $2.loc, false /* spirvLiteral */, true /* spirvByReference */); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $4.loc; + } + | function_header_with_parameters COMMA SPIRV_LITERAL ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $3.loc, true /* spirvLiteral */, false /* spirvByReference */); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $5.loc; + } + | function_header_with_parameters COMMA SPIRV_BY_REFERENCE ELLIPSIS RIGHT_PAREN { + parseContext.makeVariadic($1, $3.loc, false /* spirvLiteral */, true /* spirvByReference */); + $$.function = $1; + if (parseContext.compileOnly) $$.function->setExport(); + $$.loc = $5.loc; + } ; function_declarator @@ -1039,10 +1086,6 @@ function_header_with_parameters parseContext.vkRelaxedRemapFunctionParameter($1, $3.param); } } - | function_header_with_parameters COMMA DOT DOT DOT { - $$ = $1; - parseContext.makeVariadic($1, $3.loc); - } ; function_header @@ -3679,6 +3722,11 @@ type_specifier_nonarray parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); $$ = $1; } + | SPIRV_STRING { + parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics_string, "spirv_string type specifier"); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtString; + } | HITOBJECTNV { $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtHitObjectNV; diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp index 8b56f4d018..b16e2c12f0 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp +++ b/glslang/MachineIndependent/glslang_tab.cpp @@ -470,281 +470,284 @@ enum yysymbol_kind_t YYSYMBOL_SPIRV_STORAGE_CLASS = 346, /* SPIRV_STORAGE_CLASS */ YYSYMBOL_SPIRV_BY_REFERENCE = 347, /* SPIRV_BY_REFERENCE */ YYSYMBOL_SPIRV_LITERAL = 348, /* SPIRV_LITERAL */ - YYSYMBOL_ATTACHMENTEXT = 349, /* ATTACHMENTEXT */ - YYSYMBOL_IATTACHMENTEXT = 350, /* IATTACHMENTEXT */ - YYSYMBOL_UATTACHMENTEXT = 351, /* UATTACHMENTEXT */ - YYSYMBOL_LEFT_OP = 352, /* LEFT_OP */ - YYSYMBOL_RIGHT_OP = 353, /* RIGHT_OP */ - YYSYMBOL_INC_OP = 354, /* INC_OP */ - YYSYMBOL_DEC_OP = 355, /* DEC_OP */ - YYSYMBOL_LE_OP = 356, /* LE_OP */ - YYSYMBOL_GE_OP = 357, /* GE_OP */ - YYSYMBOL_EQ_OP = 358, /* EQ_OP */ - YYSYMBOL_NE_OP = 359, /* NE_OP */ - YYSYMBOL_AND_OP = 360, /* AND_OP */ - YYSYMBOL_OR_OP = 361, /* OR_OP */ - YYSYMBOL_XOR_OP = 362, /* XOR_OP */ - YYSYMBOL_MUL_ASSIGN = 363, /* MUL_ASSIGN */ - YYSYMBOL_DIV_ASSIGN = 364, /* DIV_ASSIGN */ - YYSYMBOL_ADD_ASSIGN = 365, /* ADD_ASSIGN */ - YYSYMBOL_MOD_ASSIGN = 366, /* MOD_ASSIGN */ - YYSYMBOL_LEFT_ASSIGN = 367, /* LEFT_ASSIGN */ - YYSYMBOL_RIGHT_ASSIGN = 368, /* RIGHT_ASSIGN */ - YYSYMBOL_AND_ASSIGN = 369, /* AND_ASSIGN */ - YYSYMBOL_XOR_ASSIGN = 370, /* XOR_ASSIGN */ - YYSYMBOL_OR_ASSIGN = 371, /* OR_ASSIGN */ - YYSYMBOL_SUB_ASSIGN = 372, /* SUB_ASSIGN */ - YYSYMBOL_STRING_LITERAL = 373, /* STRING_LITERAL */ - YYSYMBOL_LEFT_PAREN = 374, /* LEFT_PAREN */ - YYSYMBOL_RIGHT_PAREN = 375, /* RIGHT_PAREN */ - YYSYMBOL_LEFT_BRACKET = 376, /* LEFT_BRACKET */ - YYSYMBOL_RIGHT_BRACKET = 377, /* RIGHT_BRACKET */ - YYSYMBOL_LEFT_BRACE = 378, /* LEFT_BRACE */ - YYSYMBOL_RIGHT_BRACE = 379, /* RIGHT_BRACE */ - YYSYMBOL_DOT = 380, /* DOT */ - YYSYMBOL_COMMA = 381, /* COMMA */ - YYSYMBOL_COLON = 382, /* COLON */ - YYSYMBOL_EQUAL = 383, /* EQUAL */ - YYSYMBOL_SEMICOLON = 384, /* SEMICOLON */ - YYSYMBOL_BANG = 385, /* BANG */ - YYSYMBOL_DASH = 386, /* DASH */ - YYSYMBOL_TILDE = 387, /* TILDE */ - YYSYMBOL_PLUS = 388, /* PLUS */ - YYSYMBOL_STAR = 389, /* STAR */ - YYSYMBOL_SLASH = 390, /* SLASH */ - YYSYMBOL_PERCENT = 391, /* PERCENT */ - YYSYMBOL_LEFT_ANGLE = 392, /* LEFT_ANGLE */ - YYSYMBOL_RIGHT_ANGLE = 393, /* RIGHT_ANGLE */ - YYSYMBOL_VERTICAL_BAR = 394, /* VERTICAL_BAR */ - YYSYMBOL_CARET = 395, /* CARET */ - YYSYMBOL_AMPERSAND = 396, /* AMPERSAND */ - YYSYMBOL_QUESTION = 397, /* QUESTION */ - YYSYMBOL_INVARIANT = 398, /* INVARIANT */ - YYSYMBOL_HIGH_PRECISION = 399, /* HIGH_PRECISION */ - YYSYMBOL_MEDIUM_PRECISION = 400, /* MEDIUM_PRECISION */ - YYSYMBOL_LOW_PRECISION = 401, /* LOW_PRECISION */ - YYSYMBOL_PRECISION = 402, /* PRECISION */ - YYSYMBOL_PACKED = 403, /* PACKED */ - YYSYMBOL_RESOURCE = 404, /* RESOURCE */ - YYSYMBOL_SUPERP = 405, /* SUPERP */ - YYSYMBOL_FLOATCONSTANT = 406, /* FLOATCONSTANT */ - YYSYMBOL_INTCONSTANT = 407, /* INTCONSTANT */ - YYSYMBOL_UINTCONSTANT = 408, /* UINTCONSTANT */ - YYSYMBOL_BOOLCONSTANT = 409, /* BOOLCONSTANT */ - YYSYMBOL_IDENTIFIER = 410, /* IDENTIFIER */ - YYSYMBOL_TYPE_NAME = 411, /* TYPE_NAME */ - YYSYMBOL_CENTROID = 412, /* CENTROID */ - YYSYMBOL_IN = 413, /* IN */ - YYSYMBOL_OUT = 414, /* OUT */ - YYSYMBOL_INOUT = 415, /* INOUT */ - YYSYMBOL_STRUCT = 416, /* STRUCT */ - YYSYMBOL_VOID = 417, /* VOID */ - YYSYMBOL_WHILE = 418, /* WHILE */ - YYSYMBOL_BREAK = 419, /* BREAK */ - YYSYMBOL_CONTINUE = 420, /* CONTINUE */ - YYSYMBOL_DO = 421, /* DO */ - YYSYMBOL_ELSE = 422, /* ELSE */ - YYSYMBOL_FOR = 423, /* FOR */ - YYSYMBOL_IF = 424, /* IF */ - YYSYMBOL_DISCARD = 425, /* DISCARD */ - YYSYMBOL_RETURN = 426, /* RETURN */ - YYSYMBOL_SWITCH = 427, /* SWITCH */ - YYSYMBOL_CASE = 428, /* CASE */ - YYSYMBOL_DEFAULT = 429, /* DEFAULT */ - YYSYMBOL_TERMINATE_INVOCATION = 430, /* TERMINATE_INVOCATION */ - YYSYMBOL_TERMINATE_RAY = 431, /* TERMINATE_RAY */ - YYSYMBOL_IGNORE_INTERSECTION = 432, /* IGNORE_INTERSECTION */ - YYSYMBOL_UNIFORM = 433, /* UNIFORM */ - YYSYMBOL_SHARED = 434, /* SHARED */ - YYSYMBOL_BUFFER = 435, /* BUFFER */ - YYSYMBOL_TILEIMAGEEXT = 436, /* TILEIMAGEEXT */ - YYSYMBOL_FLAT = 437, /* FLAT */ - YYSYMBOL_SMOOTH = 438, /* SMOOTH */ - YYSYMBOL_LAYOUT = 439, /* LAYOUT */ - YYSYMBOL_DOUBLECONSTANT = 440, /* DOUBLECONSTANT */ - YYSYMBOL_INT16CONSTANT = 441, /* INT16CONSTANT */ - YYSYMBOL_UINT16CONSTANT = 442, /* UINT16CONSTANT */ - YYSYMBOL_FLOAT16CONSTANT = 443, /* FLOAT16CONSTANT */ - YYSYMBOL_INT32CONSTANT = 444, /* INT32CONSTANT */ - YYSYMBOL_UINT32CONSTANT = 445, /* UINT32CONSTANT */ - YYSYMBOL_INT64CONSTANT = 446, /* INT64CONSTANT */ - YYSYMBOL_UINT64CONSTANT = 447, /* UINT64CONSTANT */ - YYSYMBOL_SUBROUTINE = 448, /* SUBROUTINE */ - YYSYMBOL_DEMOTE = 449, /* DEMOTE */ - YYSYMBOL_FUNCTION = 450, /* FUNCTION */ - YYSYMBOL_PAYLOADNV = 451, /* PAYLOADNV */ - YYSYMBOL_PAYLOADINNV = 452, /* PAYLOADINNV */ - YYSYMBOL_HITATTRNV = 453, /* HITATTRNV */ - YYSYMBOL_CALLDATANV = 454, /* CALLDATANV */ - YYSYMBOL_CALLDATAINNV = 455, /* CALLDATAINNV */ - YYSYMBOL_PAYLOADEXT = 456, /* PAYLOADEXT */ - YYSYMBOL_PAYLOADINEXT = 457, /* PAYLOADINEXT */ - YYSYMBOL_HITATTREXT = 458, /* HITATTREXT */ - YYSYMBOL_CALLDATAEXT = 459, /* CALLDATAEXT */ - YYSYMBOL_CALLDATAINEXT = 460, /* CALLDATAINEXT */ - YYSYMBOL_PATCH = 461, /* PATCH */ - YYSYMBOL_SAMPLE = 462, /* SAMPLE */ - YYSYMBOL_NONUNIFORM = 463, /* NONUNIFORM */ - YYSYMBOL_RESOURCEHEAP = 464, /* RESOURCEHEAP */ - YYSYMBOL_SAMPLERHEAP = 465, /* SAMPLERHEAP */ - YYSYMBOL_COHERENT = 466, /* COHERENT */ - YYSYMBOL_VOLATILE = 467, /* VOLATILE */ - YYSYMBOL_RESTRICT = 468, /* RESTRICT */ - YYSYMBOL_READONLY = 469, /* READONLY */ - YYSYMBOL_WRITEONLY = 470, /* WRITEONLY */ - YYSYMBOL_NONTEMPORAL = 471, /* NONTEMPORAL */ - YYSYMBOL_DEVICECOHERENT = 472, /* DEVICECOHERENT */ - YYSYMBOL_QUEUEFAMILYCOHERENT = 473, /* QUEUEFAMILYCOHERENT */ - YYSYMBOL_WORKGROUPCOHERENT = 474, /* WORKGROUPCOHERENT */ - YYSYMBOL_SUBGROUPCOHERENT = 475, /* SUBGROUPCOHERENT */ - YYSYMBOL_NONPRIVATE = 476, /* NONPRIVATE */ - YYSYMBOL_SHADERCALLCOHERENT = 477, /* SHADERCALLCOHERENT */ - YYSYMBOL_NOPERSPECTIVE = 478, /* NOPERSPECTIVE */ - YYSYMBOL_EXPLICITINTERPAMD = 479, /* EXPLICITINTERPAMD */ - YYSYMBOL_PERVERTEXEXT = 480, /* PERVERTEXEXT */ - YYSYMBOL_PERVERTEXNV = 481, /* PERVERTEXNV */ - YYSYMBOL_PERPRIMITIVENV = 482, /* PERPRIMITIVENV */ - YYSYMBOL_PERVIEWNV = 483, /* PERVIEWNV */ - YYSYMBOL_PERTASKNV = 484, /* PERTASKNV */ - YYSYMBOL_PERPRIMITIVEEXT = 485, /* PERPRIMITIVEEXT */ - YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 486, /* TASKPAYLOADWORKGROUPEXT */ - YYSYMBOL_PRECISE = 487, /* PRECISE */ - YYSYMBOL_YYACCEPT = 488, /* $accept */ - YYSYMBOL_variable_identifier = 489, /* variable_identifier */ - YYSYMBOL_primary_expression = 490, /* primary_expression */ - YYSYMBOL_postfix_expression = 491, /* postfix_expression */ - YYSYMBOL_integer_expression = 492, /* integer_expression */ - YYSYMBOL_function_call = 493, /* function_call */ - YYSYMBOL_function_call_or_method = 494, /* function_call_or_method */ - YYSYMBOL_function_call_generic = 495, /* function_call_generic */ - YYSYMBOL_function_call_header_no_parameters = 496, /* function_call_header_no_parameters */ - YYSYMBOL_function_call_header_with_parameters = 497, /* function_call_header_with_parameters */ - YYSYMBOL_function_call_header = 498, /* function_call_header */ - YYSYMBOL_function_identifier = 499, /* function_identifier */ - YYSYMBOL_unary_expression = 500, /* unary_expression */ - YYSYMBOL_unary_operator = 501, /* unary_operator */ - YYSYMBOL_multiplicative_expression = 502, /* multiplicative_expression */ - YYSYMBOL_additive_expression = 503, /* additive_expression */ - YYSYMBOL_shift_expression = 504, /* shift_expression */ - YYSYMBOL_relational_expression = 505, /* relational_expression */ - YYSYMBOL_equality_expression = 506, /* equality_expression */ - YYSYMBOL_and_expression = 507, /* and_expression */ - YYSYMBOL_exclusive_or_expression = 508, /* exclusive_or_expression */ - YYSYMBOL_inclusive_or_expression = 509, /* inclusive_or_expression */ - YYSYMBOL_logical_and_expression = 510, /* logical_and_expression */ - YYSYMBOL_logical_xor_expression = 511, /* logical_xor_expression */ - YYSYMBOL_logical_or_expression = 512, /* logical_or_expression */ - YYSYMBOL_conditional_expression = 513, /* conditional_expression */ - YYSYMBOL_514_1 = 514, /* $@1 */ - YYSYMBOL_assignment_expression = 515, /* assignment_expression */ - YYSYMBOL_assignment_operator = 516, /* assignment_operator */ - YYSYMBOL_expression = 517, /* expression */ - YYSYMBOL_constant_expression = 518, /* constant_expression */ - YYSYMBOL_declaration = 519, /* declaration */ - YYSYMBOL_block_structure = 520, /* block_structure */ - YYSYMBOL_521_2 = 521, /* $@2 */ - YYSYMBOL_identifier_list = 522, /* identifier_list */ - YYSYMBOL_function_prototype = 523, /* function_prototype */ - YYSYMBOL_function_declarator = 524, /* function_declarator */ - YYSYMBOL_function_header_with_parameters = 525, /* function_header_with_parameters */ - YYSYMBOL_function_header = 526, /* function_header */ - YYSYMBOL_parameter_declarator = 527, /* parameter_declarator */ - YYSYMBOL_parameter_declaration = 528, /* parameter_declaration */ - YYSYMBOL_parameter_type_specifier = 529, /* parameter_type_specifier */ - YYSYMBOL_init_declarator_list = 530, /* init_declarator_list */ - YYSYMBOL_single_declaration = 531, /* single_declaration */ - YYSYMBOL_fully_specified_type = 532, /* fully_specified_type */ - YYSYMBOL_invariant_qualifier = 533, /* invariant_qualifier */ - YYSYMBOL_interpolation_qualifier = 534, /* interpolation_qualifier */ - YYSYMBOL_layout_qualifier = 535, /* layout_qualifier */ - YYSYMBOL_layout_qualifier_id_list = 536, /* layout_qualifier_id_list */ - YYSYMBOL_layout_qualifier_id = 537, /* layout_qualifier_id */ - YYSYMBOL_precise_qualifier = 538, /* precise_qualifier */ - YYSYMBOL_type_qualifier = 539, /* type_qualifier */ - YYSYMBOL_single_type_qualifier = 540, /* single_type_qualifier */ - YYSYMBOL_storage_qualifier = 541, /* storage_qualifier */ - YYSYMBOL_non_uniform_qualifier = 542, /* non_uniform_qualifier */ - YYSYMBOL_type_name_list = 543, /* type_name_list */ - YYSYMBOL_type_specifier = 544, /* type_specifier */ - YYSYMBOL_array_specifier = 545, /* array_specifier */ - YYSYMBOL_type_parameter_specifier_opt = 546, /* type_parameter_specifier_opt */ - YYSYMBOL_type_parameter_specifier = 547, /* type_parameter_specifier */ - YYSYMBOL_type_parameter_specifier_list = 548, /* type_parameter_specifier_list */ - YYSYMBOL_type_specifier_nonarray = 549, /* type_specifier_nonarray */ - YYSYMBOL_precision_qualifier = 550, /* precision_qualifier */ - YYSYMBOL_struct_specifier = 551, /* struct_specifier */ - YYSYMBOL_552_3 = 552, /* $@3 */ - YYSYMBOL_553_4 = 553, /* $@4 */ - YYSYMBOL_struct_declaration_list = 554, /* struct_declaration_list */ - YYSYMBOL_struct_declaration_with_heap = 555, /* struct_declaration_with_heap */ - YYSYMBOL_block_heap_inner_structure = 556, /* block_heap_inner_structure */ - YYSYMBOL_557_5 = 557, /* $@5 */ - YYSYMBOL_struct_declaration_without_heap = 558, /* struct_declaration_without_heap */ - YYSYMBOL_struct_declaration = 559, /* struct_declaration */ - YYSYMBOL_struct_declarator_list = 560, /* struct_declarator_list */ - YYSYMBOL_struct_declarator = 561, /* struct_declarator */ - YYSYMBOL_initializer = 562, /* initializer */ - YYSYMBOL_initializer_list = 563, /* initializer_list */ - YYSYMBOL_declaration_statement = 564, /* declaration_statement */ - YYSYMBOL_statement = 565, /* statement */ - YYSYMBOL_simple_statement = 566, /* simple_statement */ - YYSYMBOL_demote_statement = 567, /* demote_statement */ - YYSYMBOL_compound_statement = 568, /* compound_statement */ - YYSYMBOL_569_6 = 569, /* $@6 */ - YYSYMBOL_570_7 = 570, /* $@7 */ - YYSYMBOL_statement_no_new_scope = 571, /* statement_no_new_scope */ - YYSYMBOL_statement_scoped = 572, /* statement_scoped */ - YYSYMBOL_573_8 = 573, /* $@8 */ - YYSYMBOL_574_9 = 574, /* $@9 */ - YYSYMBOL_compound_statement_no_new_scope = 575, /* compound_statement_no_new_scope */ - YYSYMBOL_statement_list = 576, /* statement_list */ - YYSYMBOL_expression_statement = 577, /* expression_statement */ - YYSYMBOL_selection_statement = 578, /* selection_statement */ - YYSYMBOL_selection_statement_nonattributed = 579, /* selection_statement_nonattributed */ - YYSYMBOL_selection_rest_statement = 580, /* selection_rest_statement */ - YYSYMBOL_condition = 581, /* condition */ - YYSYMBOL_switch_statement = 582, /* switch_statement */ - YYSYMBOL_switch_statement_nonattributed = 583, /* switch_statement_nonattributed */ - YYSYMBOL_584_10 = 584, /* $@10 */ - YYSYMBOL_switch_statement_list = 585, /* switch_statement_list */ - YYSYMBOL_case_label = 586, /* case_label */ - YYSYMBOL_iteration_statement = 587, /* iteration_statement */ - YYSYMBOL_iteration_statement_nonattributed = 588, /* iteration_statement_nonattributed */ - YYSYMBOL_589_11 = 589, /* $@11 */ - YYSYMBOL_590_12 = 590, /* $@12 */ - YYSYMBOL_591_13 = 591, /* $@13 */ - YYSYMBOL_for_init_statement = 592, /* for_init_statement */ - YYSYMBOL_conditionopt = 593, /* conditionopt */ - YYSYMBOL_for_rest_statement = 594, /* for_rest_statement */ - YYSYMBOL_jump_statement = 595, /* jump_statement */ - YYSYMBOL_translation_unit = 596, /* translation_unit */ - YYSYMBOL_external_declaration = 597, /* external_declaration */ - YYSYMBOL_function_definition = 598, /* function_definition */ - YYSYMBOL_599_14 = 599, /* $@14 */ - YYSYMBOL_attribute = 600, /* attribute */ - YYSYMBOL_attribute_list = 601, /* attribute_list */ - YYSYMBOL_single_attribute = 602, /* single_attribute */ - YYSYMBOL_spirv_requirements_list = 603, /* spirv_requirements_list */ - YYSYMBOL_spirv_requirements_parameter = 604, /* spirv_requirements_parameter */ - YYSYMBOL_spirv_extension_list = 605, /* spirv_extension_list */ - YYSYMBOL_spirv_capability_list = 606, /* spirv_capability_list */ - YYSYMBOL_spirv_execution_mode_qualifier = 607, /* spirv_execution_mode_qualifier */ - YYSYMBOL_spirv_execution_mode_parameter_list = 608, /* spirv_execution_mode_parameter_list */ - YYSYMBOL_spirv_execution_mode_parameter = 609, /* spirv_execution_mode_parameter */ - YYSYMBOL_spirv_execution_mode_id_parameter_list = 610, /* spirv_execution_mode_id_parameter_list */ - YYSYMBOL_spirv_storage_class_qualifier = 611, /* spirv_storage_class_qualifier */ - YYSYMBOL_spirv_decorate_qualifier = 612, /* spirv_decorate_qualifier */ - YYSYMBOL_spirv_decorate_parameter_list = 613, /* spirv_decorate_parameter_list */ - YYSYMBOL_spirv_decorate_parameter = 614, /* spirv_decorate_parameter */ - YYSYMBOL_spirv_decorate_id_parameter_list = 615, /* spirv_decorate_id_parameter_list */ - YYSYMBOL_spirv_decorate_id_parameter = 616, /* spirv_decorate_id_parameter */ - YYSYMBOL_spirv_decorate_string_parameter_list = 617, /* spirv_decorate_string_parameter_list */ - YYSYMBOL_spirv_type_specifier = 618, /* spirv_type_specifier */ - YYSYMBOL_spirv_type_parameter_list = 619, /* spirv_type_parameter_list */ - YYSYMBOL_spirv_type_parameter = 620, /* spirv_type_parameter */ - YYSYMBOL_spirv_instruction_qualifier = 621, /* spirv_instruction_qualifier */ - YYSYMBOL_spirv_instruction_qualifier_list = 622, /* spirv_instruction_qualifier_list */ - YYSYMBOL_spirv_instruction_qualifier_id = 623 /* spirv_instruction_qualifier_id */ + YYSYMBOL_SPIRV_STRING = 349, /* SPIRV_STRING */ + YYSYMBOL_ATTACHMENTEXT = 350, /* ATTACHMENTEXT */ + YYSYMBOL_IATTACHMENTEXT = 351, /* IATTACHMENTEXT */ + YYSYMBOL_UATTACHMENTEXT = 352, /* UATTACHMENTEXT */ + YYSYMBOL_LEFT_OP = 353, /* LEFT_OP */ + YYSYMBOL_RIGHT_OP = 354, /* RIGHT_OP */ + YYSYMBOL_INC_OP = 355, /* INC_OP */ + YYSYMBOL_DEC_OP = 356, /* DEC_OP */ + YYSYMBOL_LE_OP = 357, /* LE_OP */ + YYSYMBOL_GE_OP = 358, /* GE_OP */ + YYSYMBOL_EQ_OP = 359, /* EQ_OP */ + YYSYMBOL_NE_OP = 360, /* NE_OP */ + YYSYMBOL_AND_OP = 361, /* AND_OP */ + YYSYMBOL_OR_OP = 362, /* OR_OP */ + YYSYMBOL_XOR_OP = 363, /* XOR_OP */ + YYSYMBOL_MUL_ASSIGN = 364, /* MUL_ASSIGN */ + YYSYMBOL_DIV_ASSIGN = 365, /* DIV_ASSIGN */ + YYSYMBOL_ADD_ASSIGN = 366, /* ADD_ASSIGN */ + YYSYMBOL_MOD_ASSIGN = 367, /* MOD_ASSIGN */ + YYSYMBOL_LEFT_ASSIGN = 368, /* LEFT_ASSIGN */ + YYSYMBOL_RIGHT_ASSIGN = 369, /* RIGHT_ASSIGN */ + YYSYMBOL_AND_ASSIGN = 370, /* AND_ASSIGN */ + YYSYMBOL_XOR_ASSIGN = 371, /* XOR_ASSIGN */ + YYSYMBOL_OR_ASSIGN = 372, /* OR_ASSIGN */ + YYSYMBOL_SUB_ASSIGN = 373, /* SUB_ASSIGN */ + YYSYMBOL_STRING_LITERAL = 374, /* STRING_LITERAL */ + YYSYMBOL_LEFT_PAREN = 375, /* LEFT_PAREN */ + YYSYMBOL_RIGHT_PAREN = 376, /* RIGHT_PAREN */ + YYSYMBOL_LEFT_BRACKET = 377, /* LEFT_BRACKET */ + YYSYMBOL_RIGHT_BRACKET = 378, /* RIGHT_BRACKET */ + YYSYMBOL_LEFT_BRACE = 379, /* LEFT_BRACE */ + YYSYMBOL_RIGHT_BRACE = 380, /* RIGHT_BRACE */ + YYSYMBOL_DOT = 381, /* DOT */ + YYSYMBOL_ELLIPSIS = 382, /* ELLIPSIS */ + YYSYMBOL_COMMA = 383, /* COMMA */ + YYSYMBOL_COLON = 384, /* COLON */ + YYSYMBOL_EQUAL = 385, /* EQUAL */ + YYSYMBOL_SEMICOLON = 386, /* SEMICOLON */ + YYSYMBOL_BANG = 387, /* BANG */ + YYSYMBOL_DASH = 388, /* DASH */ + YYSYMBOL_TILDE = 389, /* TILDE */ + YYSYMBOL_PLUS = 390, /* PLUS */ + YYSYMBOL_STAR = 391, /* STAR */ + YYSYMBOL_SLASH = 392, /* SLASH */ + YYSYMBOL_PERCENT = 393, /* PERCENT */ + YYSYMBOL_LEFT_ANGLE = 394, /* LEFT_ANGLE */ + YYSYMBOL_RIGHT_ANGLE = 395, /* RIGHT_ANGLE */ + YYSYMBOL_VERTICAL_BAR = 396, /* VERTICAL_BAR */ + YYSYMBOL_CARET = 397, /* CARET */ + YYSYMBOL_AMPERSAND = 398, /* AMPERSAND */ + YYSYMBOL_QUESTION = 399, /* QUESTION */ + YYSYMBOL_INVARIANT = 400, /* INVARIANT */ + YYSYMBOL_HIGH_PRECISION = 401, /* HIGH_PRECISION */ + YYSYMBOL_MEDIUM_PRECISION = 402, /* MEDIUM_PRECISION */ + YYSYMBOL_LOW_PRECISION = 403, /* LOW_PRECISION */ + YYSYMBOL_PRECISION = 404, /* PRECISION */ + YYSYMBOL_PACKED = 405, /* PACKED */ + YYSYMBOL_RESOURCE = 406, /* RESOURCE */ + YYSYMBOL_SUPERP = 407, /* SUPERP */ + YYSYMBOL_FLOATCONSTANT = 408, /* FLOATCONSTANT */ + YYSYMBOL_INTCONSTANT = 409, /* INTCONSTANT */ + YYSYMBOL_UINTCONSTANT = 410, /* UINTCONSTANT */ + YYSYMBOL_BOOLCONSTANT = 411, /* BOOLCONSTANT */ + YYSYMBOL_IDENTIFIER = 412, /* IDENTIFIER */ + YYSYMBOL_TYPE_NAME = 413, /* TYPE_NAME */ + YYSYMBOL_CENTROID = 414, /* CENTROID */ + YYSYMBOL_IN = 415, /* IN */ + YYSYMBOL_OUT = 416, /* OUT */ + YYSYMBOL_INOUT = 417, /* INOUT */ + YYSYMBOL_STRUCT = 418, /* STRUCT */ + YYSYMBOL_VOID = 419, /* VOID */ + YYSYMBOL_WHILE = 420, /* WHILE */ + YYSYMBOL_BREAK = 421, /* BREAK */ + YYSYMBOL_CONTINUE = 422, /* CONTINUE */ + YYSYMBOL_DO = 423, /* DO */ + YYSYMBOL_ELSE = 424, /* ELSE */ + YYSYMBOL_FOR = 425, /* FOR */ + YYSYMBOL_IF = 426, /* IF */ + YYSYMBOL_DISCARD = 427, /* DISCARD */ + YYSYMBOL_RETURN = 428, /* RETURN */ + YYSYMBOL_SWITCH = 429, /* SWITCH */ + YYSYMBOL_CASE = 430, /* CASE */ + YYSYMBOL_DEFAULT = 431, /* DEFAULT */ + YYSYMBOL_TERMINATE_INVOCATION = 432, /* TERMINATE_INVOCATION */ + YYSYMBOL_TERMINATE_RAY = 433, /* TERMINATE_RAY */ + YYSYMBOL_IGNORE_INTERSECTION = 434, /* IGNORE_INTERSECTION */ + YYSYMBOL_UNIFORM = 435, /* UNIFORM */ + YYSYMBOL_SHARED = 436, /* SHARED */ + YYSYMBOL_BUFFER = 437, /* BUFFER */ + YYSYMBOL_TILEIMAGEEXT = 438, /* TILEIMAGEEXT */ + YYSYMBOL_FLAT = 439, /* FLAT */ + YYSYMBOL_SMOOTH = 440, /* SMOOTH */ + YYSYMBOL_LAYOUT = 441, /* LAYOUT */ + YYSYMBOL_DOUBLECONSTANT = 442, /* DOUBLECONSTANT */ + YYSYMBOL_INT16CONSTANT = 443, /* INT16CONSTANT */ + YYSYMBOL_UINT16CONSTANT = 444, /* UINT16CONSTANT */ + YYSYMBOL_FLOAT16CONSTANT = 445, /* FLOAT16CONSTANT */ + YYSYMBOL_INT32CONSTANT = 446, /* INT32CONSTANT */ + YYSYMBOL_UINT32CONSTANT = 447, /* UINT32CONSTANT */ + YYSYMBOL_INT64CONSTANT = 448, /* INT64CONSTANT */ + YYSYMBOL_UINT64CONSTANT = 449, /* UINT64CONSTANT */ + YYSYMBOL_SUBROUTINE = 450, /* SUBROUTINE */ + YYSYMBOL_DEMOTE = 451, /* DEMOTE */ + YYSYMBOL_FUNCTION = 452, /* FUNCTION */ + YYSYMBOL_PAYLOADNV = 453, /* PAYLOADNV */ + YYSYMBOL_PAYLOADINNV = 454, /* PAYLOADINNV */ + YYSYMBOL_HITATTRNV = 455, /* HITATTRNV */ + YYSYMBOL_CALLDATANV = 456, /* CALLDATANV */ + YYSYMBOL_CALLDATAINNV = 457, /* CALLDATAINNV */ + YYSYMBOL_PAYLOADEXT = 458, /* PAYLOADEXT */ + YYSYMBOL_PAYLOADINEXT = 459, /* PAYLOADINEXT */ + YYSYMBOL_HITATTREXT = 460, /* HITATTREXT */ + YYSYMBOL_CALLDATAEXT = 461, /* CALLDATAEXT */ + YYSYMBOL_CALLDATAINEXT = 462, /* CALLDATAINEXT */ + YYSYMBOL_PATCH = 463, /* PATCH */ + YYSYMBOL_SAMPLE = 464, /* SAMPLE */ + YYSYMBOL_NONUNIFORM = 465, /* NONUNIFORM */ + YYSYMBOL_RESOURCEHEAP = 466, /* RESOURCEHEAP */ + YYSYMBOL_SAMPLERHEAP = 467, /* SAMPLERHEAP */ + YYSYMBOL_COHERENT = 468, /* COHERENT */ + YYSYMBOL_VOLATILE = 469, /* VOLATILE */ + YYSYMBOL_RESTRICT = 470, /* RESTRICT */ + YYSYMBOL_READONLY = 471, /* READONLY */ + YYSYMBOL_WRITEONLY = 472, /* WRITEONLY */ + YYSYMBOL_NONTEMPORAL = 473, /* NONTEMPORAL */ + YYSYMBOL_DEVICECOHERENT = 474, /* DEVICECOHERENT */ + YYSYMBOL_QUEUEFAMILYCOHERENT = 475, /* QUEUEFAMILYCOHERENT */ + YYSYMBOL_WORKGROUPCOHERENT = 476, /* WORKGROUPCOHERENT */ + YYSYMBOL_SUBGROUPCOHERENT = 477, /* SUBGROUPCOHERENT */ + YYSYMBOL_NONPRIVATE = 478, /* NONPRIVATE */ + YYSYMBOL_SHADERCALLCOHERENT = 479, /* SHADERCALLCOHERENT */ + YYSYMBOL_NOPERSPECTIVE = 480, /* NOPERSPECTIVE */ + YYSYMBOL_EXPLICITINTERPAMD = 481, /* EXPLICITINTERPAMD */ + YYSYMBOL_PERVERTEXEXT = 482, /* PERVERTEXEXT */ + YYSYMBOL_PERVERTEXNV = 483, /* PERVERTEXNV */ + YYSYMBOL_PERPRIMITIVENV = 484, /* PERPRIMITIVENV */ + YYSYMBOL_PERVIEWNV = 485, /* PERVIEWNV */ + YYSYMBOL_PERTASKNV = 486, /* PERTASKNV */ + YYSYMBOL_PERPRIMITIVEEXT = 487, /* PERPRIMITIVEEXT */ + YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 488, /* TASKPAYLOADWORKGROUPEXT */ + YYSYMBOL_PRECISE = 489, /* PRECISE */ + YYSYMBOL_YYACCEPT = 490, /* $accept */ + YYSYMBOL_variable_identifier = 491, /* variable_identifier */ + YYSYMBOL_primary_expression = 492, /* primary_expression */ + YYSYMBOL_postfix_expression = 493, /* postfix_expression */ + YYSYMBOL_integer_expression = 494, /* integer_expression */ + YYSYMBOL_function_call = 495, /* function_call */ + YYSYMBOL_function_call_or_method = 496, /* function_call_or_method */ + YYSYMBOL_function_call_generic = 497, /* function_call_generic */ + YYSYMBOL_function_call_header_no_parameters = 498, /* function_call_header_no_parameters */ + YYSYMBOL_function_call_header_with_parameters = 499, /* function_call_header_with_parameters */ + YYSYMBOL_function_call_header = 500, /* function_call_header */ + YYSYMBOL_function_identifier = 501, /* function_identifier */ + YYSYMBOL_unary_expression = 502, /* unary_expression */ + YYSYMBOL_unary_operator = 503, /* unary_operator */ + YYSYMBOL_multiplicative_expression = 504, /* multiplicative_expression */ + YYSYMBOL_additive_expression = 505, /* additive_expression */ + YYSYMBOL_shift_expression = 506, /* shift_expression */ + YYSYMBOL_relational_expression = 507, /* relational_expression */ + YYSYMBOL_equality_expression = 508, /* equality_expression */ + YYSYMBOL_and_expression = 509, /* and_expression */ + YYSYMBOL_exclusive_or_expression = 510, /* exclusive_or_expression */ + YYSYMBOL_inclusive_or_expression = 511, /* inclusive_or_expression */ + YYSYMBOL_logical_and_expression = 512, /* logical_and_expression */ + YYSYMBOL_logical_xor_expression = 513, /* logical_xor_expression */ + YYSYMBOL_logical_or_expression = 514, /* logical_or_expression */ + YYSYMBOL_conditional_expression = 515, /* conditional_expression */ + YYSYMBOL_516_1 = 516, /* $@1 */ + YYSYMBOL_assignment_expression = 517, /* assignment_expression */ + YYSYMBOL_assignment_operator = 518, /* assignment_operator */ + YYSYMBOL_expression = 519, /* expression */ + YYSYMBOL_constant_expression = 520, /* constant_expression */ + YYSYMBOL_declaration = 521, /* declaration */ + YYSYMBOL_block_structure = 522, /* block_structure */ + YYSYMBOL_523_2 = 523, /* $@2 */ + YYSYMBOL_identifier_list = 524, /* identifier_list */ + YYSYMBOL_function_prototype = 525, /* function_prototype */ + YYSYMBOL_function_prototype_with_spirv_variadic_tail = 526, /* function_prototype_with_spirv_variadic_tail */ + YYSYMBOL_function_declarator = 527, /* function_declarator */ + YYSYMBOL_function_header_with_parameters = 528, /* function_header_with_parameters */ + YYSYMBOL_function_header = 529, /* function_header */ + YYSYMBOL_parameter_declarator = 530, /* parameter_declarator */ + YYSYMBOL_parameter_declaration = 531, /* parameter_declaration */ + YYSYMBOL_parameter_type_specifier = 532, /* parameter_type_specifier */ + YYSYMBOL_init_declarator_list = 533, /* init_declarator_list */ + YYSYMBOL_single_declaration = 534, /* single_declaration */ + YYSYMBOL_fully_specified_type = 535, /* fully_specified_type */ + YYSYMBOL_invariant_qualifier = 536, /* invariant_qualifier */ + YYSYMBOL_interpolation_qualifier = 537, /* interpolation_qualifier */ + YYSYMBOL_layout_qualifier = 538, /* layout_qualifier */ + YYSYMBOL_layout_qualifier_id_list = 539, /* layout_qualifier_id_list */ + YYSYMBOL_layout_qualifier_id = 540, /* layout_qualifier_id */ + YYSYMBOL_precise_qualifier = 541, /* precise_qualifier */ + YYSYMBOL_type_qualifier = 542, /* type_qualifier */ + YYSYMBOL_single_type_qualifier = 543, /* single_type_qualifier */ + YYSYMBOL_storage_qualifier = 544, /* storage_qualifier */ + YYSYMBOL_non_uniform_qualifier = 545, /* non_uniform_qualifier */ + YYSYMBOL_type_name_list = 546, /* type_name_list */ + YYSYMBOL_type_specifier = 547, /* type_specifier */ + YYSYMBOL_array_specifier = 548, /* array_specifier */ + YYSYMBOL_type_parameter_specifier_opt = 549, /* type_parameter_specifier_opt */ + YYSYMBOL_type_parameter_specifier = 550, /* type_parameter_specifier */ + YYSYMBOL_type_parameter_specifier_list = 551, /* type_parameter_specifier_list */ + YYSYMBOL_type_specifier_nonarray = 552, /* type_specifier_nonarray */ + YYSYMBOL_precision_qualifier = 553, /* precision_qualifier */ + YYSYMBOL_struct_specifier = 554, /* struct_specifier */ + YYSYMBOL_555_3 = 555, /* $@3 */ + YYSYMBOL_556_4 = 556, /* $@4 */ + YYSYMBOL_struct_declaration_list = 557, /* struct_declaration_list */ + YYSYMBOL_struct_declaration_with_heap = 558, /* struct_declaration_with_heap */ + YYSYMBOL_block_heap_inner_structure = 559, /* block_heap_inner_structure */ + YYSYMBOL_560_5 = 560, /* $@5 */ + YYSYMBOL_struct_declaration_without_heap = 561, /* struct_declaration_without_heap */ + YYSYMBOL_struct_declaration = 562, /* struct_declaration */ + YYSYMBOL_struct_declarator_list = 563, /* struct_declarator_list */ + YYSYMBOL_struct_declarator = 564, /* struct_declarator */ + YYSYMBOL_initializer = 565, /* initializer */ + YYSYMBOL_initializer_list = 566, /* initializer_list */ + YYSYMBOL_declaration_statement = 567, /* declaration_statement */ + YYSYMBOL_statement = 568, /* statement */ + YYSYMBOL_simple_statement = 569, /* simple_statement */ + YYSYMBOL_demote_statement = 570, /* demote_statement */ + YYSYMBOL_compound_statement = 571, /* compound_statement */ + YYSYMBOL_572_6 = 572, /* $@6 */ + YYSYMBOL_573_7 = 573, /* $@7 */ + YYSYMBOL_statement_no_new_scope = 574, /* statement_no_new_scope */ + YYSYMBOL_statement_scoped = 575, /* statement_scoped */ + YYSYMBOL_576_8 = 576, /* $@8 */ + YYSYMBOL_577_9 = 577, /* $@9 */ + YYSYMBOL_compound_statement_no_new_scope = 578, /* compound_statement_no_new_scope */ + YYSYMBOL_statement_list = 579, /* statement_list */ + YYSYMBOL_expression_statement = 580, /* expression_statement */ + YYSYMBOL_selection_statement = 581, /* selection_statement */ + YYSYMBOL_selection_statement_nonattributed = 582, /* selection_statement_nonattributed */ + YYSYMBOL_selection_rest_statement = 583, /* selection_rest_statement */ + YYSYMBOL_condition = 584, /* condition */ + YYSYMBOL_switch_statement = 585, /* switch_statement */ + YYSYMBOL_switch_statement_nonattributed = 586, /* switch_statement_nonattributed */ + YYSYMBOL_587_10 = 587, /* $@10 */ + YYSYMBOL_switch_statement_list = 588, /* switch_statement_list */ + YYSYMBOL_case_label = 589, /* case_label */ + YYSYMBOL_iteration_statement = 590, /* iteration_statement */ + YYSYMBOL_iteration_statement_nonattributed = 591, /* iteration_statement_nonattributed */ + YYSYMBOL_592_11 = 592, /* $@11 */ + YYSYMBOL_593_12 = 593, /* $@12 */ + YYSYMBOL_594_13 = 594, /* $@13 */ + YYSYMBOL_for_init_statement = 595, /* for_init_statement */ + YYSYMBOL_conditionopt = 596, /* conditionopt */ + YYSYMBOL_for_rest_statement = 597, /* for_rest_statement */ + YYSYMBOL_jump_statement = 598, /* jump_statement */ + YYSYMBOL_translation_unit = 599, /* translation_unit */ + YYSYMBOL_external_declaration = 600, /* external_declaration */ + YYSYMBOL_function_definition = 601, /* function_definition */ + YYSYMBOL_602_14 = 602, /* $@14 */ + YYSYMBOL_attribute = 603, /* attribute */ + YYSYMBOL_attribute_list = 604, /* attribute_list */ + YYSYMBOL_single_attribute = 605, /* single_attribute */ + YYSYMBOL_spirv_requirements_list = 606, /* spirv_requirements_list */ + YYSYMBOL_spirv_requirements_parameter = 607, /* spirv_requirements_parameter */ + YYSYMBOL_spirv_extension_list = 608, /* spirv_extension_list */ + YYSYMBOL_spirv_capability_list = 609, /* spirv_capability_list */ + YYSYMBOL_spirv_execution_mode_qualifier = 610, /* spirv_execution_mode_qualifier */ + YYSYMBOL_spirv_execution_mode_parameter_list = 611, /* spirv_execution_mode_parameter_list */ + YYSYMBOL_spirv_execution_mode_parameter = 612, /* spirv_execution_mode_parameter */ + YYSYMBOL_spirv_execution_mode_id_parameter_list = 613, /* spirv_execution_mode_id_parameter_list */ + YYSYMBOL_spirv_storage_class_qualifier = 614, /* spirv_storage_class_qualifier */ + YYSYMBOL_spirv_decorate_qualifier = 615, /* spirv_decorate_qualifier */ + YYSYMBOL_spirv_decorate_parameter_list = 616, /* spirv_decorate_parameter_list */ + YYSYMBOL_spirv_decorate_parameter = 617, /* spirv_decorate_parameter */ + YYSYMBOL_spirv_decorate_id_parameter_list = 618, /* spirv_decorate_id_parameter_list */ + YYSYMBOL_spirv_decorate_id_parameter = 619, /* spirv_decorate_id_parameter */ + YYSYMBOL_spirv_decorate_string_parameter_list = 620, /* spirv_decorate_string_parameter_list */ + YYSYMBOL_spirv_type_specifier = 621, /* spirv_type_specifier */ + YYSYMBOL_spirv_type_parameter_list = 622, /* spirv_type_parameter_list */ + YYSYMBOL_spirv_type_parameter = 623, /* spirv_type_parameter */ + YYSYMBOL_spirv_instruction_qualifier = 624, /* spirv_instruction_qualifier */ + YYSYMBOL_spirv_instruction_qualifier_list = 625, /* spirv_instruction_qualifier_list */ + YYSYMBOL_spirv_instruction_qualifier_id = 626 /* spirv_instruction_qualifier_id */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -759,7 +762,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; extern int yylex(YYSTYPE*, TParseContext&); -#line 763 "MachineIndependent/glslang_tab.cpp" +#line 766 "MachineIndependent/glslang_tab.cpp" #ifdef short @@ -1081,21 +1084,21 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 476 +#define YYFINAL 478 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 13823 +#define YYLAST 15360 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 488 +#define YYNTOKENS 490 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 136 +#define YYNNTS 137 /* YYNRULES -- Number of rules. */ -#define YYNRULES 732 +#define YYNRULES 739 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 986 +#define YYNSTATES 1008 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 742 +#define YYMAXUTOK 744 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -1183,87 +1186,87 @@ static const yytype_int16 yytranslate[] = 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487 + 485, 486, 487, 488, 489 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 365, 365, 371, 374, 379, 382, 385, 389, 392, - 395, 399, 403, 407, 411, 415, 419, 425, 432, 435, - 438, 441, 444, 449, 457, 464, 471, 477, 481, 488, - 491, 497, 515, 540, 548, 553, 580, 588, 594, 598, - 602, 618, 625, 626, 627, 628, 634, 635, 640, 645, - 654, 655, 660, 668, 669, 675, 684, 685, 690, 695, - 700, 708, 709, 718, 730, 731, 740, 741, 750, 751, - 760, 761, 769, 770, 778, 779, 787, 788, 788, 806, - 807, 823, 827, 831, 835, 840, 844, 848, 852, 856, - 860, 864, 871, 874, 885, 892, 897, 904, 909, 914, - 921, 924, 927, 930, 935, 943, 943, 955, 959, 966, - 971, 979, 987, 999, 1002, 1009, 1022, 1042, 1049, 1072, - 1087, 1106, 1117, 1128, 1138, 1148, 1158, 1167, 1170, 1175, - 1180, 1185, 1193, 1198, 1204, 1209, 1214, 1223, 1233, 1260, - 1269, 1276, 1283, 1290, 1297, 1305, 1313, 1323, 1333, 1340, - 1350, 1356, 1359, 1366, 1370, 1374, 1382, 1391, 1394, 1405, - 1408, 1411, 1415, 1419, 1423, 1427, 1430, 1435, 1439, 1444, - 1452, 1456, 1461, 1467, 1473, 1480, 1485, 1490, 1498, 1503, - 1515, 1529, 1535, 1540, 1545, 1550, 1558, 1566, 1574, 1582, - 1590, 1598, 1606, 1614, 1622, 1630, 1637, 1644, 1648, 1653, - 1658, 1663, 1668, 1673, 1678, 1682, 1686, 1690, 1694, 1698, - 1704, 1710, 1720, 1727, 1730, 1738, 1745, 1756, 1761, 1769, - 1773, 1783, 1786, 1792, 1798, 1804, 1812, 1822, 1826, 1830, - 1834, 1839, 1843, 1848, 1853, 1858, 1863, 1868, 1873, 1878, - 1883, 1888, 1894, 1900, 1906, 1911, 1916, 1921, 1926, 1931, - 1936, 1941, 1946, 1951, 1956, 1961, 1966, 1973, 1978, 1983, - 1988, 1993, 1998, 2003, 2008, 2013, 2018, 2023, 2028, 2033, - 2038, 2043, 2051, 2059, 2067, 2073, 2079, 2085, 2091, 2097, - 2103, 2109, 2115, 2121, 2127, 2133, 2139, 2145, 2151, 2157, - 2163, 2169, 2175, 2181, 2187, 2193, 2199, 2205, 2211, 2217, - 2223, 2229, 2235, 2241, 2247, 2253, 2259, 2265, 2271, 2277, - 2283, 2289, 2295, 2301, 2307, 2313, 2319, 2327, 2335, 2343, - 2351, 2359, 2367, 2375, 2383, 2391, 2399, 2407, 2415, 2421, - 2427, 2433, 2439, 2445, 2451, 2457, 2463, 2469, 2475, 2481, - 2487, 2493, 2499, 2505, 2511, 2517, 2523, 2529, 2535, 2541, - 2547, 2553, 2559, 2565, 2571, 2577, 2583, 2589, 2595, 2601, - 2607, 2613, 2619, 2625, 2631, 2635, 2639, 2643, 2648, 2653, - 2658, 2663, 2668, 2673, 2678, 2683, 2688, 2693, 2698, 2703, - 2708, 2713, 2719, 2725, 2731, 2737, 2743, 2749, 2755, 2761, - 2767, 2773, 2779, 2785, 2791, 2796, 2801, 2806, 2811, 2816, - 2821, 2826, 2831, 2836, 2841, 2846, 2851, 2856, 2861, 2866, - 2871, 2876, 2881, 2886, 2891, 2896, 2901, 2906, 2911, 2916, - 2921, 2926, 2931, 2936, 2941, 2946, 2951, 2956, 2962, 2968, - 2973, 2978, 2983, 2989, 2994, 2999, 3004, 3010, 3015, 3020, - 3025, 3031, 3036, 3041, 3046, 3052, 3058, 3064, 3070, 3075, - 3081, 3087, 3093, 3098, 3103, 3108, 3113, 3118, 3124, 3129, - 3134, 3139, 3145, 3150, 3155, 3160, 3166, 3171, 3176, 3181, - 3187, 3192, 3197, 3202, 3208, 3213, 3218, 3223, 3229, 3234, - 3239, 3244, 3250, 3255, 3260, 3265, 3271, 3276, 3281, 3286, - 3292, 3297, 3302, 3307, 3313, 3318, 3323, 3328, 3334, 3339, - 3344, 3349, 3355, 3360, 3365, 3370, 3376, 3381, 3386, 3391, - 3397, 3402, 3407, 3412, 3418, 3423, 3428, 3433, 3438, 3443, - 3448, 3453, 3458, 3463, 3468, 3473, 3478, 3483, 3488, 3493, - 3498, 3503, 3508, 3513, 3518, 3523, 3528, 3533, 3538, 3544, - 3550, 3556, 3562, 3568, 3574, 3580, 3587, 3594, 3600, 3606, - 3612, 3618, 3625, 3632, 3639, 3646, 3651, 3656, 3660, 3666, - 3672, 3678, 3682, 3686, 3690, 3695, 3711, 3716, 3721, 3729, - 3729, 3745, 3745, 3755, 3758, 3761, 3771, 3784, 3801, 3801, - 3816, 3819, 3832, 3854, 3881, 3885, 3891, 3896, 3907, 3910, - 3916, 3922, 3931, 3934, 3940, 3944, 3945, 3951, 3952, 3953, - 3954, 3955, 3956, 3957, 3958, 3962, 3970, 3971, 3975, 3971, - 3989, 3990, 3994, 3994, 4001, 4001, 4015, 4018, 4028, 4036, - 4047, 4048, 4052, 4055, 4062, 4069, 4073, 4081, 4085, 4094, - 4097, 4104, 4104, 4124, 4127, 4133, 4145, 4157, 4160, 4168, - 4168, 4187, 4187, 4209, 4209, 4230, 4233, 4239, 4242, 4248, - 4252, 4259, 4264, 4269, 4276, 4279, 4283, 4287, 4291, 4300, - 4304, 4313, 4316, 4319, 4327, 4327, 4369, 4374, 4377, 4382, - 4385, 4390, 4393, 4398, 4401, 4406, 4409, 4414, 4417, 4422, - 4426, 4431, 4435, 4440, 4444, 4451, 4454, 4459, 4462, 4465, - 4468, 4471, 4476, 4485, 4496, 4501, 4509, 4513, 4518, 4522, - 4527, 4531, 4536, 4540, 4547, 4550, 4555, 4558, 4561, 4564, - 4569, 4572, 4577, 4583, 4586, 4589, 4592, 4597, 4601, 4606, - 4610, 4615, 4619, 4626, 4629, 4634, 4637, 4642, 4645, 4651, - 4654, 4659, 4662 + 0, 366, 366, 372, 375, 380, 383, 386, 390, 393, + 396, 400, 404, 408, 412, 416, 420, 426, 433, 436, + 439, 442, 445, 450, 458, 465, 472, 478, 482, 489, + 492, 498, 516, 541, 549, 554, 581, 589, 595, 599, + 603, 619, 626, 627, 628, 629, 635, 636, 641, 646, + 655, 656, 661, 669, 670, 676, 685, 686, 691, 696, + 701, 709, 710, 719, 731, 732, 741, 742, 751, 752, + 761, 762, 770, 771, 779, 780, 788, 789, 789, 807, + 808, 824, 828, 832, 836, 841, 845, 849, 853, 857, + 861, 865, 872, 875, 886, 893, 898, 905, 912, 917, + 922, 929, 932, 935, 938, 943, 951, 951, 963, 967, + 974, 979, 987, 995, 1004, 1010, 1019, 1025, 1031, 1037, + 1046, 1049, 1056, 1069, 1092, 1115, 1130, 1149, 1160, 1171, + 1181, 1191, 1201, 1210, 1213, 1218, 1223, 1228, 1236, 1241, + 1247, 1252, 1257, 1266, 1276, 1303, 1312, 1319, 1326, 1333, + 1340, 1348, 1356, 1366, 1376, 1383, 1393, 1399, 1402, 1409, + 1413, 1417, 1425, 1434, 1437, 1448, 1451, 1454, 1458, 1462, + 1466, 1470, 1473, 1478, 1482, 1487, 1495, 1499, 1504, 1510, + 1516, 1523, 1528, 1533, 1541, 1546, 1558, 1572, 1578, 1583, + 1588, 1593, 1601, 1609, 1617, 1625, 1633, 1641, 1649, 1657, + 1665, 1673, 1680, 1687, 1691, 1696, 1701, 1706, 1711, 1716, + 1721, 1725, 1729, 1733, 1737, 1741, 1747, 1753, 1763, 1770, + 1773, 1781, 1788, 1799, 1804, 1812, 1816, 1826, 1829, 1835, + 1841, 1847, 1855, 1865, 1869, 1873, 1877, 1882, 1886, 1891, + 1896, 1901, 1906, 1911, 1916, 1921, 1926, 1931, 1937, 1943, + 1949, 1954, 1959, 1964, 1969, 1974, 1979, 1984, 1989, 1994, + 1999, 2004, 2009, 2016, 2021, 2026, 2031, 2036, 2041, 2046, + 2051, 2056, 2061, 2066, 2071, 2076, 2081, 2086, 2094, 2102, + 2110, 2116, 2122, 2128, 2134, 2140, 2146, 2152, 2158, 2164, + 2170, 2176, 2182, 2188, 2194, 2200, 2206, 2212, 2218, 2224, + 2230, 2236, 2242, 2248, 2254, 2260, 2266, 2272, 2278, 2284, + 2290, 2296, 2302, 2308, 2314, 2320, 2326, 2332, 2338, 2344, + 2350, 2356, 2362, 2370, 2378, 2386, 2394, 2402, 2410, 2418, + 2426, 2434, 2442, 2450, 2458, 2464, 2470, 2476, 2482, 2488, + 2494, 2500, 2506, 2512, 2518, 2524, 2530, 2536, 2542, 2548, + 2554, 2560, 2566, 2572, 2578, 2584, 2590, 2596, 2602, 2608, + 2614, 2620, 2626, 2632, 2638, 2644, 2650, 2656, 2662, 2668, + 2674, 2678, 2682, 2686, 2691, 2696, 2701, 2706, 2711, 2716, + 2721, 2726, 2731, 2736, 2741, 2746, 2751, 2756, 2762, 2768, + 2774, 2780, 2786, 2792, 2798, 2804, 2810, 2816, 2822, 2828, + 2834, 2839, 2844, 2849, 2854, 2859, 2864, 2869, 2874, 2879, + 2884, 2889, 2894, 2899, 2904, 2909, 2914, 2919, 2924, 2929, + 2934, 2939, 2944, 2949, 2954, 2959, 2964, 2969, 2974, 2979, + 2984, 2989, 2994, 2999, 3005, 3011, 3016, 3021, 3026, 3032, + 3037, 3042, 3047, 3053, 3058, 3063, 3068, 3074, 3079, 3084, + 3089, 3095, 3101, 3107, 3113, 3118, 3124, 3130, 3136, 3141, + 3146, 3151, 3156, 3161, 3167, 3172, 3177, 3182, 3188, 3193, + 3198, 3203, 3209, 3214, 3219, 3224, 3230, 3235, 3240, 3245, + 3251, 3256, 3261, 3266, 3272, 3277, 3282, 3287, 3293, 3298, + 3303, 3308, 3314, 3319, 3324, 3329, 3335, 3340, 3345, 3350, + 3356, 3361, 3366, 3371, 3377, 3382, 3387, 3392, 3398, 3403, + 3408, 3413, 3419, 3424, 3429, 3434, 3440, 3445, 3450, 3455, + 3461, 3466, 3471, 3476, 3481, 3486, 3491, 3496, 3501, 3506, + 3511, 3516, 3521, 3526, 3531, 3536, 3541, 3546, 3551, 3556, + 3561, 3566, 3571, 3576, 3581, 3587, 3593, 3599, 3605, 3611, + 3617, 3623, 3630, 3637, 3643, 3649, 3655, 3661, 3668, 3675, + 3682, 3689, 3694, 3699, 3703, 3709, 3715, 3721, 3725, 3730, + 3734, 3738, 3743, 3759, 3764, 3769, 3777, 3777, 3793, 3793, + 3803, 3806, 3809, 3819, 3832, 3849, 3849, 3864, 3867, 3880, + 3902, 3929, 3933, 3939, 3944, 3955, 3958, 3964, 3970, 3979, + 3982, 3988, 3992, 3993, 3999, 4000, 4001, 4002, 4003, 4004, + 4005, 4006, 4010, 4018, 4019, 4023, 4019, 4037, 4038, 4042, + 4042, 4049, 4049, 4063, 4066, 4076, 4084, 4095, 4096, 4100, + 4103, 4110, 4117, 4121, 4129, 4133, 4142, 4145, 4152, 4152, + 4172, 4175, 4181, 4193, 4205, 4208, 4216, 4216, 4235, 4235, + 4257, 4257, 4278, 4281, 4287, 4290, 4296, 4300, 4307, 4312, + 4317, 4324, 4327, 4331, 4335, 4339, 4348, 4352, 4361, 4364, + 4367, 4375, 4375, 4417, 4422, 4425, 4430, 4433, 4438, 4441, + 4446, 4449, 4454, 4457, 4462, 4465, 4470, 4474, 4479, 4483, + 4488, 4492, 4499, 4502, 4507, 4510, 4513, 4516, 4519, 4524, + 4533, 4544, 4549, 4557, 4561, 4566, 4570, 4575, 4579, 4584, + 4588, 4595, 4598, 4603, 4606, 4609, 4612, 4617, 4620, 4625, + 4631, 4634, 4637, 4640, 4645, 4649, 4654, 4658, 4663, 4667, + 4674, 4677, 4682, 4685, 4690, 4693, 4699, 4702, 4707, 4710 }; #endif @@ -1357,32 +1360,33 @@ static const char *const yytname[] = "F16SUBPASSINPUTMS", "SPIRV_INSTRUCTION", "SPIRV_EXECUTION_MODE", "SPIRV_EXECUTION_MODE_ID", "SPIRV_DECORATE", "SPIRV_DECORATE_ID", "SPIRV_DECORATE_STRING", "SPIRV_TYPE", "SPIRV_STORAGE_CLASS", - "SPIRV_BY_REFERENCE", "SPIRV_LITERAL", "ATTACHMENTEXT", "IATTACHMENTEXT", - "UATTACHMENTEXT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP", - "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN", - "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", - "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "STRING_LITERAL", - "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", - "LEFT_BRACE", "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", - "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", - "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", - "QUESTION", "INVARIANT", "HIGH_PRECISION", "MEDIUM_PRECISION", - "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", - "FLOATCONSTANT", "INTCONSTANT", "UINTCONSTANT", "BOOLCONSTANT", - "IDENTIFIER", "TYPE_NAME", "CENTROID", "IN", "OUT", "INOUT", "STRUCT", - "VOID", "WHILE", "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", - "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", "TERMINATE_INVOCATION", - "TERMINATE_RAY", "IGNORE_INTERSECTION", "UNIFORM", "SHARED", "BUFFER", - "TILEIMAGEEXT", "FLAT", "SMOOTH", "LAYOUT", "DOUBLECONSTANT", - "INT16CONSTANT", "UINT16CONSTANT", "FLOAT16CONSTANT", "INT32CONSTANT", - "UINT32CONSTANT", "INT64CONSTANT", "UINT64CONSTANT", "SUBROUTINE", - "DEMOTE", "FUNCTION", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", - "CALLDATANV", "CALLDATAINNV", "PAYLOADEXT", "PAYLOADINEXT", "HITATTREXT", - "CALLDATAEXT", "CALLDATAINEXT", "PATCH", "SAMPLE", "NONUNIFORM", - "RESOURCEHEAP", "SAMPLERHEAP", "COHERENT", "VOLATILE", "RESTRICT", - "READONLY", "WRITEONLY", "NONTEMPORAL", "DEVICECOHERENT", - "QUEUEFAMILYCOHERENT", "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", - "NONPRIVATE", "SHADERCALLCOHERENT", "NOPERSPECTIVE", "EXPLICITINTERPAMD", + "SPIRV_BY_REFERENCE", "SPIRV_LITERAL", "SPIRV_STRING", "ATTACHMENTEXT", + "IATTACHMENTEXT", "UATTACHMENTEXT", "LEFT_OP", "RIGHT_OP", "INC_OP", + "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", + "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", + "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", + "SUB_ASSIGN", "STRING_LITERAL", "LEFT_PAREN", "RIGHT_PAREN", + "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "DOT", + "ELLIPSIS", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG", "DASH", + "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE", "RIGHT_ANGLE", + "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION", "INVARIANT", + "HIGH_PRECISION", "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", + "PACKED", "RESOURCE", "SUPERP", "FLOATCONSTANT", "INTCONSTANT", + "UINTCONSTANT", "BOOLCONSTANT", "IDENTIFIER", "TYPE_NAME", "CENTROID", + "IN", "OUT", "INOUT", "STRUCT", "VOID", "WHILE", "BREAK", "CONTINUE", + "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", + "DEFAULT", "TERMINATE_INVOCATION", "TERMINATE_RAY", + "IGNORE_INTERSECTION", "UNIFORM", "SHARED", "BUFFER", "TILEIMAGEEXT", + "FLAT", "SMOOTH", "LAYOUT", "DOUBLECONSTANT", "INT16CONSTANT", + "UINT16CONSTANT", "FLOAT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", + "INT64CONSTANT", "UINT64CONSTANT", "SUBROUTINE", "DEMOTE", "FUNCTION", + "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", "CALLDATANV", "CALLDATAINNV", + "PAYLOADEXT", "PAYLOADINEXT", "HITATTREXT", "CALLDATAEXT", + "CALLDATAINEXT", "PATCH", "SAMPLE", "NONUNIFORM", "RESOURCEHEAP", + "SAMPLERHEAP", "COHERENT", "VOLATILE", "RESTRICT", "READONLY", + "WRITEONLY", "NONTEMPORAL", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT", + "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", + "SHADERCALLCOHERENT", "NOPERSPECTIVE", "EXPLICITINTERPAMD", "PERVERTEXEXT", "PERVERTEXNV", "PERPRIMITIVENV", "PERVIEWNV", "PERTASKNV", "PERPRIMITIVEEXT", "TASKPAYLOADWORKGROUPEXT", "PRECISE", "$accept", "variable_identifier", "primary_expression", @@ -1398,7 +1402,8 @@ static const char *const yytname[] = "logical_or_expression", "conditional_expression", "$@1", "assignment_expression", "assignment_operator", "expression", "constant_expression", "declaration", "block_structure", "$@2", - "identifier_list", "function_prototype", "function_declarator", + "identifier_list", "function_prototype", + "function_prototype_with_spirv_variadic_tail", "function_declarator", "function_header_with_parameters", "function_header", "parameter_declarator", "parameter_declaration", "parameter_type_specifier", "init_declarator_list", "single_declaration", @@ -1445,12 +1450,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-849) +#define YYPACT_NINF (-886) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-727) +#define YYTABLE_NINF (-734) #define yytable_value_is_error(Yyn) \ 0 @@ -1459,105 +1464,107 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 4869, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -289, -249, -213, - -142, -94, -76, -72, -44, -849, -849, -849, -849, -849, - -327, -849, -849, -849, -849, -849, -193, -849, -849, -849, - -849, -849, -352, -849, -849, -849, -849, -849, -849, -849, - -37, -30, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -345, -202, -139, -122, 8749, -310, -849, -117, -849, - -849, -849, -849, 5839, -849, -849, -849, -849, -127, -849, - -849, 989, -849, -849, 8749, -33, -849, -849, -849, 6324, - -63, -294, -244, -168, -150, -140, -63, -138, -51, 13373, - -849, -17, -378, -48, -849, -330, -849, -15, -12, 6809, - -849, -849, -849, 8749, -43, -40, -849, -282, -849, -13, - -144, -849, -849, 11993, -10, -849, -849, -849, -7, -39, - 8749, -849, -11, -14, -5, -849, -324, -849, -239, -9, - -4, -2, -1, -238, 1, 3, 4, 5, 8, 10, - -236, 12, 11, 14, -237, -849, -3, 8749, -849, 15, - -849, -224, -849, -849, -221, 10153, -849, -329, 1474, -849, - -849, 13, -849, -849, -849, -266, -261, -849, 10613, -257, - -849, -20, -849, 11993, 11993, -849, 11993, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, -849, -849, -268, -849, -849, -849, - 19, -217, 12453, 23, -849, 11993, -849, 25, -303, 24, - -12, 27, -849, -332, -63, -849, -8, -849, -325, 28, - -134, 11993, -133, -849, -145, -129, -162, -128, 30, -121, - -63, -849, 12913, -849, -115, 11993, 29, -51, -849, 7294, - 16, 26, 8749, 16, 8749, -849, 8749, 11993, -849, -378, - -849, 17, -849, -849, -41, -45, -254, -326, -109, 18, - 34, 31, 47, 49, -334, 32, -849, 11073, -849, 33, - -849, -849, 39, 35, 36, -849, 44, 48, 37, 11533, - 56, 11993, 54, 60, 62, 63, 67, -169, -849, -849, - -87, -849, -202, 78, 25, -849, -849, -849, -849, -849, - 1959, -849, -849, -849, -849, -849, -849, -849, -849, -849, - 5354, 74, 10613, 24, 10613, -255, 9233, -849, -849, 10613, - 8749, -849, -849, -849, -216, -323, -849, -849, 11993, 45, - -849, -849, 11993, 81, -849, -849, -849, 11993, -849, -849, - -849, -339, -849, -849, -205, 75, -849, -849, -849, -849, - -849, -849, -204, -849, -201, -849, -849, -200, 76, -849, - -849, -849, -849, -197, -849, -192, -849, -849, -849, -849, - -849, -190, -849, 80, -849, -188, 83, -171, 75, -849, - -322, -170, -849, 87, 90, -849, -849, -849, 16, -10, - -81, -849, -849, 8749, 8749, -53, -849, -849, 91, -849, - -849, -849, 11993, 11993, 11993, 11993, 11993, 11993, 11993, 11993, - 11993, 11993, 11993, 11993, 11993, 11993, 11993, 11993, 11993, 11993, - 11993, -849, -849, -849, 89, -849, 2444, -849, -849, -849, - 2444, -849, 11993, -849, -849, -52, 11993, -97, -849, -849, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -849, -849, 11993, 11993, -849, -849, -849, -849, - -849, -849, -849, -849, -849, 10613, -849, -849, -232, -849, - 7779, -849, 11993, 92, 93, -849, -849, -849, -849, -849, - -148, -146, -849, -331, -849, -325, -849, -325, -849, 11993, - 11993, -849, -145, -849, -145, -849, -162, -162, -849, 98, - 30, -849, 12913, -849, 11993, -849, -849, 8749, -42, 24, - 16, -849, -849, -849, -849, -849, -849, -41, -41, -45, - -45, -254, -254, -254, -254, -326, -326, -109, 18, 34, - 31, 47, 49, 11993, -849, 2444, 4384, 57, 3899, -166, - -849, -163, -849, -849, -849, -849, -849, 9693, -849, -849, - -849, -849, 103, -849, 70, -849, -159, -849, -158, -849, - -156, -849, -155, -849, -154, -151, -849, 8264, -849, -849, - -75, 99, 93, 69, 106, 109, -849, -849, 4384, 107, - -849, -849, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, 11993, -849, 101, 2929, 11993, -849, 102, 112, - 66, 113, 3414, -849, 114, -849, 10613, -849, -849, -849, - -147, 11993, 2929, 107, -849, -849, 2444, -849, 110, 93, - -849, -849, 2444, 111, -849, -849 + 4907, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -322, -316, -270, + -213, -203, -123, -113, -89, -886, -886, -886, -886, -886, + -886, -110, -886, -886, -886, -886, -886, -43, -886, -886, + -886, -886, -886, -324, -886, -886, -886, -886, -886, -886, + -886, -85, -60, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -339, -186, -178, -181, 6368, -243, -886, -184, + -886, -886, -886, -886, 5881, -886, -886, -886, -886, -168, + -886, -886, 1011, -886, -886, 10264, -111, -886, -886, -886, + 6855, -67, -264, -162, -161, -138, -128, -67, -127, -47, + 14908, -886, -3, -358, -35, -886, -315, -886, -1, 3, + 7342, 5, -886, -886, -886, 10264, -33, -30, -886, -317, + -886, 4, -95, -886, -886, 13522, 7, -886, -886, -886, + 10, 6, 10264, -27, 10264, -886, 8, 12, 14, 7829, + 15, 16, -886, -248, -886, -245, 17, 18, 20, 21, + -237, 22, 23, 24, 27, 28, 29, -234, 19, 30, + 39, -326, -886, 31, 10264, -886, 33, -886, -220, -886, + -886, -218, 11674, -886, -276, 1498, -886, -886, 44, -886, + -886, -886, -886, -277, -271, -886, 12136, -261, -886, -22, + -886, 13522, 13522, -886, 13522, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -258, -886, -886, -886, 46, -215, + 13984, 40, -886, 13522, -886, 51, -292, 50, 3, 10264, + 53, -886, -886, 8316, 47, 48, -334, -67, -886, -19, + -886, -345, 54, -117, 13522, -109, -886, -145, -108, -166, + -107, 64, -102, -67, -886, 14446, -886, -100, 13522, 68, + -47, -886, 8803, -16, 67, 10264, -16, 10264, -886, 10264, + 13522, -886, -358, -886, 36, -886, -886, -24, -41, -260, + -312, -148, -10, -6, 58, 94, 93, -329, 79, -886, + 12598, -886, 78, -886, -886, 84, 76, 77, -886, 89, + 91, 81, 13060, 95, 13522, 87, 82, 86, 90, 92, + -150, -886, -886, -72, -886, -186, 98, 51, -886, -886, + -886, -886, -886, 1985, -886, -886, -886, -886, -886, -886, + -886, -886, -886, 5394, -886, 12136, 50, 12136, -259, 10750, + -886, -886, 12136, 10264, -886, -886, -886, -209, -320, -886, + -886, 13522, 69, -886, -886, 13522, 103, -886, -886, -886, + 13522, -886, -886, 101, 105, 104, 109, -886, -332, -886, + -886, -205, 107, -886, -886, -886, -886, -886, -886, -201, + -886, -200, -886, -886, -195, 111, -886, -886, -886, -886, + -192, -886, -191, -886, -886, -886, -886, -886, -190, -886, + 112, -886, -189, 113, -187, 107, -886, -287, -179, -886, + 114, 121, -886, -886, -886, -16, 7, -70, -886, -886, + 10264, 10264, -45, -886, -886, 108, -886, -886, -886, 13522, + 13522, 13522, 13522, 13522, 13522, 13522, 13522, 13522, 13522, 13522, + 13522, 13522, 13522, 13522, 13522, 13522, 13522, 13522, -886, -886, + -886, 122, -886, 2472, -886, -886, -886, 2472, -886, 13522, + -886, -886, -44, 13522, -28, -886, -886, -886, -886, -886, + -886, -886, -886, -886, -886, -886, -886, -886, -886, -886, + -886, 13522, 13522, -886, -886, -886, -886, -886, -886, -886, + -886, 12136, -886, -886, -40, -886, 9290, -886, 13522, 123, + 116, -886, -886, -886, 126, 127, -886, -886, -886, -886, + -263, -253, -886, -323, -886, -345, -886, -345, -886, 13522, + 13522, -886, -145, -886, -145, -886, -166, -166, -886, 130, + 64, -886, 14446, -886, 13522, -886, -886, 10264, -29, 50, + -16, -886, -886, -886, -886, -886, -886, -24, -24, -41, + -41, -260, -260, -260, -260, -312, -312, -148, -10, -6, + 58, 94, 93, 13522, -886, 2472, 4420, 85, 3933, -177, + -886, -175, -886, -886, -886, -886, -886, 11212, -886, -886, + -886, -886, -886, -886, 133, -886, 99, -886, -173, -886, + -152, -886, -151, -886, -149, -886, -147, -146, -886, 9777, + -886, -886, -21, 129, 116, 100, 134, 136, -886, -886, + 4420, 137, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -886, -886, 13522, -886, 128, 2959, 13522, -886, + 131, 139, 96, 140, 3446, -886, 142, -886, 12136, -886, + -886, -886, -143, 13522, 2959, 137, -886, -886, 2472, -886, + 132, 116, -886, -886, 2472, 144, -886, -886 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1565,143 +1572,145 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int16 yydefact[] = { - 0, 170, 231, 229, 230, 228, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 232, 233, 234, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 369, 370, 371, 372, 373, 374, 375, 395, 396, 397, - 398, 399, 400, 401, 410, 423, 424, 411, 412, 414, - 413, 415, 416, 417, 418, 419, 420, 421, 422, 179, - 180, 258, 259, 257, 260, 261, 256, 262, 269, 270, - 267, 268, 265, 266, 263, 264, 301, 302, 303, 313, - 314, 315, 298, 299, 300, 310, 311, 312, 295, 296, - 297, 307, 308, 309, 292, 293, 294, 304, 305, 306, - 271, 272, 273, 316, 317, 318, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 328, 329, - 330, 286, 287, 288, 340, 341, 342, 289, 290, 291, - 352, 353, 354, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 343, 344, 345, 346, 347, 348, 349, 350, 351, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 367, - 364, 365, 366, 551, 552, 553, 554, 558, 560, 562, - 186, 563, 187, 555, 556, 559, 379, 380, 403, 406, - 368, 377, 378, 394, 376, 425, 426, 429, 430, 431, - 433, 434, 435, 437, 438, 439, 441, 442, 538, 539, - 402, 404, 405, 381, 382, 383, 427, 384, 388, 389, - 392, 432, 436, 440, 385, 386, 390, 391, 428, 387, - 393, 472, 474, 475, 476, 478, 479, 480, 482, 483, - 484, 486, 487, 488, 490, 491, 492, 494, 495, 496, - 498, 499, 500, 502, 503, 504, 506, 507, 508, 510, - 511, 512, 514, 515, 473, 477, 481, 485, 489, 497, - 501, 505, 493, 509, 513, 516, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 532, 533, 534, 535, 536, 537, 407, 408, 409, - 443, 452, 454, 448, 453, 455, 456, 458, 459, 460, - 462, 463, 464, 466, 467, 468, 470, 471, 444, 445, - 446, 457, 447, 449, 450, 451, 461, 465, 469, 543, - 544, 547, 548, 549, 550, 545, 546, 0, 0, 0, - 0, 0, 0, 0, 0, 168, 169, 540, 541, 542, - 0, 663, 139, 566, 567, 568, 0, 565, 174, 172, - 173, 171, 0, 227, 175, 177, 178, 176, 141, 140, - 0, 209, 557, 189, 191, 185, 193, 195, 190, 192, - 188, 194, 196, 181, 182, 212, 183, 184, 197, 204, - 205, 206, 207, 208, 198, 199, 200, 201, 202, 203, - 142, 143, 145, 144, 146, 148, 149, 147, 211, 156, - 662, 0, 664, 0, 114, 113, 0, 127, 132, 163, - 162, 160, 164, 0, 157, 159, 165, 137, 222, 161, - 564, 0, 659, 661, 0, 0, 166, 167, 561, 0, + 0, 176, 237, 235, 236, 234, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 238, 239, 240, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 375, 376, 377, 378, 379, 380, 381, 401, 402, 403, + 404, 405, 406, 407, 416, 429, 430, 417, 418, 420, + 419, 421, 422, 423, 424, 425, 426, 427, 428, 185, + 186, 264, 265, 263, 266, 267, 262, 268, 275, 276, + 273, 274, 271, 272, 269, 270, 307, 308, 309, 319, + 320, 321, 304, 305, 306, 316, 317, 318, 301, 302, + 303, 313, 314, 315, 298, 299, 300, 310, 311, 312, + 277, 278, 279, 322, 323, 324, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 334, 335, + 336, 292, 293, 294, 346, 347, 348, 295, 296, 297, + 358, 359, 360, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 373, + 370, 371, 372, 557, 558, 559, 560, 564, 566, 569, + 192, 570, 193, 561, 562, 565, 385, 386, 409, 412, + 374, 383, 384, 400, 382, 431, 432, 435, 436, 437, + 439, 440, 441, 443, 444, 445, 447, 448, 544, 545, + 408, 410, 411, 387, 388, 389, 433, 390, 394, 395, + 398, 438, 442, 446, 391, 392, 396, 397, 434, 393, + 399, 478, 480, 481, 482, 484, 485, 486, 488, 489, + 490, 492, 493, 494, 496, 497, 498, 500, 501, 502, + 504, 505, 506, 508, 509, 510, 512, 513, 514, 516, + 517, 518, 520, 521, 479, 483, 487, 491, 495, 503, + 507, 511, 499, 515, 519, 522, 523, 524, 525, 526, + 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, + 537, 538, 539, 540, 541, 542, 543, 413, 414, 415, + 449, 458, 460, 454, 459, 461, 462, 464, 465, 466, + 468, 469, 470, 472, 473, 474, 476, 477, 450, 451, + 452, 463, 453, 455, 456, 457, 467, 471, 475, 549, + 550, 553, 554, 555, 556, 551, 552, 0, 0, 0, + 0, 0, 0, 0, 0, 174, 175, 568, 546, 547, + 548, 0, 670, 145, 573, 574, 575, 0, 572, 180, + 178, 179, 177, 0, 233, 181, 183, 184, 182, 147, + 146, 0, 215, 563, 195, 197, 191, 199, 201, 196, + 198, 194, 200, 202, 187, 188, 218, 189, 190, 203, + 210, 211, 212, 213, 214, 204, 205, 206, 207, 208, + 209, 148, 149, 151, 150, 152, 154, 155, 153, 217, + 162, 669, 0, 671, 0, 121, 120, 0, 133, 138, + 169, 168, 166, 170, 0, 163, 165, 171, 143, 228, + 167, 571, 0, 666, 668, 0, 0, 172, 173, 567, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 571, 0, 0, 0, 100, 0, 95, 0, 109, 0, - 123, 115, 125, 0, 126, 0, 98, 133, 103, 107, - 0, 158, 138, 0, 215, 221, 1, 660, 0, 0, - 0, 97, 0, 0, 0, 671, 0, 729, 0, 0, + 0, 578, 0, 0, 0, 101, 0, 95, 0, 110, + 0, 0, 129, 122, 131, 0, 132, 0, 99, 139, + 104, 108, 0, 164, 144, 0, 221, 227, 1, 667, + 0, 121, 120, 0, 0, 98, 0, 0, 121, 120, + 0, 0, 678, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 669, 0, 667, 0, 0, 569, 153, - 155, 0, 151, 213, 0, 0, 101, 0, 0, 665, - 110, 0, 116, 122, 124, 119, 128, 118, 0, 134, - 105, 0, 104, 0, 0, 9, 0, 44, 43, 45, - 42, 5, 6, 7, 8, 2, 16, 14, 15, 17, - 10, 11, 12, 13, 3, 18, 37, 20, 25, 26, - 0, 0, 30, 0, 225, 0, 36, 224, 0, 216, - 111, 0, 96, 0, 0, 727, 0, 679, 0, 0, - 0, 0, 0, 696, 0, 0, 0, 0, 0, 0, - 0, 721, 0, 694, 0, 0, 0, 0, 99, 0, - 0, 0, 574, 0, 573, 580, 0, 0, 150, 0, - 210, 0, 217, 46, 50, 53, 56, 61, 64, 66, - 68, 70, 72, 74, 76, 0, 34, 0, 102, 607, - 616, 620, 0, 0, 0, 641, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 46, 79, 92, - 0, 594, 0, 165, 137, 597, 618, 596, 604, 595, - 0, 598, 599, 622, 600, 629, 601, 602, 637, 603, - 0, 0, 0, 120, 0, 129, 0, 588, 136, 0, - 0, 108, 38, 39, 0, 222, 22, 23, 0, 0, - 28, 27, 0, 227, 31, 33, 40, 0, 223, 112, - 731, 0, 732, 672, 0, 0, 730, 691, 687, 688, - 689, 690, 0, 685, 0, 94, 692, 0, 0, 706, - 707, 708, 709, 0, 704, 0, 713, 714, 715, 716, - 712, 0, 710, 0, 717, 0, 0, 0, 2, 725, - 222, 0, 723, 0, 0, 666, 668, 578, 0, 586, - 0, 584, 572, 0, 575, 0, 576, 581, 0, 154, - 152, 214, 0, 0, 0, 0, 0, 0, 0, 0, + 676, 0, 674, 0, 0, 576, 159, 161, 0, 157, + 219, 0, 0, 102, 0, 0, 672, 111, 0, 123, + 114, 128, 130, 125, 134, 124, 0, 140, 106, 0, + 105, 0, 0, 9, 0, 44, 43, 45, 42, 5, + 6, 7, 8, 2, 16, 14, 15, 17, 10, 11, + 12, 13, 3, 18, 37, 20, 25, 26, 0, 0, + 30, 0, 231, 0, 36, 230, 0, 222, 112, 0, + 0, 96, 97, 0, 174, 175, 0, 0, 734, 0, + 686, 0, 0, 0, 0, 0, 703, 0, 0, 0, + 0, 0, 0, 0, 728, 0, 701, 0, 0, 0, + 0, 100, 0, 0, 0, 581, 0, 580, 587, 0, + 0, 156, 0, 216, 0, 223, 46, 50, 53, 56, + 61, 64, 66, 68, 70, 72, 74, 76, 0, 34, + 0, 103, 614, 623, 627, 0, 0, 0, 648, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 77, 218, 219, 0, 606, 0, 639, 652, 651, - 0, 643, 0, 655, 653, 0, 0, 0, 636, 656, - 657, 658, 605, 82, 83, 85, 84, 87, 88, 89, - 90, 91, 86, 81, 0, 0, 621, 617, 619, 623, - 630, 638, 117, 121, 131, 0, 591, 592, 0, 135, - 0, 4, 0, 0, 24, 21, 32, 226, 675, 677, - 0, 0, 728, 0, 681, 0, 680, 0, 683, 0, - 0, 698, 0, 697, 0, 700, 0, 0, 702, 0, - 0, 722, 0, 719, 0, 695, 670, 0, 0, 587, - 0, 582, 577, 570, 47, 48, 49, 52, 51, 54, + 46, 79, 92, 0, 601, 0, 171, 143, 604, 625, + 603, 611, 602, 0, 605, 606, 629, 607, 636, 608, + 609, 644, 610, 0, 115, 0, 126, 0, 135, 0, + 595, 142, 0, 0, 109, 38, 39, 0, 228, 22, + 23, 0, 0, 28, 27, 0, 233, 31, 33, 40, + 0, 229, 113, 174, 175, 0, 0, 738, 0, 739, + 679, 0, 0, 737, 698, 694, 695, 696, 697, 0, + 692, 0, 94, 699, 0, 0, 713, 714, 715, 716, + 0, 711, 0, 720, 721, 722, 723, 719, 0, 717, + 0, 724, 0, 0, 0, 2, 732, 228, 0, 730, + 0, 0, 673, 675, 585, 0, 593, 0, 591, 579, + 0, 582, 0, 583, 588, 0, 160, 158, 220, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 77, 224, + 225, 0, 613, 0, 646, 659, 658, 0, 650, 0, + 662, 660, 0, 0, 0, 643, 663, 664, 665, 612, + 82, 83, 85, 84, 87, 88, 89, 90, 91, 86, + 81, 0, 0, 628, 624, 626, 630, 637, 645, 127, + 137, 0, 598, 599, 0, 141, 0, 4, 0, 0, + 24, 21, 32, 232, 0, 0, 117, 116, 682, 684, + 0, 0, 735, 0, 688, 0, 687, 0, 690, 0, + 0, 705, 0, 704, 0, 707, 0, 0, 709, 0, + 0, 729, 0, 726, 0, 702, 677, 0, 0, 594, + 0, 589, 584, 577, 47, 48, 49, 52, 51, 54, 55, 59, 60, 57, 58, 62, 63, 65, 67, 69, - 71, 73, 75, 0, 220, 608, 0, 0, 0, 0, - 654, 0, 635, 80, 93, 130, 589, 0, 106, 41, - 19, 673, 0, 674, 0, 686, 0, 693, 0, 705, - 0, 711, 0, 718, 0, 0, 724, 0, 583, 585, - 0, 0, 627, 0, 0, 0, 646, 645, 648, 614, - 631, 590, 593, 676, 678, 682, 684, 699, 701, 703, - 720, 579, 0, 609, 0, 0, 0, 647, 0, 0, - 626, 0, 0, 624, 0, 78, 0, 611, 640, 610, - 0, 649, 0, 614, 613, 615, 633, 628, 0, 650, - 644, 625, 634, 0, 642, 632 + 71, 73, 75, 0, 226, 615, 0, 0, 0, 0, + 661, 0, 642, 80, 93, 136, 596, 0, 107, 41, + 19, 119, 118, 680, 0, 681, 0, 693, 0, 700, + 0, 712, 0, 718, 0, 725, 0, 0, 731, 0, + 590, 592, 0, 0, 634, 0, 0, 0, 653, 652, + 655, 621, 638, 597, 600, 683, 685, 689, 691, 706, + 708, 710, 727, 586, 0, 616, 0, 0, 0, 654, + 0, 0, 633, 0, 0, 631, 0, 78, 0, 618, + 647, 617, 0, 656, 0, 621, 620, 622, 640, 635, + 0, 657, 651, 632, 641, 0, 649, 639 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -849, -569, -849, -849, -849, -849, -849, -849, -849, -849, - -849, -849, -454, -849, -413, -411, -517, -419, -280, -283, - -281, -279, -278, -277, -849, -504, -849, -524, -849, -521, - -545, 7, -849, -849, -849, 6, -412, -849, -849, 41, - 38, 42, -849, -849, -429, -849, -849, -849, -849, -111, - -849, -414, -420, -849, 9, -849, 0, -453, -849, -849, - -849, -528, 144, -849, -849, -849, -104, -98, -849, -849, - -584, -592, -579, -362, -639, -849, -388, -644, -848, -849, - -450, -849, -849, -460, -459, -849, -849, 58, -763, -381, - -849, -149, -849, -416, -849, -141, -849, -849, -849, -849, - -137, -849, -849, -849, -849, -849, -849, -849, -849, 88, - -849, -849, 2, -849, -77, -312, -485, -849, -849, -849, - -321, -320, -319, -849, -849, -318, -317, -316, -333, -328, - -849, -315, -336, -849, -418, -563 + -886, -583, -886, -886, -886, -886, -886, -886, -886, -886, + -886, -886, -461, -886, -544, -411, -509, -420, -266, -265, + -272, -268, -267, -262, -886, -518, -886, -535, -886, -541, + -571, 13, -886, -886, -886, 11, -886, -413, -414, -396, + 66, -428, 71, -886, -886, -430, -886, -886, -886, -886, + -90, -886, -410, -417, -886, 9, -886, 0, -449, -886, + -886, -886, -536, 176, -886, -886, -886, -82, -79, -886, + -886, -598, -605, -588, -350, -651, -886, -377, -654, -885, + -886, -441, -886, -886, -451, -450, -886, -886, 88, -785, + -374, -886, -136, -886, -412, -886, -134, -886, -886, -886, + -886, -132, -886, -886, -886, -886, -886, -886, -886, -886, + 120, -886, -886, 2, -886, -57, -188, -466, -886, -886, + -886, -313, -310, -314, -886, -886, -311, -308, -319, -309, + -321, -886, -325, -318, -886, -423, -574 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - 0, 554, 555, 556, 833, 557, 558, 559, 560, 561, - 562, 563, 647, 565, 614, 615, 616, 617, 618, 619, - 620, 621, 622, 623, 624, 648, 893, 649, 814, 650, - 739, 651, 411, 680, 470, 652, 413, 414, 415, 460, - 461, 462, 416, 417, 418, 419, 420, 421, 511, 512, - 422, 423, 424, 425, 566, 514, 626, 517, 474, 475, - 568, 428, 429, 430, 606, 507, 601, 602, 603, 867, - 604, 605, 750, 751, 678, 828, 655, 656, 657, 658, - 659, 786, 931, 968, 960, 961, 962, 969, 660, 661, - 662, 663, 963, 934, 664, 665, 964, 983, 666, 667, - 668, 896, 790, 898, 938, 958, 959, 669, 431, 432, - 433, 457, 670, 504, 505, 484, 485, 840, 841, 435, - 712, 713, 717, 436, 437, 723, 724, 731, 732, 735, - 438, 741, 742, 439, 486, 487 + 0, 562, 563, 564, 849, 565, 566, 567, 568, 569, + 570, 571, 660, 573, 627, 628, 629, 630, 631, 632, + 633, 634, 635, 636, 637, 661, 913, 662, 831, 663, + 756, 664, 412, 693, 472, 665, 487, 414, 415, 416, + 462, 463, 464, 417, 418, 419, 420, 421, 422, 518, + 519, 423, 424, 425, 426, 574, 521, 639, 524, 476, + 477, 576, 429, 430, 431, 619, 514, 614, 615, 616, + 887, 617, 618, 767, 768, 691, 844, 668, 669, 670, + 671, 672, 803, 953, 990, 982, 983, 984, 991, 673, + 674, 675, 676, 985, 956, 677, 678, 986, 1005, 679, + 680, 681, 916, 807, 918, 960, 980, 981, 682, 432, + 433, 434, 458, 683, 511, 512, 491, 492, 860, 861, + 436, 729, 730, 734, 437, 438, 740, 741, 748, 749, + 752, 439, 758, 759, 440, 493, 494 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1709,106 +1718,303 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 427, 463, 434, 471, 677, 479, 412, 410, 685, 426, - 479, 625, 757, 706, 529, 684, 818, 730, 754, 564, - 480, 569, 478, 895, 755, 480, 450, 780, 500, 706, - 769, 770, 509, 823, 838, 824, 716, 827, 694, 454, - 829, 700, 700, 471, 701, 463, 515, 627, 707, 448, - 744, 575, 832, -726, 516, 628, 510, 576, 451, -726, - 471, 613, 759, 781, 740, 455, 771, 772, 839, 473, - 473, 465, 673, 675, 466, 702, 702, 715, 697, 682, - 683, 708, 709, 710, 711, 440, 686, 687, 715, 703, - 698, 715, 527, 599, 515, 703, 830, 703, 767, 768, - 703, 528, 703, 715, 703, 703, -35, 967, 688, 703, - 515, 696, 689, 488, 975, 515, 489, 672, 795, 627, - 797, 627, 674, 784, 967, 441, 679, 613, 825, 490, - 492, 494, 496, 498, 499, 502, 577, 583, 613, 591, - 596, 613, 578, 584, 597, 592, 897, 906, 677, 907, - 677, 608, 677, 613, 610, 677, 704, 609, 691, 831, - 611, 442, 757, 491, 692, 815, 489, 834, 836, 868, - 842, 844, 737, 613, 846, 848, 576, 845, 851, 471, - 847, 849, 456, 853, 852, 855, 905, 858, 753, 854, - 599, 856, 599, 859, 803, 804, 805, 806, 807, 808, - 809, 810, 811, 812, 861, 863, 353, 354, 355, 939, - 862, 864, 940, 982, 813, 815, 945, 946, 815, 947, - 948, 949, 845, 849, 950, 852, 856, 859, 978, 911, - 864, 913, 443, 912, 815, 914, 458, 531, 757, 493, - 532, 479, 489, 837, 726, 727, 728, 729, 545, 773, - 774, 818, 881, 882, 883, 884, 480, 495, 478, 459, - 489, 719, 720, 721, 722, 473, 753, 497, 942, 501, - 489, 899, 489, 714, 718, 901, 489, 489, 725, 733, - 444, 489, 489, 927, 815, 902, 736, 730, 730, 489, - 903, 904, 743, 467, 815, 489, 869, 816, 445, 706, - 870, 677, 446, 871, 917, 716, 815, 952, 874, 875, - 876, 613, 613, 613, 613, 613, 613, 613, 613, 613, - 613, 613, 613, 613, 613, 613, 613, 977, 870, 815, - 447, 872, 900, 471, 740, 757, 740, 452, 818, 870, - 753, 765, 928, 766, 453, 715, 715, 483, 762, 763, - 764, 481, 877, 878, 885, 886, 879, 880, 715, 503, - 715, 508, 513, 518, 350, 530, 515, 525, 570, 573, - 526, 571, 930, 572, 579, 932, 574, 580, 909, 581, - 582, 598, 585, 677, 586, 587, 588, 593, 595, 589, - 681, 590, 594, 671, 690, 613, 613, 695, 607, -34, - 627, 527, 705, 734, 701, 752, 745, 778, 613, 782, - 613, 779, 785, 787, 775, 464, 753, 932, 791, 788, - 789, 793, 792, 472, 426, 777, 749, 761, 965, 776, - 796, 427, 426, 434, 427, 970, 798, 412, 410, 427, - 426, 434, 677, 426, 799, 482, 800, 801, 426, 506, - 979, 802, -36, 753, 822, 835, -29, 850, 843, 464, - 520, 857, 865, 464, 860, 866, 894, 933, 426, 910, - 873, 923, 426, 567, 815, 935, 943, 944, 953, 954, - 472, 955, 480, 956, 966, -612, 971, 972, 973, 426, - 985, 629, 976, 888, 984, 887, 889, 522, 760, 890, - 449, 891, 758, 892, 523, 524, 756, 600, 929, 933, - 936, 974, 980, 753, 981, 519, 426, 937, 654, 477, - 746, 819, 957, 921, 480, 915, 916, 653, 926, 820, - 0, 918, 924, 821, 0, 919, 920, 0, 0, 0, - 0, 922, 0, 0, 0, 0, 0, 925, 0, 0, + 428, 690, 435, 697, 638, 483, 465, 473, 698, 427, + 483, 413, 774, 411, 572, 723, 747, 771, 915, 835, + 537, 481, 480, 733, 507, 484, 488, 577, 772, 724, + 484, 723, 529, 797, 839, 707, 840, 761, 843, 482, + 717, 845, 858, 718, 489, 786, 787, 455, 473, 776, + 465, 717, 609, 441, 516, 451, 848, 610, 535, 442, + 522, 626, 522, 725, 726, 727, 728, 473, 536, 757, + 798, 523, 465, 456, 475, 719, 732, 859, 517, 465, + 695, 696, 788, 789, 686, 688, 719, 732, 452, -733, + 732, 710, 989, 784, 785, 846, -733, 699, 700, 997, + 522, 640, 732, 711, 612, 443, 522, 475, 685, 989, + 641, 812, 709, 814, 687, 933, 640, -35, 640, 701, + 934, 720, 801, 702, 692, 935, 841, 720, 588, 720, + 936, 590, 720, 626, 720, 589, 720, 720, 591, 596, + 467, 720, 604, 468, 626, 495, 597, 626, 496, 605, + 690, 529, 690, 917, 690, 529, 621, 690, 623, 626, + 850, 704, 444, 622, 721, 624, 774, 847, 705, 465, + 852, 862, 445, 465, 832, 864, 866, 888, 589, 626, + 754, 868, 865, 867, 871, 873, 875, 878, 869, 881, + 925, 872, 874, 876, 879, 473, 882, 883, 459, 961, + 457, 962, 460, 967, 884, 770, 832, 612, 832, 612, + 865, 790, 791, 1004, 820, 821, 822, 823, 824, 825, + 826, 827, 828, 829, 968, 969, 475, 970, 469, 971, + 972, 869, 872, 1000, 876, 830, 879, 884, 897, 898, + 832, 774, 743, 744, 745, 746, 553, 498, 500, 853, + 496, 496, 446, 483, 497, 499, 501, 503, 505, 506, + 509, 835, 447, 736, 737, 738, 739, 449, 919, 481, + 480, 502, 921, 484, 496, 485, 964, 901, 902, 903, + 904, 504, 508, 770, 496, 496, 448, 482, 539, 949, + 453, 540, 731, 747, 747, 496, 923, 924, 939, 733, + 735, 742, 750, 496, 496, 496, 690, 753, 723, 760, + 496, 832, 496, 890, 833, 454, 891, 889, 894, 895, + 896, 626, 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 999, 890, 832, + 926, 892, 920, 927, 774, 490, 757, 782, 757, 783, + 835, 732, 732, 473, 890, 832, 922, 950, 354, 355, + 356, 770, 832, 974, 732, 510, 732, 779, 780, 781, + 905, 906, 952, 899, 900, 954, 515, 520, 525, 533, + 351, 530, 534, 538, 522, 580, 578, 929, 792, 579, + 694, 793, 690, 722, 581, 606, 766, 583, 582, 587, + 586, 593, 592, 594, 595, 598, 599, 600, 626, 626, + 601, 602, 603, 607, 608, 708, 466, 611, 620, 954, + 684, 626, 703, 626, 474, 427, -34, 640, 535, 715, + 716, 718, 428, 427, 435, 428, 770, 992, 751, 987, + 428, 427, 435, 413, 427, 411, 762, 769, 778, 427, + 513, 486, 1001, 690, 794, 795, 796, 799, 802, 804, + 466, 527, 805, 806, 808, 466, 809, 810, 816, 427, + 813, 815, 817, -36, 427, 575, 818, 770, 819, -29, + 856, 851, 466, 854, 474, 857, 955, 855, 893, 466, + 885, 427, 863, 427, 870, 877, 880, 886, 427, 832, + 914, 930, 931, 932, 945, 957, 484, 965, 966, 975, + 977, 978, 976, 988, 613, 994, -619, 993, 1006, 642, + 995, 998, 909, 427, 1007, 667, 907, 910, 908, 911, + 955, 531, 777, 450, 666, 912, 532, 775, 773, 770, + 951, 958, 996, 1002, 959, 1003, 526, 836, 979, 837, + 484, 838, 479, 763, 938, 937, 940, 947, 944, 946, + 0, 0, 0, 942, 941, 0, 948, 943, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 466, + 712, 0, 0, 466, 0, 0, 0, 0, 427, 0, + 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 765, 0, 0, 613, 0, 613, 0, 613, + 0, 427, 0, 0, 427, 0, 427, 0, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 748, - 0, 0, 600, 0, 600, 0, 600, 0, 426, 0, - 0, 426, 0, 426, 0, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 667, 0, 0, 0, 0, 0, 0, + 0, 0, 666, 428, 0, 0, 0, 0, 0, 0, + 0, 0, 427, 613, 0, 0, 0, 0, 0, 0, + 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 654, 0, 0, 0, 0, 0, 0, 0, 0, 653, - 427, 0, 0, 0, 0, 0, 0, 0, 0, 426, - 600, 0, 0, 0, 0, 0, 0, 0, 0, 426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 765, 613, 0, 0, 0, 0, 0, 0, 0, 427, + 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 667, 0, 0, 0, 667, 0, 0, + 0, 0, 666, 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 748, 600, 0, 0, 0, 0, 0, - 0, 0, 426, 426, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 613, 0, 0, 0, + 0, 0, 0, 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 654, 0, 0, 0, - 654, 0, 0, 0, 0, 653, 0, 0, 0, 653, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 613, 0, 0, + 0, 0, 0, 0, 0, 0, 427, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 667, 667, 0, 667, 0, + 435, 0, 0, 0, 666, 666, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 600, 0, 0, 0, 0, 0, 0, 0, 0, 426, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 613, + 0, 0, 0, 0, 0, 0, 0, 0, 427, 0, + 667, 0, 0, 0, 0, 0, 0, 0, 0, 666, + 0, 0, 0, 0, 0, 0, 0, 667, 0, 0, + 0, 0, 0, 0, 667, 0, 666, 0, 0, 0, + 0, 0, 0, 666, 667, 0, 0, 0, 667, 0, + 0, 0, 0, 666, 667, 0, 0, 666, 0, 0, + 0, 478, 0, 666, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 351, 0, + 0, 0, 0, 0, 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 600, 0, 0, - 0, 0, 0, 0, 0, 0, 426, 0, 0, 0, + 0, 353, 354, 355, 356, 357, 0, 0, 0, 0, + 0, 0, 0, 0, 358, 359, 360, 361, 362, 363, + 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 365, 366, 367, 368, + 369, 370, 371, 0, 0, 0, 0, 0, 0, 0, + 0, 372, 0, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 654, 654, 0, 654, 0, - 434, 0, 0, 0, 653, 653, 0, 653, 0, 0, + 0, 0, 543, 544, 0, 351, 0, 642, 643, 0, + 0, 0, 0, 0, 644, 545, 546, 547, 548, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 353, 354, + 355, 356, 357, 0, 0, 0, 549, 550, 551, 552, + 553, 358, 359, 360, 361, 362, 363, 364, 645, 646, + 647, 648, 0, 649, 650, 651, 652, 653, 654, 655, + 656, 657, 658, 365, 366, 367, 368, 369, 370, 371, + 554, 555, 556, 557, 558, 559, 560, 561, 372, 659, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 0, 0, + 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 543, + 544, 0, 351, 0, 642, 834, 0, 0, 0, 0, + 0, 644, 545, 546, 547, 548, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 353, 354, 355, 356, 357, + 0, 0, 0, 549, 550, 551, 552, 553, 358, 359, + 360, 361, 362, 363, 364, 645, 646, 647, 648, 0, + 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, + 365, 366, 367, 368, 369, 370, 371, 554, 555, 556, + 557, 558, 559, 560, 561, 372, 659, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 600, 0, 0, - 0, 0, 0, 0, 0, 0, 426, 0, 654, 0, - 0, 0, 0, 0, 0, 0, 0, 653, 0, 0, - 0, 0, 0, 0, 0, 654, 0, 0, 0, 0, - 0, 0, 654, 0, 653, 0, 0, 0, 0, 0, - 0, 653, 654, 0, 0, 0, 654, 0, 0, 0, - 0, 653, 654, 0, 0, 653, 0, 0, 0, 476, - 0, 653, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 0, 0, 0, 0, 543, 544, 0, 351, + 0, 642, 0, 0, 0, 0, 0, 0, 644, 545, + 546, 547, 548, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 353, 354, 355, 356, 357, 0, 0, 0, + 549, 550, 551, 552, 553, 358, 359, 360, 361, 362, + 363, 364, 645, 646, 647, 648, 0, 649, 650, 651, + 652, 653, 654, 655, 656, 657, 658, 365, 366, 367, + 368, 369, 370, 371, 554, 555, 556, 557, 558, 559, + 560, 561, 372, 659, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, @@ -1843,117 +2049,215 @@ static const yytype_int16 yytable[] = 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 349, 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 350, 0, 0, 0, 0, - 0, 0, 0, 351, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, + 0, 0, 0, 543, 544, 0, 351, 0, 525, 0, + 0, 0, 0, 0, 0, 644, 545, 546, 547, 548, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 353, + 354, 355, 356, 357, 0, 0, 0, 549, 550, 551, + 552, 553, 358, 359, 360, 361, 362, 363, 364, 645, + 646, 647, 648, 0, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 365, 366, 367, 368, 369, 370, + 371, 554, 555, 556, 557, 558, 559, 560, 561, 372, + 659, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, + 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 533, 534, + 543, 544, 0, 351, 0, 0, 0, 0, 0, 0, + 0, 0, 644, 545, 546, 547, 548, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 353, 354, 355, 356, + 357, 0, 0, 0, 549, 550, 551, 552, 553, 358, + 359, 360, 361, 362, 363, 364, 645, 646, 647, 648, + 0, 649, 650, 651, 652, 653, 654, 655, 656, 657, + 658, 365, 366, 367, 368, 369, 370, 371, 554, 555, + 556, 557, 558, 559, 560, 561, 372, 659, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 535, 536, 0, - 350, 0, 629, 630, 0, 0, 0, 0, 631, 537, - 538, 539, 540, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 356, 0, 0, 0, - 541, 542, 543, 544, 545, 357, 358, 359, 360, 361, - 362, 363, 632, 633, 634, 635, 0, 636, 637, 638, - 639, 640, 641, 642, 643, 644, 645, 364, 365, 366, - 367, 368, 369, 370, 546, 547, 548, 549, 550, 551, - 552, 553, 371, 646, 372, 373, 374, 375, 376, 377, + 0, 0, 0, 0, 0, 0, 0, 543, 544, 0, + 351, 0, 0, 0, 0, 0, 0, 0, 0, 644, + 545, 546, 547, 548, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 353, 354, 355, 356, 357, 0, 0, + 0, 549, 550, 551, 552, 553, 358, 359, 360, 361, + 362, 363, 364, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 365, 366, + 367, 368, 369, 370, 371, 554, 555, 556, 557, 558, + 559, 560, 561, 372, 0, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 533, 534, 0, 0, 0, 0, 0, + 408, 409, 410, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 0, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 535, 536, 0, 350, 0, 629, 817, 0, - 0, 0, 0, 631, 537, 538, 539, 540, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 0, 0, 0, 541, 542, 543, 544, 545, - 357, 358, 359, 360, 361, 362, 363, 632, 633, 634, - 635, 0, 636, 637, 638, 639, 640, 641, 642, 643, - 644, 645, 364, 365, 366, 367, 368, 369, 370, 546, - 547, 548, 549, 550, 551, 552, 553, 371, 646, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, + 0, 0, 0, 0, 543, 544, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 545, 546, 547, + 548, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 353, 354, 355, 356, 0, 0, 0, 0, 549, 550, + 551, 552, 553, 358, 359, 360, 361, 362, 363, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 365, 366, 367, 368, 369, + 370, 371, 554, 555, 556, 557, 558, 559, 560, 561, + 372, 0, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 351, 0, 0, 0, 0, 0, + 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 353, 354, 355, + 356, 357, 0, 0, 0, 0, 0, 0, 0, 0, + 358, 359, 360, 361, 362, 363, 364, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 365, 366, 367, 368, 369, 370, 371, 0, + 0, 0, 0, 0, 0, 0, 0, 372, 0, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -1987,22 +2291,217 @@ static const yytype_int16 yytable[] = 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 533, 534, + 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 535, 536, 0, - 350, 0, 629, 0, 0, 0, 0, 0, 631, 537, - 538, 539, 540, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 356, 0, 0, 0, - 541, 542, 543, 544, 545, 357, 358, 359, 360, 361, - 362, 363, 632, 633, 634, 635, 0, 636, 637, 638, - 639, 640, 641, 642, 643, 644, 645, 364, 365, 366, - 367, 368, 369, 370, 546, 547, 548, 549, 550, 551, - 552, 553, 371, 646, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 353, 354, 355, 356, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 358, 359, 360, + 361, 362, 363, 364, 645, 0, 0, 648, 0, 649, + 650, 0, 0, 653, 0, 0, 0, 0, 0, 365, + 366, 367, 368, 369, 370, 371, 0, 0, 0, 0, + 0, 0, 0, 0, 372, 0, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 0, 0, 0, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 470, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 353, 354, 355, 356, 0, 0, 0, 0, 0, + 0, 0, 0, 471, 358, 359, 360, 361, 362, 363, + 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 365, 366, 367, 368, + 369, 370, 371, 0, 0, 0, 0, 0, 0, 0, + 0, 372, 0, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 0, 0, 0, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 461, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 353, 354, + 355, 356, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 358, 359, 360, 361, 362, 363, 364, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 365, 366, 367, 368, 369, 370, 371, + 0, 0, 0, 0, 0, 0, 0, 0, 372, 0, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 0, 0, 0, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 351, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 353, 354, 355, 356, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 358, 359, + 360, 361, 362, 363, 364, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 365, 366, 367, 368, 369, 370, 371, 0, 0, 0, + 0, 0, 0, 0, 0, 372, 0, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 0, 0, 0, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 350, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 528, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 353, 354, 355, 356, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 358, 359, 360, 361, 362, + 363, 364, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 365, 366, 367, + 368, 369, 370, 371, 0, 0, 0, 0, 0, 0, + 0, 0, 372, 0, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, @@ -2035,22 +2534,217 @@ static const yytype_int16 yytable[] = 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 533, 534, 0, 0, 0, 0, 0, + 329, 330, 331, 332, 333, 334, 335, 336, 0, 0, + 0, 340, 341, 342, 343, 344, 584, 585, 347, 348, + 349, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 535, 536, 0, 350, 0, 518, 0, 0, - 0, 0, 0, 631, 537, 538, 539, 540, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 0, 0, 0, 541, 542, 543, 544, 545, - 357, 358, 359, 360, 361, 362, 363, 632, 633, 634, - 635, 0, 636, 637, 638, 639, 640, 641, 642, 643, - 644, 645, 364, 365, 366, 367, 368, 369, 370, 546, - 547, 548, 549, 550, 551, 552, 553, 371, 646, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 461, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 353, + 354, 355, 356, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 358, 359, 360, 361, 362, 363, 364, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 365, 366, 367, 368, 369, 370, + 371, 0, 0, 0, 0, 0, 0, 0, 0, 372, + 0, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 0, 0, 0, 340, 341, + 342, 343, 344, 713, 714, 347, 348, 349, 350, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 528, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 353, 354, 355, 356, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 358, + 359, 360, 361, 362, 363, 364, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 365, 366, 367, 368, 369, 370, 371, 0, 0, + 0, 0, 0, 0, 0, 0, 372, 0, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 0, 0, 0, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 764, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 353, 354, 355, 356, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 358, 359, 360, 361, + 362, 363, 364, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 365, 366, + 367, 368, 369, 370, 371, 0, 0, 0, 0, 0, + 0, 0, 0, 372, 0, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 0, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 928, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 353, 354, 355, 356, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 358, 359, 360, 361, 362, 363, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 365, 366, 367, 368, 369, + 370, 371, 0, 0, 0, 0, 0, 0, 0, 0, + 372, 0, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 0, 0, 0, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 973, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 353, 354, 355, + 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 358, 359, 360, 361, 362, 363, 364, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 365, 366, 367, 368, 369, 370, 371, 0, + 0, 0, 0, 0, 0, 0, 0, 372, 0, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -2084,76 +2778,120 @@ static const yytype_int16 yytable[] = 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 533, 534, + 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 535, 536, 0, - 350, 0, 0, 0, 0, 0, 0, 0, 631, 537, - 538, 539, 540, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 356, 0, 0, 0, - 541, 542, 543, 544, 545, 357, 358, 359, 360, 361, - 362, 363, 632, 633, 634, 635, 0, 636, 637, 638, - 639, 640, 641, 642, 643, 644, 645, 364, 365, 366, - 367, 368, 369, 370, 546, 547, 548, 549, 550, 551, - 552, 553, 371, 646, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 533, 534, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 535, 536, 0, 350, 0, 0, 0, 0, - 0, 0, 0, 631, 537, 538, 539, 540, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 0, 0, 0, 541, 542, 543, 544, 545, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 546, - 547, 548, 549, 550, 551, 552, 553, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 353, 354, 355, 356, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 358, 359, 360, + 361, 362, 363, 364, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 365, + 366, 367, 368, 369, 370, 371, 0, 0, 0, 0, + 0, 0, 0, 0, 372, 0, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 0, 181, 0, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 0, + 0, 0, 0, 0, 0, 343, 0, 0, 0, 347, + 348, 349, 350, 0, 0, 541, 542, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 543, 544, 0, 0, 0, 689, + 842, 0, 0, 0, 0, 0, 0, 545, 546, 547, + 548, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 549, 550, + 551, 552, 553, 358, 0, 0, 0, 0, 363, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 554, 555, 556, 557, 558, 559, 560, 561, + 0, 0, 373, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 386, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 0, 181, 0, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 0, 0, 0, 0, 0, 0, 343, 0, 0, + 0, 347, 348, 349, 350, 0, 0, 541, 542, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 543, 544, 0, 0, + 0, 689, 963, 0, 0, 0, 0, 0, 0, 545, + 546, 547, 548, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 549, 550, 551, 552, 553, 358, 0, 0, 0, 0, + 363, 364, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 554, 555, 556, 557, 558, 559, + 560, 561, 0, 0, 373, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 386, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, @@ -2165,7 +2903,7 @@ static const yytype_int16 yytable[] = 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 174, 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, @@ -2181,76 +2919,210 @@ static const yytype_int16 yytable[] = 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 533, 534, + 334, 335, 336, 0, 0, 0, 0, 0, 0, 343, + 0, 0, 0, 347, 348, 349, 350, 0, 0, 541, + 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 543, 544, + 0, 0, 625, 0, 0, 0, 0, 0, 0, 0, + 0, 545, 546, 547, 548, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 535, 536, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 537, - 538, 539, 540, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 0, 0, 0, 0, - 541, 542, 543, 544, 545, 357, 358, 359, 360, 361, - 362, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 365, 366, - 367, 368, 369, 370, 546, 547, 548, 549, 550, 551, - 552, 553, 371, 0, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 549, 550, 551, 552, 553, 358, 0, 0, + 0, 0, 363, 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 350, 0, 0, 0, 0, - 0, 0, 0, 351, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 554, 555, 556, 557, + 558, 559, 560, 561, 0, 0, 373, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 386, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 0, 181, + 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 0, 0, 0, 0, 0, + 0, 343, 0, 0, 0, 347, 348, 349, 350, 0, + 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, + 543, 544, 0, 0, 0, 689, 0, 0, 0, 0, + 0, 0, 0, 545, 546, 547, 548, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 549, 550, 551, 552, 553, 358, + 0, 0, 0, 0, 363, 364, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 554, 555, + 556, 557, 558, 559, 560, 561, 0, 0, 373, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 386, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, + 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 0, 181, 0, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 0, 0, 0, + 0, 0, 0, 343, 0, 0, 0, 347, 348, 349, + 350, 0, 0, 541, 542, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 543, 544, 0, 0, 800, 0, 0, 0, + 0, 0, 0, 0, 0, 545, 546, 547, 548, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 549, 550, 551, 552, + 553, 358, 0, 0, 0, 0, 363, 364, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 554, 555, 556, 557, 558, 559, 560, 561, 0, 0, + 373, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 386, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 0, 181, 0, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 0, + 0, 0, 0, 0, 0, 343, 0, 0, 0, 347, + 348, 349, 350, 0, 0, 541, 542, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 543, 544, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 811, 545, 546, 547, + 548, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 549, 550, + 551, 552, 553, 358, 0, 0, 0, 0, 363, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 554, 555, 556, 557, 558, 559, 560, 561, + 0, 0, 373, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 386, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 0, 181, 0, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 0, 0, 0, 0, 0, 0, 343, 0, 0, + 0, 347, 348, 349, 350, 0, 0, 541, 542, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 543, 544, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 545, + 546, 547, 548, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 549, 550, 551, 552, 553, 358, 0, 0, 0, 0, + 363, 364, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 554, 555, 556, 557, 558, 559, + 560, 561, 0, 0, 373, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 386, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, @@ -2262,7 +3134,7 @@ static const yytype_int16 yytable[] = 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 174, 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, @@ -2278,22 +3150,217 @@ static const yytype_int16 yytable[] = 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 0, 0, + 334, 335, 336, 0, 0, 0, 0, 0, 0, 343, + 0, 0, 0, 347, 348, 349, 350, 0, 0, 541, + 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 543, 544, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 545, 546, 547, 548, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 549, 550, 551, 552, 553, 358, 0, 0, + 0, 0, 363, 706, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 554, 555, 556, 557, + 558, 559, 560, 561, 0, 0, 373, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 386, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 0, 181, + 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 0, 0, 0, 0, 0, + 0, 343, 0, 0, 0, 347, 348, 349, 350, 0, + 0, 541, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 357, 358, 359, 360, 361, - 362, 363, 632, 0, 0, 635, 0, 636, 637, 0, - 0, 640, 0, 0, 0, 0, 0, 364, 365, 366, - 367, 368, 369, 370, 0, 0, 0, 0, 0, 0, - 0, 0, 371, 0, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, + 543, 544, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 545, 546, 547, 548, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 549, 550, 551, 552, 755, 358, + 0, 0, 0, 0, 363, 364, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 554, 555, + 556, 557, 558, 559, 560, 561, 0, 0, 373, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 386, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, + 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 0, 181, 0, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 0, 0, 0, + 0, 0, 0, 343, 0, 0, 0, 347, 348, 349, + 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 358, 0, 0, 0, 0, 363, 364, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 373 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 536, 0, 544, 522, 435, 416, 424, 544, 0, + 440, 0, 617, 0, 475, 589, 599, 615, 803, 673, + 469, 435, 435, 594, 447, 435, 440, 476, 616, 374, + 440, 605, 460, 362, 685, 570, 687, 608, 689, 435, + 374, 692, 374, 377, 440, 357, 358, 386, 465, 620, + 460, 374, 378, 375, 412, 379, 376, 383, 375, 375, + 377, 522, 377, 408, 409, 410, 411, 484, 385, 605, + 399, 386, 482, 412, 394, 409, 594, 409, 436, 489, + 541, 542, 394, 395, 533, 534, 409, 605, 412, 376, + 608, 383, 977, 353, 354, 693, 383, 355, 356, 984, + 377, 377, 620, 395, 514, 375, 377, 394, 385, 994, + 386, 652, 573, 654, 385, 378, 377, 375, 377, 377, + 383, 587, 640, 381, 385, 378, 385, 593, 376, 595, + 383, 376, 598, 594, 600, 383, 602, 603, 383, 376, + 383, 607, 376, 386, 605, 409, 383, 608, 412, 383, + 685, 579, 687, 807, 689, 583, 376, 692, 376, 620, + 701, 376, 375, 383, 587, 383, 771, 376, 383, 579, + 705, 376, 375, 583, 383, 376, 376, 765, 383, 640, + 603, 376, 383, 383, 376, 376, 376, 376, 383, 376, + 841, 383, 383, 383, 383, 612, 383, 376, 376, 376, + 386, 376, 383, 376, 383, 615, 383, 617, 383, 619, + 383, 359, 360, 998, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 376, 376, 394, 376, 412, 376, + 376, 383, 383, 376, 383, 385, 383, 383, 782, 783, + 383, 846, 408, 409, 410, 411, 412, 409, 409, 710, + 412, 412, 375, 683, 442, 443, 444, 445, 446, 447, + 448, 915, 375, 408, 409, 410, 411, 377, 809, 683, + 683, 409, 813, 683, 412, 386, 927, 786, 787, 788, + 789, 409, 409, 693, 412, 412, 375, 683, 383, 887, + 375, 386, 409, 876, 877, 412, 831, 832, 869, 870, + 409, 409, 409, 412, 412, 412, 841, 409, 882, 409, + 412, 383, 412, 383, 386, 375, 386, 766, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, + 791, 792, 793, 794, 795, 796, 797, 988, 383, 383, + 380, 386, 386, 383, 949, 412, 882, 388, 884, 390, + 1004, 869, 870, 770, 383, 383, 384, 386, 401, 402, + 403, 771, 383, 384, 882, 412, 884, 391, 392, 393, + 790, 791, 913, 784, 785, 916, 379, 412, 379, 412, + 377, 376, 412, 379, 377, 412, 376, 848, 398, 383, + 412, 397, 927, 412, 386, 376, 412, 383, 386, 383, + 385, 383, 385, 383, 383, 383, 383, 383, 869, 870, + 383, 383, 383, 383, 375, 375, 416, 386, 385, 960, + 376, 882, 376, 884, 424, 416, 375, 377, 375, 382, + 382, 377, 432, 424, 432, 435, 846, 978, 374, 974, + 440, 432, 440, 432, 435, 432, 378, 380, 412, 440, + 450, 440, 993, 988, 396, 361, 363, 378, 380, 375, + 460, 459, 386, 386, 375, 465, 375, 386, 386, 460, + 375, 384, 386, 375, 465, 475, 386, 887, 386, 376, + 376, 412, 482, 382, 484, 376, 916, 382, 380, 489, + 376, 482, 385, 484, 383, 383, 383, 376, 489, 383, + 378, 378, 376, 376, 374, 420, 916, 374, 409, 380, + 376, 375, 412, 385, 514, 376, 379, 386, 386, 379, + 424, 379, 794, 514, 380, 525, 792, 795, 793, 796, + 960, 465, 622, 357, 525, 797, 465, 619, 617, 949, + 890, 918, 983, 994, 918, 995, 458, 683, 960, 683, + 960, 683, 432, 610, 867, 865, 870, 882, 877, 880, + -1, -1, -1, 874, 872, -1, 884, 876, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 579, + 578, -1, -1, 583, -1, -1, -1, -1, 579, -1, + -1, -1, 583, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 612, -1, -1, 615, -1, 617, -1, 619, + -1, 612, -1, -1, 615, -1, 617, -1, 619, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 673, -1, -1, -1, -1, -1, -1, + -1, -1, 673, 683, -1, -1, -1, -1, -1, -1, + -1, -1, 683, 693, -1, -1, -1, -1, -1, -1, + -1, -1, 693, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 770, 771, -1, -1, -1, -1, -1, -1, -1, 770, + 771, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 803, -1, -1, -1, 807, -1, -1, + -1, -1, 803, -1, -1, -1, 807, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 846, -1, -1, -1, + -1, -1, -1, -1, -1, 846, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 887, -1, -1, + -1, -1, -1, -1, -1, -1, 887, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 915, 916, -1, 918, -1, + 918, -1, -1, -1, 915, 916, -1, 918, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 949, + -1, -1, -1, -1, -1, -1, -1, -1, 949, -1, + 960, -1, -1, -1, -1, -1, -1, -1, -1, 960, + -1, -1, -1, -1, -1, -1, -1, 977, -1, -1, + -1, -1, -1, -1, 984, -1, 977, -1, -1, -1, + -1, -1, -1, 984, 994, -1, -1, -1, 998, -1, + -1, -1, -1, 994, 1004, -1, -1, 998, -1, -1, + -1, 0, -1, 1004, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, @@ -2326,45 +3393,240 @@ static const yytype_int16 yytable[] = 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 0, 0, - 0, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 468, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 0, 0, 0, 0, 0, 0, 0, 0, 469, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 377, -1, + -1, -1, -1, -1, -1, -1, -1, 386, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 400, 401, 402, 403, 404, -1, -1, -1, -1, + -1, -1, -1, -1, 413, 414, 415, 416, 417, 418, + 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 435, 436, 437, 438, + 439, 440, 441, -1, -1, -1, -1, -1, -1, -1, + -1, 450, -1, 452, 453, 454, 455, 456, 457, 458, + 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, + 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, -1, -1, 355, 356, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 374, 375, -1, 377, -1, 379, 380, -1, + -1, -1, -1, -1, 386, 387, 388, 389, 390, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 400, 401, + 402, 403, 404, -1, -1, -1, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, -1, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, + 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, -1, + 355, 356, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 374, + 375, -1, 377, -1, 379, 380, -1, -1, -1, -1, + -1, 386, 387, 388, 389, 390, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 400, 401, 402, 403, 404, + -1, -1, -1, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, -1, -1, 355, 356, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 374, 375, -1, 377, + -1, 379, -1, -1, -1, -1, -1, -1, 386, 387, + 388, 389, 390, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 400, 401, 402, 403, 404, -1, -1, -1, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, -1, 425, 426, 427, + 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 351, 352, -1, -1, 355, 356, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 374, 375, -1, 377, -1, 379, -1, + -1, -1, -1, -1, -1, 386, 387, 388, 389, 390, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, + 401, 402, 403, 404, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 421, 422, 423, -1, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, @@ -2375,22 +3637,217 @@ static const yytype_int16 yytable[] = 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 350, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 357, 358, 359, 360, 361, - 362, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 365, 366, - 367, 368, 369, 370, 0, 0, 0, 0, 0, 0, - 0, 0, 371, 0, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, + -1, 355, 356, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 374, 375, -1, 377, -1, -1, -1, -1, -1, -1, + -1, -1, 386, 387, 388, 389, 390, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 400, 401, 402, 403, + 404, -1, -1, -1, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + -1, 425, 426, 427, 428, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, + 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, -1, -1, 355, 356, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 374, 375, -1, + 377, -1, -1, -1, -1, -1, -1, -1, -1, 386, + 387, 388, 389, 390, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 400, 401, 402, 403, 404, -1, -1, + -1, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 447, 448, 449, 450, -1, 452, 453, 454, 455, 456, + 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, + -1, -1, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, -1, -1, 355, 356, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 374, 375, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 387, 388, 389, + 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 400, 401, 402, 403, -1, -1, -1, -1, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, + 450, -1, 452, 453, 454, 455, 456, 457, 458, 459, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, + 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 377, -1, -1, -1, -1, -1, + -1, -1, -1, 386, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 400, 401, 402, + 403, 404, -1, -1, -1, -1, -1, -1, -1, -1, + 413, 414, 415, 416, 417, 418, 419, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 435, 436, 437, 438, 439, 440, 441, -1, + -1, -1, -1, -1, -1, -1, -1, 450, -1, 452, + 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, + 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, + 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 400, 401, 402, 403, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 413, 414, 415, + 416, 417, 418, 419, 420, -1, -1, 423, -1, 425, + 426, -1, -1, 429, -1, -1, -1, -1, -1, 435, + 436, 437, 438, 439, 440, 441, -1, -1, -1, -1, + -1, -1, -1, -1, 450, -1, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, + 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, @@ -2423,1555 +3880,169 @@ static const yytype_int16 yytable[] = 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 0, 0, - 0, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 521, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 747, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 357, 358, 359, 360, 361, - 362, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 365, 366, - 367, 368, 369, 370, 0, 0, 0, 0, 0, 0, - 0, 0, 371, 0, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 0, 0, - 0, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 908, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 0, 0, 0, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 951, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 357, 358, 359, 360, 361, - 362, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 365, 366, - 367, 368, 369, 370, 0, 0, 0, 0, 0, 0, - 0, 0, 371, 0, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 0, 0, - 0, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 357, 358, 359, 360, 361, 362, 363, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 364, 365, 366, 367, 368, 369, 370, 0, - 0, 0, 0, 0, 0, 0, 0, 371, 0, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 676, 826, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 676, 941, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 612, 0, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 676, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 783, 0, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 794, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 545, 357, 0, 0, 0, 0, 362, - 693, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 533, 534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 535, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 537, 538, - 539, 540, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, - 542, 543, 544, 738, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 546, 547, 548, 549, 550, 551, 552, - 553, 0, 0, 372, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 385, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 0, 181, 0, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 0, 0, 0, 0, 0, 0, 343, 0, - 0, 0, 347, 348, 349, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 357, 0, 0, 0, 0, 362, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 372 -}; - -static const yytype_int16 yycheck[] = -{ - 0, 415, 0, 423, 528, 434, 0, 0, 536, 0, - 439, 515, 604, 576, 467, 536, 660, 586, 602, 473, - 434, 474, 434, 786, 603, 439, 378, 361, 446, 592, - 356, 357, 410, 672, 373, 674, 581, 676, 562, 384, - 679, 373, 373, 463, 376, 459, 376, 376, 373, 376, - 595, 375, 375, 375, 384, 384, 434, 381, 410, 381, - 480, 515, 607, 397, 592, 410, 392, 393, 407, 392, - 392, 381, 525, 526, 384, 407, 407, 581, 381, 533, - 534, 406, 407, 408, 409, 374, 354, 355, 592, 574, - 393, 595, 374, 507, 376, 580, 680, 582, 352, 353, - 585, 383, 587, 607, 589, 590, 374, 955, 376, 594, - 376, 565, 380, 407, 962, 376, 410, 383, 639, 376, - 641, 376, 383, 627, 972, 374, 383, 581, 383, 441, - 442, 443, 444, 445, 446, 447, 375, 375, 592, 375, - 377, 595, 381, 381, 381, 381, 790, 379, 672, 381, - 674, 375, 676, 607, 375, 679, 574, 381, 375, 375, - 381, 374, 754, 407, 381, 381, 410, 688, 692, 748, - 375, 375, 590, 627, 375, 375, 381, 381, 375, 599, - 381, 381, 384, 375, 381, 375, 825, 375, 602, 381, - 604, 381, 606, 381, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 375, 375, 399, 400, 401, 375, - 381, 381, 375, 976, 383, 381, 375, 375, 381, 375, - 375, 375, 381, 381, 375, 381, 381, 381, 375, 377, - 381, 377, 374, 381, 381, 381, 375, 381, 830, 407, - 384, 670, 410, 697, 406, 407, 408, 409, 410, 358, - 359, 895, 769, 770, 771, 772, 670, 407, 670, 381, - 410, 406, 407, 408, 409, 392, 680, 407, 907, 407, - 410, 792, 410, 407, 407, 796, 410, 410, 407, 407, - 374, 410, 410, 867, 381, 382, 407, 856, 857, 410, - 814, 815, 407, 410, 381, 410, 749, 384, 374, 862, - 381, 825, 374, 384, 849, 850, 381, 382, 762, 763, - 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, - 774, 775, 776, 777, 778, 779, 780, 966, 381, 381, - 374, 384, 384, 753, 862, 927, 864, 374, 982, 381, - 754, 386, 384, 388, 374, 849, 850, 410, 389, 390, - 391, 384, 765, 766, 773, 774, 767, 768, 862, 410, - 864, 378, 410, 378, 376, 378, 376, 410, 375, 383, - 410, 410, 893, 384, 383, 896, 381, 381, 832, 381, - 381, 384, 381, 907, 381, 381, 381, 375, 374, 381, - 410, 381, 381, 380, 375, 849, 850, 374, 383, 374, - 376, 374, 410, 373, 376, 379, 377, 360, 862, 377, - 864, 362, 379, 374, 396, 415, 830, 938, 374, 384, - 384, 384, 374, 423, 415, 394, 410, 410, 952, 395, - 374, 431, 423, 431, 434, 956, 382, 431, 431, 439, - 431, 439, 966, 434, 384, 439, 384, 384, 439, 449, - 971, 384, 374, 867, 380, 410, 375, 381, 383, 459, - 458, 381, 375, 463, 381, 375, 377, 896, 459, 377, - 379, 373, 463, 473, 381, 418, 373, 407, 379, 410, - 480, 375, 896, 374, 383, 378, 384, 375, 422, 480, - 379, 378, 378, 776, 384, 775, 777, 459, 609, 778, - 356, 779, 606, 780, 463, 463, 604, 507, 870, 938, - 898, 961, 972, 927, 973, 457, 507, 898, 518, 431, - 597, 670, 938, 856, 938, 845, 847, 518, 864, 670, - -1, 850, 860, 670, -1, 852, 854, -1, -1, -1, - -1, 857, -1, -1, -1, -1, -1, 862, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 570, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 599, - -1, -1, 602, -1, 604, -1, 606, -1, 599, -1, - -1, 602, -1, 604, -1, 606, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 660, -1, -1, -1, -1, -1, -1, -1, -1, 660, - 670, -1, -1, -1, -1, -1, -1, -1, -1, 670, - 680, -1, -1, -1, -1, -1, -1, -1, -1, 680, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 753, 754, -1, -1, -1, -1, -1, - -1, -1, 753, 754, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 786, -1, -1, -1, - 790, -1, -1, -1, -1, 786, -1, -1, -1, 790, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 830, -1, -1, -1, -1, -1, -1, -1, -1, 830, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 867, -1, -1, - -1, -1, -1, -1, -1, -1, 867, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 895, 896, -1, 898, -1, - 898, -1, -1, -1, 895, 896, -1, 898, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 927, -1, -1, - -1, -1, -1, -1, -1, -1, 927, -1, 938, -1, - -1, -1, -1, -1, -1, -1, -1, 938, -1, -1, - -1, -1, -1, -1, -1, 955, -1, -1, -1, -1, - -1, -1, 962, -1, 955, -1, -1, -1, -1, -1, - -1, 962, 972, -1, -1, -1, 976, -1, -1, -1, - -1, 972, 982, -1, -1, 976, -1, -1, -1, 0, - -1, 982, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, - -1, -1, -1, 384, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, 402, -1, -1, -1, -1, -1, -1, -1, -1, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, 354, 355, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 373, 374, -1, - 376, -1, 378, 379, -1, -1, -1, -1, 384, 385, - 386, 387, 388, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, 402, -1, -1, -1, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, -1, 423, 424, 425, - 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, 354, 355, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 373, 374, -1, 376, -1, 378, 379, -1, - -1, -1, -1, 384, 385, 386, 387, 388, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, 402, -1, -1, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, -1, 423, 424, 425, 426, 427, 428, 429, 430, - 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, 354, 355, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 373, 374, -1, - 376, -1, 378, -1, -1, -1, -1, -1, 384, 385, - 386, 387, 388, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, 402, -1, -1, -1, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, -1, 423, 424, 425, - 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, 354, 355, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 373, 374, -1, 376, -1, 378, -1, -1, - -1, -1, -1, 384, 385, 386, 387, 388, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, 402, -1, -1, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, -1, 423, 424, 425, 426, 427, 428, 429, 430, - 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, 354, 355, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 373, 374, -1, - 376, -1, -1, -1, -1, -1, -1, -1, 384, 385, - 386, 387, 388, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, 402, -1, -1, -1, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, -1, 423, 424, 425, - 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, 354, 355, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 373, 374, -1, 376, -1, -1, -1, -1, - -1, -1, -1, 384, 385, 386, 387, 388, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, 402, -1, -1, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, 354, 355, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 373, 374, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 385, - 386, 387, 388, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, -1, -1, -1, -1, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, -1, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, - -1, -1, -1, 384, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, 402, -1, -1, -1, -1, -1, -1, -1, -1, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 411, 412, 413, 414, 415, - 416, 417, 418, -1, -1, 421, -1, 423, 424, -1, - -1, 427, -1, -1, -1, -1, -1, 433, 434, 435, - 436, 437, 438, 439, -1, -1, -1, -1, -1, -1, - -1, -1, 448, -1, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, -1, -1, - -1, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 384, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, -1, -1, -1, -1, -1, -1, -1, -1, 410, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 411, 412, 413, 414, 415, - 416, 417, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 433, 434, 435, - 436, 437, 438, 439, -1, -1, -1, -1, -1, -1, - -1, -1, 448, -1, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, -1, -1, - -1, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + -1, -1, -1, 342, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 380, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 386, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, -1, -1, + -1, 400, 401, 402, 403, -1, -1, -1, -1, -1, + -1, -1, -1, 412, 413, 414, 415, 416, 417, 418, + 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 435, 436, 437, 438, + 439, 440, 441, -1, -1, -1, -1, -1, -1, -1, + -1, 450, -1, 452, 453, 454, 455, 456, 457, 458, + 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, + 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, -1, -1, -1, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 378, -1, -1, -1, -1, -1, -1, -1, + 382, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 400, 401, + 402, 403, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 413, 414, 415, 416, 417, 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 411, 412, 413, 414, 415, - 416, 417, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 433, 434, 435, - 436, 437, 438, 439, -1, -1, -1, -1, -1, -1, - -1, -1, 448, -1, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, -1, -1, - -1, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 435, 436, 437, 438, 439, 440, 441, + -1, -1, -1, -1, -1, -1, -1, -1, 450, -1, + 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, + 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, -1, -1, -1, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 379, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, + -1, -1, 377, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, - 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 351, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 400, 401, 402, 403, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 413, 414, + 415, 416, 417, 418, 419, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 435, 436, 437, 438, 439, 440, 441, -1, -1, -1, + -1, -1, -1, -1, -1, 450, -1, 452, 453, 454, + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, -1, -1, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 379, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 382, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 398, 399, 400, 401, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 411, 412, 413, 414, 415, - 416, 417, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 433, 434, 435, - 436, 437, 438, 439, -1, -1, -1, -1, -1, -1, - -1, -1, 448, -1, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, - 486, 487, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, 400, 401, 402, 403, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 413, 414, 415, 416, 417, + 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 435, 436, 437, + 438, 439, 440, 441, -1, -1, -1, -1, -1, -1, + -1, -1, 450, -1, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, @@ -4006,302 +4077,75 @@ static const yytype_int16 yycheck[] = 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 398, 399, 400, - 401, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 411, 412, 413, 414, 415, 416, 417, -1, -1, -1, + -1, 382, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, + 401, 402, 403, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 413, 414, 415, 416, 417, 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 433, 434, 435, 436, 437, 438, 439, -1, - -1, -1, -1, -1, -1, -1, -1, 448, -1, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + -1, -1, -1, -1, 435, 436, 437, 438, 439, 440, + 441, -1, -1, -1, -1, -1, -1, -1, -1, 450, + -1, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, 486, 487, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, 378, 379, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, 378, 379, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - 377, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, 378, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, 336, 337, 338, -1, -1, -1, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - 377, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 382, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 384, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 400, 401, 402, 403, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 413, + 414, 415, 416, 417, 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, + -1, 435, 436, 437, 438, 439, 440, 441, -1, -1, + -1, -1, -1, -1, -1, -1, 450, -1, 452, 453, + 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, + 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, + 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, @@ -4313,7 +4157,7 @@ static const yytype_int16 yycheck[] = 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, @@ -4329,156 +4173,629 @@ static const yytype_int16 yycheck[] = 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, + 337, 338, -1, -1, -1, 342, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 379, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 400, 401, 402, 403, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 413, 414, 415, 416, + 417, 418, 419, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 435, 436, + 437, 438, 439, 440, 441, -1, -1, -1, -1, -1, + -1, -1, -1, 450, -1, 452, 453, 454, 455, 456, + 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, + 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, + 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, + -1, -1, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 380, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 400, 401, 402, 403, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 413, 414, 415, 416, 417, 418, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 435, 436, 437, 438, 439, + 440, 441, -1, -1, -1, -1, -1, -1, -1, -1, + 450, -1, 452, 453, 454, 455, 456, 457, 458, 459, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, + 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, -1, -1, -1, 342, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 380, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 400, 401, 402, + 403, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 413, 414, 415, 416, 417, 418, 419, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 435, 436, 437, 438, 439, 440, 441, -1, + -1, -1, -1, -1, -1, -1, -1, 450, -1, 452, + 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, + 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, + 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, -1, -1, -1, 342, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 400, 401, 402, 403, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 413, 414, 415, + 416, 417, 418, 419, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 435, + 436, 437, 438, 439, 440, 441, -1, -1, -1, -1, + -1, -1, -1, -1, 450, -1, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, + 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, -1, -1, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, -1, 183, -1, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, + -1, -1, -1, -1, -1, 345, -1, -1, -1, 349, + 350, 351, 352, -1, -1, 355, 356, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 374, 375, -1, -1, -1, 379, + 380, -1, -1, -1, -1, -1, -1, 387, 388, 389, + 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 408, 409, + 410, 411, 412, 413, -1, -1, -1, -1, 418, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, + -1, -1, 452, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 465, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, -1, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, -1, 183, -1, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, -1, -1, -1, -1, -1, 345, -1, -1, + -1, 349, 350, 351, 352, -1, -1, 355, 356, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 374, 375, -1, -1, + -1, 379, 380, -1, -1, -1, -1, -1, -1, 387, + 388, 389, 390, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 408, 409, 410, 411, 412, 413, -1, -1, -1, -1, + 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 442, 443, 444, 445, 446, 447, + 448, 449, -1, -1, 452, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 465, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, -1, 183, -1, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, -1, -1, -1, -1, -1, -1, 345, + -1, -1, -1, 349, 350, 351, 352, -1, -1, 355, + 356, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 374, 375, + -1, -1, 378, -1, -1, -1, -1, -1, -1, -1, + -1, 387, 388, 389, 390, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 408, 409, 410, 411, 412, 413, -1, -1, + -1, -1, 418, 419, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 442, 443, 444, 445, + 446, 447, 448, 449, -1, -1, 452, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 465, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, -1, 183, + -1, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, 336, 337, 338, -1, -1, -1, -1, -1, + -1, 345, -1, -1, -1, 349, 350, 351, 352, -1, + -1, 355, 356, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 374, 375, -1, -1, -1, 379, -1, -1, -1, -1, + -1, -1, -1, 387, 388, 389, 390, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 408, 409, 410, 411, 412, 413, + -1, -1, -1, -1, 418, 419, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 442, 443, + 444, 445, 446, 447, 448, 449, -1, -1, 452, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 465, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, + -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + -1, 183, -1, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, -1, -1, -1, + -1, -1, -1, 345, -1, -1, -1, 349, 350, 351, + 352, -1, -1, 355, 356, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 374, 375, -1, -1, 378, -1, -1, -1, + -1, -1, -1, -1, -1, 387, 388, 389, 390, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 408, 409, 410, 411, + 412, 413, -1, -1, -1, -1, 418, 419, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 442, 443, 444, 445, 446, 447, 448, 449, -1, -1, + 452, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 465, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, -1, -1, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, -1, 183, -1, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, 336, 337, 338, -1, + -1, -1, -1, -1, -1, 345, -1, -1, -1, 349, + 350, 351, 352, -1, -1, 355, 356, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 374, 375, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 386, 387, 388, 389, + 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 408, 409, + 410, 411, 412, 413, -1, -1, -1, -1, 418, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, + -1, -1, 452, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 465, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, -1, -1, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, -1, 183, -1, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, -1, -1, -1, -1, -1, -1, 345, -1, -1, + -1, 349, 350, 351, 352, -1, -1, 355, 356, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 374, 375, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 387, + 388, 389, 390, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 408, 409, 410, 411, 412, 413, -1, -1, -1, -1, + 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 442, 443, 444, 445, 446, 447, + 448, 449, -1, -1, 452, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 465, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, -1, 183, -1, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, -1, -1, -1, -1, -1, -1, 345, + -1, -1, -1, 349, 350, 351, 352, -1, -1, 355, + 356, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 374, 375, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 387, 388, 389, 390, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 408, 409, 410, 411, 412, 413, -1, -1, + -1, -1, 418, 419, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 442, 443, 444, 445, + 446, 447, 448, 449, -1, -1, 452, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 465, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, -1, 183, + -1, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, 336, 337, 338, -1, -1, -1, -1, -1, + -1, 345, -1, -1, -1, 349, 350, 351, 352, -1, + -1, 355, 356, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, + 374, 375, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 387, 388, 389, 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 408, 409, 410, 411, 412, 413, + -1, -1, -1, -1, 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, 354, 355, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 442, 443, + 444, 445, 446, 447, 448, 449, -1, -1, 452, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 373, 374, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 385, 386, - 387, 388, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 406, - 407, 408, 409, 410, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 465, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, + -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, + -1, 183, -1, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, 336, 337, 338, -1, -1, -1, + -1, -1, -1, 345, -1, -1, -1, 349, 350, 351, + 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 440, 441, 442, 443, 444, 445, 446, - 447, -1, -1, 450, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 463, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, -1, 183, -1, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, 349, 350, 351, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 413, -1, -1, -1, -1, 418, 419, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 411, -1, -1, -1, -1, 416, - 417, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 450 + 452 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -4520,149 +4837,151 @@ static const yytype_int16 yystos[] = 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, - 376, 384, 398, 399, 400, 401, 402, 411, 412, 413, - 414, 415, 416, 417, 433, 434, 435, 436, 437, 438, - 439, 448, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 519, 520, 523, 524, 525, 526, 530, 531, 532, 533, - 534, 535, 538, 539, 540, 541, 542, 544, 549, 550, - 551, 596, 597, 598, 600, 607, 611, 612, 618, 621, - 374, 374, 374, 374, 374, 374, 374, 374, 376, 550, - 378, 410, 374, 374, 384, 410, 384, 599, 375, 381, - 527, 528, 529, 539, 544, 381, 384, 410, 384, 410, - 522, 540, 544, 392, 546, 547, 0, 597, 524, 532, - 539, 384, 523, 410, 603, 604, 622, 623, 407, 410, - 603, 407, 603, 407, 603, 407, 603, 407, 603, 603, - 622, 407, 603, 410, 601, 602, 544, 553, 378, 410, - 434, 536, 537, 410, 543, 376, 384, 545, 378, 575, - 600, 380, 528, 527, 529, 410, 410, 374, 383, 545, - 378, 381, 384, 354, 355, 373, 374, 385, 386, 387, - 388, 406, 407, 408, 409, 410, 440, 441, 442, 443, - 444, 445, 446, 447, 489, 490, 491, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 542, 544, 548, 545, - 375, 410, 384, 383, 381, 375, 381, 375, 381, 383, - 381, 381, 381, 375, 381, 381, 381, 381, 381, 381, - 381, 375, 381, 375, 381, 374, 377, 381, 384, 539, - 544, 554, 555, 556, 558, 559, 552, 383, 375, 381, - 375, 381, 377, 500, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 544, 376, 384, 378, - 379, 384, 418, 419, 420, 421, 423, 424, 425, 426, - 427, 428, 429, 430, 431, 432, 449, 500, 513, 515, - 517, 519, 523, 542, 544, 564, 565, 566, 567, 568, - 576, 577, 578, 579, 582, 583, 586, 587, 588, 595, - 600, 380, 383, 545, 383, 545, 378, 515, 562, 383, - 521, 410, 500, 500, 517, 549, 354, 355, 376, 380, - 375, 375, 381, 417, 515, 374, 500, 381, 393, 600, - 373, 376, 407, 604, 622, 410, 623, 373, 406, 407, - 408, 409, 608, 609, 407, 513, 518, 610, 407, 406, - 407, 408, 409, 613, 614, 407, 406, 407, 408, 409, - 489, 615, 616, 407, 373, 617, 407, 622, 410, 518, - 549, 619, 620, 407, 518, 377, 602, 378, 544, 410, - 560, 561, 379, 539, 558, 560, 555, 559, 554, 518, - 537, 410, 389, 390, 391, 386, 388, 352, 353, 356, - 357, 392, 393, 358, 359, 396, 395, 394, 360, 362, - 361, 397, 377, 377, 513, 379, 569, 374, 384, 384, - 590, 374, 374, 384, 384, 517, 374, 517, 382, 384, - 384, 384, 384, 363, 364, 365, 366, 367, 368, 369, - 370, 371, 372, 383, 516, 381, 384, 379, 565, 579, - 583, 588, 380, 562, 562, 383, 379, 562, 563, 562, - 558, 375, 375, 492, 517, 410, 515, 500, 373, 407, - 605, 606, 375, 383, 375, 381, 375, 381, 375, 381, - 381, 375, 381, 375, 381, 375, 381, 381, 375, 381, - 381, 375, 381, 375, 381, 375, 375, 557, 560, 545, - 381, 384, 384, 379, 500, 500, 500, 502, 502, 503, - 503, 504, 504, 504, 504, 505, 505, 506, 507, 508, - 509, 510, 511, 514, 377, 576, 589, 565, 591, 517, - 384, 517, 382, 515, 515, 562, 379, 381, 379, 500, - 377, 377, 381, 377, 381, 609, 608, 518, 610, 614, - 613, 616, 615, 373, 617, 619, 620, 558, 384, 561, - 517, 570, 517, 532, 581, 418, 564, 577, 592, 375, - 375, 379, 562, 373, 407, 375, 375, 375, 375, 375, - 375, 379, 382, 379, 410, 375, 374, 581, 593, 594, - 572, 573, 574, 580, 584, 515, 383, 566, 571, 575, - 517, 384, 375, 422, 568, 566, 378, 562, 375, 517, - 571, 572, 576, 585, 384, 379 + 352, 377, 386, 400, 401, 402, 403, 404, 413, 414, + 415, 416, 417, 418, 419, 435, 436, 437, 438, 439, + 440, 441, 450, 452, 453, 454, 455, 456, 457, 458, + 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, + 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, + 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 521, 522, 525, 527, 528, 529, 533, 534, 535, + 536, 537, 538, 541, 542, 543, 544, 545, 547, 552, + 553, 554, 599, 600, 601, 603, 610, 614, 615, 621, + 624, 375, 375, 375, 375, 375, 375, 375, 375, 377, + 553, 379, 412, 375, 375, 386, 412, 386, 602, 376, + 383, 382, 530, 531, 532, 542, 547, 383, 386, 412, + 386, 412, 524, 543, 547, 394, 549, 550, 0, 600, + 527, 528, 529, 535, 542, 386, 525, 526, 528, 529, + 412, 606, 607, 625, 626, 409, 412, 606, 409, 606, + 409, 606, 409, 606, 409, 606, 606, 625, 409, 606, + 412, 604, 605, 547, 556, 379, 412, 436, 539, 540, + 412, 546, 377, 386, 548, 379, 578, 603, 382, 531, + 376, 530, 532, 412, 412, 375, 385, 548, 379, 383, + 386, 355, 356, 374, 375, 387, 388, 389, 390, 408, + 409, 410, 411, 412, 442, 443, 444, 445, 446, 447, + 448, 449, 491, 492, 493, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 545, 547, 551, 548, 376, 383, + 412, 386, 386, 383, 347, 348, 385, 383, 376, 383, + 376, 383, 385, 383, 383, 383, 376, 383, 383, 383, + 383, 383, 383, 383, 376, 383, 376, 383, 375, 378, + 383, 386, 542, 547, 557, 558, 559, 561, 562, 555, + 385, 376, 383, 376, 383, 378, 502, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 547, + 377, 386, 379, 380, 386, 420, 421, 422, 423, 425, + 426, 427, 428, 429, 430, 431, 432, 433, 434, 451, + 502, 515, 517, 519, 521, 525, 545, 547, 567, 568, + 569, 570, 571, 579, 580, 581, 582, 585, 586, 589, + 590, 591, 598, 603, 376, 385, 548, 385, 548, 379, + 517, 565, 385, 523, 412, 502, 502, 519, 552, 355, + 356, 377, 381, 376, 376, 383, 419, 517, 375, 502, + 383, 395, 603, 347, 348, 382, 382, 374, 377, 409, + 607, 625, 412, 626, 374, 408, 409, 410, 411, 611, + 612, 409, 515, 520, 613, 409, 408, 409, 410, 411, + 616, 617, 409, 408, 409, 410, 411, 491, 618, 619, + 409, 374, 620, 409, 625, 412, 520, 552, 622, 623, + 409, 520, 378, 605, 379, 547, 412, 563, 564, 380, + 542, 561, 563, 558, 562, 557, 520, 540, 412, 391, + 392, 393, 388, 390, 353, 354, 357, 358, 394, 395, + 359, 360, 398, 397, 396, 361, 363, 362, 399, 378, + 378, 515, 380, 572, 375, 386, 386, 593, 375, 375, + 386, 386, 519, 375, 519, 384, 386, 386, 386, 386, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 385, 518, 383, 386, 380, 568, 582, 586, 591, 565, + 565, 385, 380, 565, 566, 565, 561, 376, 376, 494, + 519, 412, 517, 502, 382, 382, 376, 376, 374, 409, + 608, 609, 376, 385, 376, 383, 376, 383, 376, 383, + 383, 376, 383, 376, 383, 376, 383, 383, 376, 383, + 383, 376, 383, 376, 383, 376, 376, 560, 563, 548, + 383, 386, 386, 380, 502, 502, 502, 504, 504, 505, + 505, 506, 506, 506, 506, 507, 507, 508, 509, 510, + 511, 512, 513, 516, 378, 579, 592, 568, 594, 519, + 386, 519, 384, 517, 517, 565, 380, 383, 380, 502, + 378, 376, 376, 378, 383, 378, 383, 612, 611, 520, + 613, 617, 616, 619, 618, 374, 620, 622, 623, 561, + 386, 564, 519, 573, 519, 535, 584, 420, 567, 580, + 595, 376, 376, 380, 565, 374, 409, 376, 376, 376, + 376, 376, 376, 380, 384, 380, 412, 376, 375, 584, + 596, 597, 575, 576, 577, 583, 587, 517, 385, 569, + 574, 578, 519, 386, 376, 424, 571, 569, 379, 565, + 376, 519, 574, 575, 579, 588, 386, 380 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_int16 yyr1[] = { - 0, 488, 489, 490, 490, 490, 490, 490, 490, 490, - 490, 490, 490, 490, 490, 490, 490, 490, 491, 491, - 491, 491, 491, 491, 492, 493, 494, 495, 495, 496, - 496, 497, 497, 498, 499, 499, 499, 500, 500, 500, - 500, 500, 501, 501, 501, 501, 502, 502, 502, 502, - 503, 503, 503, 504, 504, 504, 505, 505, 505, 505, - 505, 506, 506, 506, 507, 507, 508, 508, 509, 509, - 510, 510, 511, 511, 512, 512, 513, 514, 513, 515, - 515, 516, 516, 516, 516, 516, 516, 516, 516, 516, - 516, 516, 517, 517, 518, 519, 519, 519, 519, 519, - 519, 519, 519, 519, 519, 521, 520, 522, 522, 523, - 523, 523, 523, 524, 524, 525, 525, 525, 526, 527, - 527, 527, 528, 528, 528, 528, 529, 530, 530, 530, - 530, 530, 531, 531, 531, 531, 531, 532, 532, 533, - 534, 534, 534, 534, 534, 534, 534, 534, 534, 534, - 535, 536, 536, 537, 537, 537, 538, 539, 539, 540, - 540, 540, 540, 540, 540, 540, 540, 540, 540, 540, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 541, 541, 542, 543, 543, 544, 544, 545, 545, 545, - 545, 546, 546, 547, 548, 548, 548, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, - 549, 549, 549, 549, 549, 549, 550, 550, 550, 552, - 551, 553, 551, 554, 554, 554, 554, 555, 557, 556, - 558, 558, 559, 559, 560, 560, 561, 561, 562, 562, - 562, 562, 563, 563, 564, 565, 565, 566, 566, 566, - 566, 566, 566, 566, 566, 567, 568, 569, 570, 568, - 571, 571, 573, 572, 574, 572, 575, 575, 576, 576, - 577, 577, 578, 578, 579, 580, 580, 581, 581, 582, - 582, 584, 583, 585, 585, 586, 586, 587, 587, 589, - 588, 590, 588, 591, 588, 592, 592, 593, 593, 594, - 594, 595, 595, 595, 595, 595, 595, 595, 595, 596, - 596, 597, 597, 597, 599, 598, 600, 601, 601, 602, - 602, 603, 603, 604, 604, 605, 605, 606, 606, 607, - 607, 607, 607, 607, 607, 608, 608, 609, 609, 609, - 609, 609, 610, 610, 611, 611, 612, 612, 612, 612, - 612, 612, 612, 612, 613, 613, 614, 614, 614, 614, - 615, 615, 616, 616, 616, 616, 616, 617, 617, 618, - 618, 618, 618, 619, 619, 620, 620, 621, 621, 622, - 622, 623, 623 + 0, 490, 491, 492, 492, 492, 492, 492, 492, 492, + 492, 492, 492, 492, 492, 492, 492, 492, 493, 493, + 493, 493, 493, 493, 494, 495, 496, 497, 497, 498, + 498, 499, 499, 500, 501, 501, 501, 502, 502, 502, + 502, 502, 503, 503, 503, 503, 504, 504, 504, 504, + 505, 505, 505, 506, 506, 506, 507, 507, 507, 507, + 507, 508, 508, 508, 509, 509, 510, 510, 511, 511, + 512, 512, 513, 513, 514, 514, 515, 516, 515, 517, + 517, 518, 518, 518, 518, 518, 518, 518, 518, 518, + 518, 518, 519, 519, 520, 521, 521, 521, 521, 521, + 521, 521, 521, 521, 521, 521, 523, 522, 524, 524, + 525, 525, 525, 525, 525, 525, 526, 526, 526, 526, + 527, 527, 528, 528, 529, 530, 530, 530, 531, 531, + 531, 531, 532, 533, 533, 533, 533, 533, 534, 534, + 534, 534, 534, 535, 535, 536, 537, 537, 537, 537, + 537, 537, 537, 537, 537, 537, 538, 539, 539, 540, + 540, 540, 541, 542, 542, 543, 543, 543, 543, 543, + 543, 543, 543, 543, 543, 543, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 545, 546, + 546, 547, 547, 548, 548, 548, 548, 549, 549, 550, + 551, 551, 551, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, + 552, 552, 552, 553, 553, 553, 555, 554, 556, 554, + 557, 557, 557, 557, 558, 560, 559, 561, 561, 562, + 562, 563, 563, 564, 564, 565, 565, 565, 565, 566, + 566, 567, 568, 568, 569, 569, 569, 569, 569, 569, + 569, 569, 570, 571, 572, 573, 571, 574, 574, 576, + 575, 577, 575, 578, 578, 579, 579, 580, 580, 581, + 581, 582, 583, 583, 584, 584, 585, 585, 587, 586, + 588, 588, 589, 589, 590, 590, 592, 591, 593, 591, + 594, 591, 595, 595, 596, 596, 597, 597, 598, 598, + 598, 598, 598, 598, 598, 598, 599, 599, 600, 600, + 600, 602, 601, 603, 604, 604, 605, 605, 606, 606, + 607, 607, 608, 608, 609, 609, 610, 610, 610, 610, + 610, 610, 611, 611, 612, 612, 612, 612, 612, 613, + 613, 614, 614, 615, 615, 615, 615, 615, 615, 615, + 615, 616, 616, 617, 617, 617, 617, 618, 618, 619, + 619, 619, 619, 619, 620, 620, 621, 621, 621, 621, + 622, 622, 623, 623, 624, 624, 625, 625, 626, 626 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -4677,20 +4996,22 @@ static const yytype_int8 yyr2[] = 3, 1, 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 0, 6, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 1, 2, 3, 2, 2, 4, - 2, 3, 4, 2, 3, 0, 6, 1, 3, 2, - 3, 3, 4, 1, 1, 2, 3, 5, 3, 2, - 3, 4, 2, 1, 2, 1, 1, 1, 3, 4, - 6, 5, 1, 2, 3, 5, 4, 1, 2, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 4, 1, 3, 1, 3, 1, 1, 1, 2, 1, + 1, 1, 1, 3, 1, 2, 3, 3, 2, 2, + 4, 2, 3, 4, 2, 3, 0, 6, 1, 3, + 2, 3, 3, 4, 3, 4, 4, 4, 5, 5, + 1, 1, 2, 3, 3, 2, 3, 4, 2, 1, + 2, 1, 1, 1, 3, 4, 6, 5, 1, 2, + 3, 5, 4, 1, 2, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 1, 3, 1, + 3, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, + 3, 2, 3, 2, 3, 3, 4, 1, 0, 3, + 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 4, 1, 1, 1, 3, 2, 3, 2, 3, 3, - 4, 1, 0, 3, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -4723,25 +5044,23 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, - 6, 0, 5, 1, 1, 2, 2, 3, 0, 5, - 1, 2, 3, 4, 1, 3, 1, 2, 1, 3, - 4, 2, 1, 3, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 2, 2, 0, 0, 5, - 1, 1, 0, 2, 0, 2, 2, 3, 1, 2, - 1, 2, 1, 2, 5, 3, 1, 1, 4, 1, - 2, 0, 8, 0, 1, 3, 2, 1, 2, 0, - 6, 0, 8, 0, 7, 1, 1, 1, 0, 2, - 3, 2, 2, 2, 3, 2, 2, 2, 2, 1, - 2, 1, 1, 1, 0, 3, 5, 1, 3, 1, - 4, 1, 3, 5, 5, 1, 3, 1, 3, 4, - 6, 6, 8, 6, 8, 1, 3, 1, 1, 1, - 1, 1, 1, 3, 4, 6, 4, 6, 6, 8, - 6, 8, 6, 8, 1, 3, 1, 1, 1, 1, - 1, 3, 1, 1, 1, 1, 1, 1, 3, 6, - 8, 4, 6, 1, 3, 1, 1, 4, 6, 1, - 3, 3, 3 + 1, 1, 1, 1, 1, 1, 0, 6, 0, 5, + 1, 1, 2, 2, 3, 0, 5, 1, 2, 3, + 4, 1, 3, 1, 2, 1, 3, 4, 2, 1, + 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 2, 0, 0, 5, 1, 1, 0, + 2, 0, 2, 2, 3, 1, 2, 1, 2, 1, + 2, 5, 3, 1, 1, 4, 1, 2, 0, 8, + 0, 1, 3, 2, 1, 2, 0, 6, 0, 8, + 0, 7, 1, 1, 1, 0, 2, 3, 2, 2, + 2, 3, 2, 2, 2, 2, 1, 2, 1, 1, + 1, 0, 3, 5, 1, 3, 1, 4, 1, 3, + 5, 5, 1, 3, 1, 3, 4, 6, 6, 8, + 6, 8, 1, 3, 1, 1, 1, 1, 1, 1, + 3, 4, 6, 4, 6, 6, 8, 6, 8, 6, + 8, 1, 3, 1, 1, 1, 1, 1, 3, 1, + 1, 1, 1, 1, 1, 3, 6, 8, 4, 6, + 1, 3, 1, 1, 4, 6, 1, 3, 3, 3 }; @@ -5238,7 +5557,7 @@ YY_INITIAL_VALUE (static YYSTYPE yyval_default;) YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); /* Number of syntax errors so far. */ - int yynerrs = 0; + int yynerrs YY_ATTRIBUTE_UNUSED = 0; yy_state_fast_t yystate = 0; /* Number of tokens to shift before error messages enabled. */ @@ -5483,260 +5802,260 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); switch (yyn) { case 2: /* variable_identifier: IDENTIFIER */ -#line 365 "MachineIndependent/glslang.y" +#line 366 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 5491 "MachineIndependent/glslang_tab.cpp" +#line 5810 "MachineIndependent/glslang_tab.cpp" break; case 3: /* primary_expression: variable_identifier */ -#line 371 "MachineIndependent/glslang.y" +#line 372 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5499 "MachineIndependent/glslang_tab.cpp" +#line 5818 "MachineIndependent/glslang_tab.cpp" break; case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN */ -#line 374 "MachineIndependent/glslang.y" +#line 375 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 5509 "MachineIndependent/glslang_tab.cpp" +#line 5828 "MachineIndependent/glslang_tab.cpp" break; case 5: /* primary_expression: FLOATCONSTANT */ -#line 379 "MachineIndependent/glslang.y" +#line 380 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 5517 "MachineIndependent/glslang_tab.cpp" +#line 5836 "MachineIndependent/glslang_tab.cpp" break; case 6: /* primary_expression: INTCONSTANT */ -#line 382 "MachineIndependent/glslang.y" +#line 383 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5525 "MachineIndependent/glslang_tab.cpp" +#line 5844 "MachineIndependent/glslang_tab.cpp" break; case 7: /* primary_expression: UINTCONSTANT */ -#line 385 "MachineIndependent/glslang.y" +#line 386 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5534 "MachineIndependent/glslang_tab.cpp" +#line 5853 "MachineIndependent/glslang_tab.cpp" break; case 8: /* primary_expression: BOOLCONSTANT */ -#line 389 "MachineIndependent/glslang.y" +#line 390 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 5542 "MachineIndependent/glslang_tab.cpp" +#line 5861 "MachineIndependent/glslang_tab.cpp" break; case 9: /* primary_expression: STRING_LITERAL */ -#line 392 "MachineIndependent/glslang.y" +#line 393 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 5550 "MachineIndependent/glslang_tab.cpp" +#line 5869 "MachineIndependent/glslang_tab.cpp" break; case 10: /* primary_expression: INT32CONSTANT */ -#line 395 "MachineIndependent/glslang.y" +#line 396 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5559 "MachineIndependent/glslang_tab.cpp" +#line 5878 "MachineIndependent/glslang_tab.cpp" break; case 11: /* primary_expression: UINT32CONSTANT */ -#line 399 "MachineIndependent/glslang.y" +#line 400 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5568 "MachineIndependent/glslang_tab.cpp" +#line 5887 "MachineIndependent/glslang_tab.cpp" break; case 12: /* primary_expression: INT64CONSTANT */ -#line 403 "MachineIndependent/glslang.y" +#line 404 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 5577 "MachineIndependent/glslang_tab.cpp" +#line 5896 "MachineIndependent/glslang_tab.cpp" break; case 13: /* primary_expression: UINT64CONSTANT */ -#line 407 "MachineIndependent/glslang.y" +#line 408 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 5586 "MachineIndependent/glslang_tab.cpp" +#line 5905 "MachineIndependent/glslang_tab.cpp" break; case 14: /* primary_expression: INT16CONSTANT */ -#line 411 "MachineIndependent/glslang.y" +#line 412 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5595 "MachineIndependent/glslang_tab.cpp" +#line 5914 "MachineIndependent/glslang_tab.cpp" break; case 15: /* primary_expression: UINT16CONSTANT */ -#line 415 "MachineIndependent/glslang.y" +#line 416 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5604 "MachineIndependent/glslang_tab.cpp" +#line 5923 "MachineIndependent/glslang_tab.cpp" break; case 16: /* primary_expression: DOUBLECONSTANT */ -#line 419 "MachineIndependent/glslang.y" +#line 420 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); } -#line 5615 "MachineIndependent/glslang_tab.cpp" +#line 5934 "MachineIndependent/glslang_tab.cpp" break; case 17: /* primary_expression: FLOAT16CONSTANT */ -#line 425 "MachineIndependent/glslang.y" +#line 426 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 5624 "MachineIndependent/glslang_tab.cpp" +#line 5943 "MachineIndependent/glslang_tab.cpp" break; case 18: /* postfix_expression: primary_expression */ -#line 432 "MachineIndependent/glslang.y" +#line 433 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5632 "MachineIndependent/glslang_tab.cpp" +#line 5951 "MachineIndependent/glslang_tab.cpp" break; case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET */ -#line 435 "MachineIndependent/glslang.y" +#line 436 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 5640 "MachineIndependent/glslang_tab.cpp" +#line 5959 "MachineIndependent/glslang_tab.cpp" break; case 20: /* postfix_expression: function_call */ -#line 438 "MachineIndependent/glslang.y" +#line 439 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5648 "MachineIndependent/glslang_tab.cpp" +#line 5967 "MachineIndependent/glslang_tab.cpp" break; case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER */ -#line 441 "MachineIndependent/glslang.y" +#line 442 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 5656 "MachineIndependent/glslang_tab.cpp" +#line 5975 "MachineIndependent/glslang_tab.cpp" break; case 22: /* postfix_expression: postfix_expression INC_OP */ -#line 444 "MachineIndependent/glslang.y" +#line 445 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5666 "MachineIndependent/glslang_tab.cpp" +#line 5985 "MachineIndependent/glslang_tab.cpp" break; case 23: /* postfix_expression: postfix_expression DEC_OP */ -#line 449 "MachineIndependent/glslang.y" +#line 450 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5676 "MachineIndependent/glslang_tab.cpp" +#line 5995 "MachineIndependent/glslang_tab.cpp" break; case 24: /* integer_expression: expression */ -#line 457 "MachineIndependent/glslang.y" +#line 458 "MachineIndependent/glslang.y" { parseContext.arrayIndexCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5685 "MachineIndependent/glslang_tab.cpp" +#line 6004 "MachineIndependent/glslang_tab.cpp" break; case 25: /* function_call: function_call_or_method */ -#line 464 "MachineIndependent/glslang.y" +#line 465 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 5694 "MachineIndependent/glslang_tab.cpp" +#line 6013 "MachineIndependent/glslang_tab.cpp" break; case 26: /* function_call_or_method: function_call_generic */ -#line 471 "MachineIndependent/glslang.y" +#line 472 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5702 "MachineIndependent/glslang_tab.cpp" +#line 6021 "MachineIndependent/glslang_tab.cpp" break; case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN */ -#line 477 "MachineIndependent/glslang.y" +#line 478 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5711 "MachineIndependent/glslang_tab.cpp" +#line 6030 "MachineIndependent/glslang_tab.cpp" break; case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN */ -#line 481 "MachineIndependent/glslang.y" +#line 482 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5720 "MachineIndependent/glslang_tab.cpp" +#line 6039 "MachineIndependent/glslang_tab.cpp" break; case 29: /* function_call_header_no_parameters: function_call_header VOID */ -#line 488 "MachineIndependent/glslang.y" +#line 489 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5728 "MachineIndependent/glslang_tab.cpp" +#line 6047 "MachineIndependent/glslang_tab.cpp" break; case 30: /* function_call_header_no_parameters: function_call_header */ -#line 491 "MachineIndependent/glslang.y" +#line 492 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5736 "MachineIndependent/glslang_tab.cpp" +#line 6055 "MachineIndependent/glslang_tab.cpp" break; case 31: /* function_call_header_with_parameters: function_call_header assignment_expression */ -#line 497 "MachineIndependent/glslang.y" +#line 498 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5755,11 +6074,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } } -#line 5759 "MachineIndependent/glslang_tab.cpp" +#line 6078 "MachineIndependent/glslang_tab.cpp" break; case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression */ -#line 515 "MachineIndependent/glslang.y" +#line 516 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5782,29 +6101,29 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } } -#line 5786 "MachineIndependent/glslang_tab.cpp" +#line 6105 "MachineIndependent/glslang_tab.cpp" break; case 33: /* function_call_header: function_identifier LEFT_PAREN */ -#line 540 "MachineIndependent/glslang.y" +#line 541 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5794 "MachineIndependent/glslang_tab.cpp" +#line 6113 "MachineIndependent/glslang_tab.cpp" break; case 34: /* function_identifier: type_specifier */ -#line 548 "MachineIndependent/glslang.y" +#line 549 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5804 "MachineIndependent/glslang_tab.cpp" +#line 6123 "MachineIndependent/glslang_tab.cpp" break; case 35: /* function_identifier: postfix_expression */ -#line 553 "MachineIndependent/glslang.y" +#line 554 "MachineIndependent/glslang.y" { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -5832,50 +6151,50 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 5836 "MachineIndependent/glslang_tab.cpp" +#line 6155 "MachineIndependent/glslang_tab.cpp" break; case 36: /* function_identifier: non_uniform_qualifier */ -#line 580 "MachineIndependent/glslang.y" +#line 581 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5846 "MachineIndependent/glslang_tab.cpp" +#line 6165 "MachineIndependent/glslang_tab.cpp" break; case 37: /* unary_expression: postfix_expression */ -#line 588 "MachineIndependent/glslang.y" +#line 589 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 5857 "MachineIndependent/glslang_tab.cpp" +#line 6176 "MachineIndependent/glslang_tab.cpp" break; case 38: /* unary_expression: INC_OP unary_expression */ -#line 594 "MachineIndependent/glslang.y" +#line 595 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5866 "MachineIndependent/glslang_tab.cpp" +#line 6185 "MachineIndependent/glslang_tab.cpp" break; case 39: /* unary_expression: DEC_OP unary_expression */ -#line 598 "MachineIndependent/glslang.y" +#line 599 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5875 "MachineIndependent/glslang_tab.cpp" +#line 6194 "MachineIndependent/glslang_tab.cpp" break; case 40: /* unary_expression: unary_operator unary_expression */ -#line 602 "MachineIndependent/glslang.y" +#line 603 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -5892,187 +6211,187 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 5896 "MachineIndependent/glslang_tab.cpp" +#line 6215 "MachineIndependent/glslang_tab.cpp" break; case 41: /* unary_expression: LEFT_PAREN type_specifier_nonarray RIGHT_PAREN unary_expression */ -#line 618 "MachineIndependent/glslang.y" +#line 619 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleTypeCast((yyvsp[-3].lex).loc, new TType((yyvsp[-2].interm.type)), (yyvsp[0].interm.intermTypedNode)); } -#line 5904 "MachineIndependent/glslang_tab.cpp" +#line 6223 "MachineIndependent/glslang_tab.cpp" break; case 42: /* unary_operator: PLUS */ -#line 625 "MachineIndependent/glslang.y" +#line 626 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 5910 "MachineIndependent/glslang_tab.cpp" +#line 6229 "MachineIndependent/glslang_tab.cpp" break; case 43: /* unary_operator: DASH */ -#line 626 "MachineIndependent/glslang.y" +#line 627 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 5916 "MachineIndependent/glslang_tab.cpp" +#line 6235 "MachineIndependent/glslang_tab.cpp" break; case 44: /* unary_operator: BANG */ -#line 627 "MachineIndependent/glslang.y" +#line 628 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 5922 "MachineIndependent/glslang_tab.cpp" +#line 6241 "MachineIndependent/glslang_tab.cpp" break; case 45: /* unary_operator: TILDE */ -#line 628 "MachineIndependent/glslang.y" +#line 629 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } -#line 5929 "MachineIndependent/glslang_tab.cpp" +#line 6248 "MachineIndependent/glslang_tab.cpp" break; case 46: /* multiplicative_expression: unary_expression */ -#line 634 "MachineIndependent/glslang.y" +#line 635 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5935 "MachineIndependent/glslang_tab.cpp" +#line 6254 "MachineIndependent/glslang_tab.cpp" break; case 47: /* multiplicative_expression: multiplicative_expression STAR unary_expression */ -#line 635 "MachineIndependent/glslang.y" +#line 636 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5945 "MachineIndependent/glslang_tab.cpp" +#line 6264 "MachineIndependent/glslang_tab.cpp" break; case 48: /* multiplicative_expression: multiplicative_expression SLASH unary_expression */ -#line 640 "MachineIndependent/glslang.y" +#line 641 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5955 "MachineIndependent/glslang_tab.cpp" +#line 6274 "MachineIndependent/glslang_tab.cpp" break; case 49: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression */ -#line 645 "MachineIndependent/glslang.y" +#line 646 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5966 "MachineIndependent/glslang_tab.cpp" +#line 6285 "MachineIndependent/glslang_tab.cpp" break; case 50: /* additive_expression: multiplicative_expression */ -#line 654 "MachineIndependent/glslang.y" +#line 655 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5972 "MachineIndependent/glslang_tab.cpp" +#line 6291 "MachineIndependent/glslang_tab.cpp" break; case 51: /* additive_expression: additive_expression PLUS multiplicative_expression */ -#line 655 "MachineIndependent/glslang.y" +#line 656 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5982 "MachineIndependent/glslang_tab.cpp" +#line 6301 "MachineIndependent/glslang_tab.cpp" break; case 52: /* additive_expression: additive_expression DASH multiplicative_expression */ -#line 660 "MachineIndependent/glslang.y" +#line 661 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5992 "MachineIndependent/glslang_tab.cpp" +#line 6311 "MachineIndependent/glslang_tab.cpp" break; case 53: /* shift_expression: additive_expression */ -#line 668 "MachineIndependent/glslang.y" +#line 669 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5998 "MachineIndependent/glslang_tab.cpp" +#line 6317 "MachineIndependent/glslang_tab.cpp" break; case 54: /* shift_expression: shift_expression LEFT_OP additive_expression */ -#line 669 "MachineIndependent/glslang.y" +#line 670 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 6009 "MachineIndependent/glslang_tab.cpp" +#line 6328 "MachineIndependent/glslang_tab.cpp" break; case 55: /* shift_expression: shift_expression RIGHT_OP additive_expression */ -#line 675 "MachineIndependent/glslang.y" +#line 676 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 6020 "MachineIndependent/glslang_tab.cpp" +#line 6339 "MachineIndependent/glslang_tab.cpp" break; case 56: /* relational_expression: shift_expression */ -#line 684 "MachineIndependent/glslang.y" +#line 685 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6026 "MachineIndependent/glslang_tab.cpp" +#line 6345 "MachineIndependent/glslang_tab.cpp" break; case 57: /* relational_expression: relational_expression LEFT_ANGLE shift_expression */ -#line 685 "MachineIndependent/glslang.y" +#line 686 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6036 "MachineIndependent/glslang_tab.cpp" +#line 6355 "MachineIndependent/glslang_tab.cpp" break; case 58: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression */ -#line 690 "MachineIndependent/glslang.y" +#line 691 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6046 "MachineIndependent/glslang_tab.cpp" +#line 6365 "MachineIndependent/glslang_tab.cpp" break; case 59: /* relational_expression: relational_expression LE_OP shift_expression */ -#line 695 "MachineIndependent/glslang.y" +#line 696 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6056 "MachineIndependent/glslang_tab.cpp" +#line 6375 "MachineIndependent/glslang_tab.cpp" break; case 60: /* relational_expression: relational_expression GE_OP shift_expression */ -#line 700 "MachineIndependent/glslang.y" +#line 701 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6066 "MachineIndependent/glslang_tab.cpp" +#line 6385 "MachineIndependent/glslang_tab.cpp" break; case 61: /* equality_expression: relational_expression */ -#line 708 "MachineIndependent/glslang.y" +#line 709 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6072 "MachineIndependent/glslang_tab.cpp" +#line 6391 "MachineIndependent/glslang_tab.cpp" break; case 62: /* equality_expression: equality_expression EQ_OP relational_expression */ -#line 709 "MachineIndependent/glslang.y" +#line 710 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); @@ -6082,11 +6401,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6086 "MachineIndependent/glslang_tab.cpp" +#line 6405 "MachineIndependent/glslang_tab.cpp" break; case 63: /* equality_expression: equality_expression NE_OP relational_expression */ -#line 718 "MachineIndependent/glslang.y" +#line 719 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -6096,124 +6415,124 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6100 "MachineIndependent/glslang_tab.cpp" +#line 6419 "MachineIndependent/glslang_tab.cpp" break; case 64: /* and_expression: equality_expression */ -#line 730 "MachineIndependent/glslang.y" +#line 731 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6106 "MachineIndependent/glslang_tab.cpp" +#line 6425 "MachineIndependent/glslang_tab.cpp" break; case 65: /* and_expression: and_expression AMPERSAND equality_expression */ -#line 731 "MachineIndependent/glslang.y" +#line 732 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 6117 "MachineIndependent/glslang_tab.cpp" +#line 6436 "MachineIndependent/glslang_tab.cpp" break; case 66: /* exclusive_or_expression: and_expression */ -#line 740 "MachineIndependent/glslang.y" +#line 741 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6123 "MachineIndependent/glslang_tab.cpp" +#line 6442 "MachineIndependent/glslang_tab.cpp" break; case 67: /* exclusive_or_expression: exclusive_or_expression CARET and_expression */ -#line 741 "MachineIndependent/glslang.y" +#line 742 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 6134 "MachineIndependent/glslang_tab.cpp" +#line 6453 "MachineIndependent/glslang_tab.cpp" break; case 68: /* inclusive_or_expression: exclusive_or_expression */ -#line 750 "MachineIndependent/glslang.y" +#line 751 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6140 "MachineIndependent/glslang_tab.cpp" +#line 6459 "MachineIndependent/glslang_tab.cpp" break; case 69: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression */ -#line 751 "MachineIndependent/glslang.y" +#line 752 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 6151 "MachineIndependent/glslang_tab.cpp" +#line 6470 "MachineIndependent/glslang_tab.cpp" break; case 70: /* logical_and_expression: inclusive_or_expression */ -#line 760 "MachineIndependent/glslang.y" +#line 761 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6157 "MachineIndependent/glslang_tab.cpp" +#line 6476 "MachineIndependent/glslang_tab.cpp" break; case 71: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression */ -#line 761 "MachineIndependent/glslang.y" +#line 762 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6167 "MachineIndependent/glslang_tab.cpp" +#line 6486 "MachineIndependent/glslang_tab.cpp" break; case 72: /* logical_xor_expression: logical_and_expression */ -#line 769 "MachineIndependent/glslang.y" +#line 770 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6173 "MachineIndependent/glslang_tab.cpp" +#line 6492 "MachineIndependent/glslang_tab.cpp" break; case 73: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression */ -#line 770 "MachineIndependent/glslang.y" +#line 771 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6183 "MachineIndependent/glslang_tab.cpp" +#line 6502 "MachineIndependent/glslang_tab.cpp" break; case 74: /* logical_or_expression: logical_xor_expression */ -#line 778 "MachineIndependent/glslang.y" +#line 779 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6189 "MachineIndependent/glslang_tab.cpp" +#line 6508 "MachineIndependent/glslang_tab.cpp" break; case 75: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression */ -#line 779 "MachineIndependent/glslang.y" +#line 780 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 6199 "MachineIndependent/glslang_tab.cpp" +#line 6518 "MachineIndependent/glslang_tab.cpp" break; case 76: /* conditional_expression: logical_or_expression */ -#line 787 "MachineIndependent/glslang.y" +#line 788 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6205 "MachineIndependent/glslang_tab.cpp" +#line 6524 "MachineIndependent/glslang_tab.cpp" break; case 77: /* $@1: %empty */ -#line 788 "MachineIndependent/glslang.y" +#line 789 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 6213 "MachineIndependent/glslang_tab.cpp" +#line 6532 "MachineIndependent/glslang_tab.cpp" break; case 78: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression */ -#line 791 "MachineIndependent/glslang.y" +#line 792 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -6226,17 +6545,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6230 "MachineIndependent/glslang_tab.cpp" +#line 6549 "MachineIndependent/glslang_tab.cpp" break; case 79: /* assignment_expression: conditional_expression */ -#line 806 "MachineIndependent/glslang.y" +#line 807 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6236 "MachineIndependent/glslang_tab.cpp" +#line 6555 "MachineIndependent/glslang_tab.cpp" break; case 80: /* assignment_expression: unary_expression assignment_operator assignment_expression */ -#line 807 "MachineIndependent/glslang.y" +#line 808 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); @@ -6250,119 +6569,119 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 6254 "MachineIndependent/glslang_tab.cpp" +#line 6573 "MachineIndependent/glslang_tab.cpp" break; case 81: /* assignment_operator: EQUAL */ -#line 823 "MachineIndependent/glslang.y" +#line 824 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 6263 "MachineIndependent/glslang_tab.cpp" +#line 6582 "MachineIndependent/glslang_tab.cpp" break; case 82: /* assignment_operator: MUL_ASSIGN */ -#line 827 "MachineIndependent/glslang.y" +#line 828 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 6272 "MachineIndependent/glslang_tab.cpp" +#line 6591 "MachineIndependent/glslang_tab.cpp" break; case 83: /* assignment_operator: DIV_ASSIGN */ -#line 831 "MachineIndependent/glslang.y" +#line 832 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 6281 "MachineIndependent/glslang_tab.cpp" +#line 6600 "MachineIndependent/glslang_tab.cpp" break; case 84: /* assignment_operator: MOD_ASSIGN */ -#line 835 "MachineIndependent/glslang.y" +#line 836 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 6291 "MachineIndependent/glslang_tab.cpp" +#line 6610 "MachineIndependent/glslang_tab.cpp" break; case 85: /* assignment_operator: ADD_ASSIGN */ -#line 840 "MachineIndependent/glslang.y" +#line 841 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 6300 "MachineIndependent/glslang_tab.cpp" +#line 6619 "MachineIndependent/glslang_tab.cpp" break; case 86: /* assignment_operator: SUB_ASSIGN */ -#line 844 "MachineIndependent/glslang.y" +#line 845 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 6309 "MachineIndependent/glslang_tab.cpp" +#line 6628 "MachineIndependent/glslang_tab.cpp" break; case 87: /* assignment_operator: LEFT_ASSIGN */ -#line 848 "MachineIndependent/glslang.y" +#line 849 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 6318 "MachineIndependent/glslang_tab.cpp" +#line 6637 "MachineIndependent/glslang_tab.cpp" break; case 88: /* assignment_operator: RIGHT_ASSIGN */ -#line 852 "MachineIndependent/glslang.y" +#line 853 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 6327 "MachineIndependent/glslang_tab.cpp" +#line 6646 "MachineIndependent/glslang_tab.cpp" break; case 89: /* assignment_operator: AND_ASSIGN */ -#line 856 "MachineIndependent/glslang.y" +#line 857 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 6336 "MachineIndependent/glslang_tab.cpp" +#line 6655 "MachineIndependent/glslang_tab.cpp" break; case 90: /* assignment_operator: XOR_ASSIGN */ -#line 860 "MachineIndependent/glslang.y" +#line 861 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 6345 "MachineIndependent/glslang_tab.cpp" +#line 6664 "MachineIndependent/glslang_tab.cpp" break; case 91: /* assignment_operator: OR_ASSIGN */ -#line 864 "MachineIndependent/glslang.y" +#line 865 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 6354 "MachineIndependent/glslang_tab.cpp" +#line 6673 "MachineIndependent/glslang_tab.cpp" break; case 92: /* expression: assignment_expression */ -#line 871 "MachineIndependent/glslang.y" +#line 872 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6362 "MachineIndependent/glslang_tab.cpp" +#line 6681 "MachineIndependent/glslang_tab.cpp" break; case 93: /* expression: expression COMMA assignment_expression */ -#line 874 "MachineIndependent/glslang.y" +#line 875 "MachineIndependent/glslang.y" { parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); @@ -6371,30 +6690,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6375 "MachineIndependent/glslang_tab.cpp" +#line 6694 "MachineIndependent/glslang_tab.cpp" break; case 94: /* constant_expression: conditional_expression */ -#line 885 "MachineIndependent/glslang.y" +#line 886 "MachineIndependent/glslang.y" { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6384 "MachineIndependent/glslang_tab.cpp" +#line 6703 "MachineIndependent/glslang_tab.cpp" break; case 95: /* declaration: function_prototype SEMICOLON */ -#line 892 "MachineIndependent/glslang.y" +#line 893 "MachineIndependent/glslang.y" { parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6394 "MachineIndependent/glslang_tab.cpp" +#line 6713 "MachineIndependent/glslang_tab.cpp" break; case 96: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON */ -#line 897 "MachineIndependent/glslang.y" +#line 898 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier"); (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier @@ -6402,31 +6721,43 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6406 "MachineIndependent/glslang_tab.cpp" +#line 6725 "MachineIndependent/glslang_tab.cpp" + break; + + case 97: /* declaration: spirv_instruction_qualifier function_prototype_with_spirv_variadic_tail SEMICOLON */ +#line 905 "MachineIndependent/glslang.y" + { + parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier"); + (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier + parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); + (yyval.interm.intermNode) = 0; + // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature + } +#line 6737 "MachineIndependent/glslang_tab.cpp" break; - case 97: /* declaration: spirv_execution_mode_qualifier SEMICOLON */ -#line 904 "MachineIndependent/glslang.y" + case 98: /* declaration: spirv_execution_mode_qualifier SEMICOLON */ +#line 912 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "SPIR-V execution mode qualifier"); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier"); (yyval.interm.intermNode) = 0; } -#line 6416 "MachineIndependent/glslang_tab.cpp" +#line 6747 "MachineIndependent/glslang_tab.cpp" break; - case 98: /* declaration: init_declarator_list SEMICOLON */ -#line 909 "MachineIndependent/glslang.y" + case 99: /* declaration: init_declarator_list SEMICOLON */ +#line 917 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; } -#line 6426 "MachineIndependent/glslang_tab.cpp" +#line 6757 "MachineIndependent/glslang_tab.cpp" break; - case 99: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON */ -#line 914 "MachineIndependent/glslang.y" + case 100: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON */ +#line 922 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope @@ -6434,61 +6765,61 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 6438 "MachineIndependent/glslang_tab.cpp" +#line 6769 "MachineIndependent/glslang_tab.cpp" break; - case 100: /* declaration: block_structure SEMICOLON */ -#line 921 "MachineIndependent/glslang.y" + case 101: /* declaration: block_structure SEMICOLON */ +#line 929 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); } -#line 6446 "MachineIndependent/glslang_tab.cpp" +#line 6777 "MachineIndependent/glslang_tab.cpp" break; - case 101: /* declaration: block_structure IDENTIFIER SEMICOLON */ -#line 924 "MachineIndependent/glslang.y" + case 102: /* declaration: block_structure IDENTIFIER SEMICOLON */ +#line 932 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); } -#line 6454 "MachineIndependent/glslang_tab.cpp" +#line 6785 "MachineIndependent/glslang_tab.cpp" break; - case 102: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON */ -#line 927 "MachineIndependent/glslang.y" + case 103: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON */ +#line 935 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); } -#line 6462 "MachineIndependent/glslang_tab.cpp" +#line 6793 "MachineIndependent/glslang_tab.cpp" break; - case 103: /* declaration: type_qualifier SEMICOLON */ -#line 930 "MachineIndependent/glslang.y" + case 104: /* declaration: type_qualifier SEMICOLON */ +#line 938 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 6472 "MachineIndependent/glslang_tab.cpp" +#line 6803 "MachineIndependent/glslang_tab.cpp" break; - case 104: /* declaration: type_qualifier identifier_list SEMICOLON */ -#line 935 "MachineIndependent/glslang.y" + case 105: /* declaration: type_qualifier identifier_list SEMICOLON */ +#line 943 "MachineIndependent/glslang.y" { parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 6482 "MachineIndependent/glslang_tab.cpp" +#line 6813 "MachineIndependent/glslang_tab.cpp" break; - case 105: /* $@2: %empty */ -#line 943 "MachineIndependent/glslang.y" + case 106: /* $@2: %empty */ +#line 951 "MachineIndependent/glslang.y" { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 6488 "MachineIndependent/glslang_tab.cpp" +#line 6819 "MachineIndependent/glslang_tab.cpp" break; - case 106: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_without_heap RIGHT_BRACE */ -#line 943 "MachineIndependent/glslang.y" + case 107: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_without_heap RIGHT_BRACE */ +#line 951 "MachineIndependent/glslang.y" { --parseContext.blockNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -6498,95 +6829,161 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 6502 "MachineIndependent/glslang_tab.cpp" +#line 6833 "MachineIndependent/glslang_tab.cpp" break; - case 107: /* identifier_list: IDENTIFIER */ -#line 955 "MachineIndependent/glslang.y" + case 108: /* identifier_list: IDENTIFIER */ +#line 963 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6511 "MachineIndependent/glslang_tab.cpp" +#line 6842 "MachineIndependent/glslang_tab.cpp" break; - case 108: /* identifier_list: identifier_list COMMA IDENTIFIER */ -#line 959 "MachineIndependent/glslang.y" + case 109: /* identifier_list: identifier_list COMMA IDENTIFIER */ +#line 967 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6520 "MachineIndependent/glslang_tab.cpp" +#line 6851 "MachineIndependent/glslang_tab.cpp" break; - case 109: /* function_prototype: function_declarator RIGHT_PAREN */ -#line 966 "MachineIndependent/glslang.y" + case 110: /* function_prototype: function_declarator RIGHT_PAREN */ +#line 974 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 6530 "MachineIndependent/glslang_tab.cpp" +#line 6861 "MachineIndependent/glslang_tab.cpp" + break; + + case 111: /* function_prototype: function_declarator RIGHT_PAREN attribute */ +#line 979 "MachineIndependent/glslang.y" + { + (yyval.interm).function = (yyvsp[-2].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[-1].lex).loc; + const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence }; + parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); + parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); + } +#line 6874 "MachineIndependent/glslang_tab.cpp" break; - case 110: /* function_prototype: function_declarator RIGHT_PAREN attribute */ -#line 971 "MachineIndependent/glslang.y" + case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN */ +#line 987 "MachineIndependent/glslang.y" { + (yyval.interm).function = (yyvsp[-1].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[0].lex).loc; + const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence }; + parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute"); + parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes)); + } +#line 6887 "MachineIndependent/glslang_tab.cpp" + break; + + case 113: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ +#line 995 "MachineIndependent/glslang.y" + { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); (yyval.interm).loc = (yyvsp[-1].lex).loc; const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence }; parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); + parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes)); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6543 "MachineIndependent/glslang_tab.cpp" +#line 6901 "MachineIndependent/glslang_tab.cpp" + break; + + case 114: /* function_prototype: function_header ELLIPSIS RIGHT_PAREN */ +#line 1004 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-2].interm.function), (yyvsp[-1].lex).loc); + (yyval.interm).function = (yyvsp[-2].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 6912 "MachineIndependent/glslang_tab.cpp" + break; + + case 115: /* function_prototype: function_header_with_parameters COMMA ELLIPSIS RIGHT_PAREN */ +#line 1010 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-3].interm.function), (yyvsp[-1].lex).loc); + (yyval.interm).function = (yyvsp[-3].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 6923 "MachineIndependent/glslang_tab.cpp" + break; + + case 116: /* function_prototype_with_spirv_variadic_tail: function_header SPIRV_LITERAL ELLIPSIS RIGHT_PAREN */ +#line 1019 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-3].interm.function), (yyvsp[-2].lex).loc, true /* spirvLiteral */, false /* spirvByReference */); + (yyval.interm).function = (yyvsp[-3].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 6934 "MachineIndependent/glslang_tab.cpp" + break; + + case 117: /* function_prototype_with_spirv_variadic_tail: function_header SPIRV_BY_REFERENCE ELLIPSIS RIGHT_PAREN */ +#line 1025 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-3].interm.function), (yyvsp[-2].lex).loc, false /* spirvLiteral */, true /* spirvByReference */); + (yyval.interm).function = (yyvsp[-3].interm.function); + if (parseContext.compileOnly) (yyval.interm).function->setExport(); + (yyval.interm).loc = (yyvsp[0].lex).loc; + } +#line 6945 "MachineIndependent/glslang_tab.cpp" break; - case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN */ -#line 979 "MachineIndependent/glslang.y" - { - (yyval.interm).function = (yyvsp[-1].interm.function); + case 118: /* function_prototype_with_spirv_variadic_tail: function_header_with_parameters COMMA SPIRV_LITERAL ELLIPSIS RIGHT_PAREN */ +#line 1031 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-4].interm.function), (yyvsp[-2].lex).loc, true /* spirvLiteral */, false /* spirvByReference */); + (yyval.interm).function = (yyvsp[-4].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); (yyval.interm).loc = (yyvsp[0].lex).loc; - const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence }; - parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute"); - parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes)); } -#line 6556 "MachineIndependent/glslang_tab.cpp" +#line 6956 "MachineIndependent/glslang_tab.cpp" break; - case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ -#line 987 "MachineIndependent/glslang.y" - { - (yyval.interm).function = (yyvsp[-2].interm.function); + case 119: /* function_prototype_with_spirv_variadic_tail: function_header_with_parameters COMMA SPIRV_BY_REFERENCE ELLIPSIS RIGHT_PAREN */ +#line 1037 "MachineIndependent/glslang.y" + { + parseContext.makeVariadic((yyvsp[-4].interm.function), (yyvsp[-2].lex).loc, false /* spirvLiteral */, true /* spirvByReference */); + (yyval.interm).function = (yyvsp[-4].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); - (yyval.interm).loc = (yyvsp[-1].lex).loc; - const char * extensions[2] = { E_GL_EXT_subgroup_uniform_control_flow, E_GL_EXT_maximal_reconvergence }; - parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); - parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes)); - parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); + (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 6570 "MachineIndependent/glslang_tab.cpp" +#line 6967 "MachineIndependent/glslang_tab.cpp" break; - case 113: /* function_declarator: function_header */ -#line 999 "MachineIndependent/glslang.y" + case 120: /* function_declarator: function_header */ +#line 1046 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6578 "MachineIndependent/glslang_tab.cpp" +#line 6975 "MachineIndependent/glslang_tab.cpp" break; - case 114: /* function_declarator: function_header_with_parameters */ -#line 1002 "MachineIndependent/glslang.y" + case 121: /* function_declarator: function_header_with_parameters */ +#line 1049 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6586 "MachineIndependent/glslang_tab.cpp" +#line 6983 "MachineIndependent/glslang_tab.cpp" break; - case 115: /* function_header_with_parameters: function_header parameter_declaration */ -#line 1009 "MachineIndependent/glslang.y" + case 122: /* function_header_with_parameters: function_header parameter_declaration */ +#line 1056 "MachineIndependent/glslang.y" { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -6600,11 +6997,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else delete (yyvsp[0].interm).param.type; } -#line 6604 "MachineIndependent/glslang_tab.cpp" +#line 7001 "MachineIndependent/glslang_tab.cpp" break; - case 116: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ -#line 1022 "MachineIndependent/glslang.y" + case 123: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ +#line 1069 "MachineIndependent/glslang.y" { // // Only first parameter of one-parameter functions can be void @@ -6625,20 +7022,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.vkRelaxedRemapFunctionParameter((yyvsp[-2].interm.function), (yyvsp[0].interm).param); } } -#line 6629 "MachineIndependent/glslang_tab.cpp" - break; - - case 117: /* function_header_with_parameters: function_header_with_parameters COMMA DOT DOT DOT */ -#line 1042 "MachineIndependent/glslang.y" - { - (yyval.interm.function) = (yyvsp[-4].interm.function); - parseContext.makeVariadic((yyvsp[-4].interm.function), (yyvsp[-2].lex).loc); - } -#line 6638 "MachineIndependent/glslang_tab.cpp" +#line 7026 "MachineIndependent/glslang_tab.cpp" break; - case 118: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN */ -#line 1049 "MachineIndependent/glslang.y" + case 124: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN */ +#line 1092 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", @@ -6658,11 +7046,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 6662 "MachineIndependent/glslang_tab.cpp" +#line 7050 "MachineIndependent/glslang_tab.cpp" break; - case 119: /* parameter_declarator: type_specifier IDENTIFIER */ -#line 1072 "MachineIndependent/glslang.y" + case 125: /* parameter_declarator: type_specifier IDENTIFIER */ +#line 1115 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6678,11 +7066,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 6682 "MachineIndependent/glslang_tab.cpp" +#line 7070 "MachineIndependent/glslang_tab.cpp" break; - case 120: /* parameter_declarator: type_specifier IDENTIFIER array_specifier */ -#line 1087 "MachineIndependent/glslang.y" + case 126: /* parameter_declarator: type_specifier IDENTIFIER array_specifier */ +#line 1130 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6702,21 +7090,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 6706 "MachineIndependent/glslang_tab.cpp" +#line 7094 "MachineIndependent/glslang_tab.cpp" break; - case 121: /* parameter_declarator: type_specifier IDENTIFIER EQUAL initializer */ -#line 1106 "MachineIndependent/glslang.y" + case 127: /* parameter_declarator: type_specifier IDENTIFIER EQUAL initializer */ +#line 1149 "MachineIndependent/glslang.y" { TParameter param = parseContext.getParamWithDefault((yyvsp[-3].interm.type), (yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).param = param; } -#line 6716 "MachineIndependent/glslang_tab.cpp" +#line 7104 "MachineIndependent/glslang_tab.cpp" break; - case 122: /* parameter_declaration: type_qualifier parameter_declarator */ -#line 1117 "MachineIndependent/glslang.y" + case 128: /* parameter_declaration: type_qualifier parameter_declarator */ +#line 1160 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -6728,11 +7116,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6732 "MachineIndependent/glslang_tab.cpp" +#line 7120 "MachineIndependent/glslang_tab.cpp" break; - case 123: /* parameter_declaration: parameter_declarator */ -#line 1128 "MachineIndependent/glslang.y" + case 129: /* parameter_declaration: parameter_declarator */ +#line 1171 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); @@ -6740,11 +7128,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); } -#line 6744 "MachineIndependent/glslang_tab.cpp" +#line 7132 "MachineIndependent/glslang_tab.cpp" break; - case 124: /* parameter_declaration: type_qualifier parameter_type_specifier */ -#line 1138 "MachineIndependent/glslang.y" + case 130: /* parameter_declaration: type_qualifier parameter_type_specifier */ +#line 1181 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) @@ -6755,11 +7143,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6759 "MachineIndependent/glslang_tab.cpp" +#line 7147 "MachineIndependent/glslang_tab.cpp" break; - case 125: /* parameter_declaration: parameter_type_specifier */ -#line 1148 "MachineIndependent/glslang.y" + case 131: /* parameter_declaration: parameter_type_specifier */ +#line 1191 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); @@ -6767,121 +7155,121 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); } -#line 6771 "MachineIndependent/glslang_tab.cpp" +#line 7159 "MachineIndependent/glslang_tab.cpp" break; - case 126: /* parameter_type_specifier: type_specifier */ -#line 1158 "MachineIndependent/glslang.y" + case 132: /* parameter_type_specifier: type_specifier */ +#line 1201 "MachineIndependent/glslang.y" { TParameter param = { 0, new TType((yyvsp[0].interm.type)), {} }; (yyval.interm).param = param; if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 6782 "MachineIndependent/glslang_tab.cpp" +#line 7170 "MachineIndependent/glslang_tab.cpp" break; - case 127: /* init_declarator_list: single_declaration */ -#line 1167 "MachineIndependent/glslang.y" + case 133: /* init_declarator_list: single_declaration */ +#line 1210 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 6790 "MachineIndependent/glslang_tab.cpp" +#line 7178 "MachineIndependent/glslang_tab.cpp" break; - case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ -#line 1170 "MachineIndependent/glslang.y" + case 134: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ +#line 1213 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); TIntermNode* declNode = parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, declNode, (yyvsp[0].lex).loc); } -#line 6800 "MachineIndependent/glslang_tab.cpp" +#line 7188 "MachineIndependent/glslang_tab.cpp" break; - case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ -#line 1175 "MachineIndependent/glslang.y" + case 135: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ +#line 1218 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); TIntermNode* declNode = parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-3].interm).intermNode, declNode, (yyvsp[-1].lex).loc); } -#line 6810 "MachineIndependent/glslang_tab.cpp" +#line 7198 "MachineIndependent/glslang_tab.cpp" break; - case 130: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ -#line 1180 "MachineIndependent/glslang.y" + case 136: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ +#line 1223 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-5].interm).type; TIntermNode* declNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, declNode, (yyvsp[-1].lex).loc); } -#line 6820 "MachineIndependent/glslang_tab.cpp" +#line 7208 "MachineIndependent/glslang_tab.cpp" break; - case 131: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ -#line 1185 "MachineIndependent/glslang.y" + case 137: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ +#line 1228 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm).type; TIntermNode* declNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, declNode, (yyvsp[-1].lex).loc); } -#line 6830 "MachineIndependent/glslang_tab.cpp" +#line 7218 "MachineIndependent/glslang_tab.cpp" break; - case 132: /* single_declaration: fully_specified_type */ -#line 1193 "MachineIndependent/glslang.y" + case 138: /* single_declaration: fully_specified_type */ +#line 1236 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 6840 "MachineIndependent/glslang_tab.cpp" +#line 7228 "MachineIndependent/glslang_tab.cpp" break; - case 133: /* single_declaration: fully_specified_type IDENTIFIER */ -#line 1198 "MachineIndependent/glslang.y" + case 139: /* single_declaration: fully_specified_type IDENTIFIER */ +#line 1241 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-1].interm.type); TIntermNode* declNode = parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[0].lex).loc); } -#line 6851 "MachineIndependent/glslang_tab.cpp" +#line 7239 "MachineIndependent/glslang_tab.cpp" break; - case 134: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ -#line 1204 "MachineIndependent/glslang.y" + case 140: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ +#line 1247 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-2].interm.type); TIntermNode* declNode = parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[-1].lex).loc); } -#line 6861 "MachineIndependent/glslang_tab.cpp" +#line 7249 "MachineIndependent/glslang_tab.cpp" break; - case 135: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ -#line 1209 "MachineIndependent/glslang.y" + case 141: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ +#line 1252 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm.type); TIntermNode* declNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[-3].lex).loc); } -#line 6871 "MachineIndependent/glslang_tab.cpp" +#line 7259 "MachineIndependent/glslang_tab.cpp" break; - case 136: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 1214 "MachineIndependent/glslang.y" + case 142: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 1257 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-3].interm.type); TIntermNode* declNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(nullptr, declNode, (yyvsp[-2].lex).loc); } -#line 6881 "MachineIndependent/glslang_tab.cpp" +#line 7269 "MachineIndependent/glslang_tab.cpp" break; - case 137: /* fully_specified_type: type_specifier */ -#line 1223 "MachineIndependent/glslang.y" + case 143: /* fully_specified_type: type_specifier */ +#line 1266 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6892,11 +7280,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).hasTypeParameter()); } -#line 6896 "MachineIndependent/glslang_tab.cpp" +#line 7284 "MachineIndependent/glslang_tab.cpp" break; - case 138: /* fully_specified_type: type_qualifier type_specifier */ -#line 1233 "MachineIndependent/glslang.y" + case 144: /* fully_specified_type: type_qualifier type_specifier */ +#line 1276 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, false, &(yyvsp[0].interm.type)); parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); @@ -6921,22 +7309,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 6925 "MachineIndependent/glslang_tab.cpp" +#line 7313 "MachineIndependent/glslang_tab.cpp" break; - case 139: /* invariant_qualifier: INVARIANT */ -#line 1260 "MachineIndependent/glslang.y" + case 145: /* invariant_qualifier: INVARIANT */ +#line 1303 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 6936 "MachineIndependent/glslang_tab.cpp" +#line 7324 "MachineIndependent/glslang_tab.cpp" break; - case 140: /* interpolation_qualifier: SMOOTH */ -#line 1269 "MachineIndependent/glslang.y" + case 146: /* interpolation_qualifier: SMOOTH */ +#line 1312 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -6944,11 +7332,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 6948 "MachineIndependent/glslang_tab.cpp" +#line 7336 "MachineIndependent/glslang_tab.cpp" break; - case 141: /* interpolation_qualifier: FLAT */ -#line 1276 "MachineIndependent/glslang.y" + case 147: /* interpolation_qualifier: FLAT */ +#line 1319 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -6956,11 +7344,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 6960 "MachineIndependent/glslang_tab.cpp" +#line 7348 "MachineIndependent/glslang_tab.cpp" break; - case 142: /* interpolation_qualifier: NOPERSPECTIVE */ -#line 1283 "MachineIndependent/glslang.y" + case 148: /* interpolation_qualifier: NOPERSPECTIVE */ +#line 1326 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective"); @@ -6968,11 +7356,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 6972 "MachineIndependent/glslang_tab.cpp" +#line 7360 "MachineIndependent/glslang_tab.cpp" break; - case 143: /* interpolation_qualifier: EXPLICITINTERPAMD */ -#line 1290 "MachineIndependent/glslang.y" + case 149: /* interpolation_qualifier: EXPLICITINTERPAMD */ +#line 1333 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); @@ -6980,11 +7368,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.explicitInterp = true; } -#line 6984 "MachineIndependent/glslang_tab.cpp" +#line 7372 "MachineIndependent/glslang_tab.cpp" break; - case 144: /* interpolation_qualifier: PERVERTEXNV */ -#line 1297 "MachineIndependent/glslang.y" + case 150: /* interpolation_qualifier: PERVERTEXNV */ +#line 1340 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); @@ -6993,11 +7381,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexNV = true; } -#line 6997 "MachineIndependent/glslang_tab.cpp" +#line 7385 "MachineIndependent/glslang_tab.cpp" break; - case 145: /* interpolation_qualifier: PERVERTEXEXT */ -#line 1305 "MachineIndependent/glslang.y" + case 151: /* interpolation_qualifier: PERVERTEXEXT */ +#line 1348 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexEXT"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_EXT_fragment_shader_barycentric, "fragment shader barycentric"); @@ -7006,11 +7394,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexEXT = true; } -#line 7010 "MachineIndependent/glslang_tab.cpp" +#line 7398 "MachineIndependent/glslang_tab.cpp" break; - case 146: /* interpolation_qualifier: PERPRIMITIVENV */ -#line 1313 "MachineIndependent/glslang.y" + case 152: /* interpolation_qualifier: PERPRIMITIVENV */ +#line 1356 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); @@ -7021,11 +7409,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 7025 "MachineIndependent/glslang_tab.cpp" +#line 7413 "MachineIndependent/glslang_tab.cpp" break; - case 147: /* interpolation_qualifier: PERPRIMITIVEEXT */ -#line 1323 "MachineIndependent/glslang.y" + case 153: /* interpolation_qualifier: PERPRIMITIVEEXT */ +#line 1366 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveEXT"); @@ -7036,11 +7424,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 7040 "MachineIndependent/glslang_tab.cpp" +#line 7428 "MachineIndependent/glslang_tab.cpp" break; - case 148: /* interpolation_qualifier: PERVIEWNV */ -#line 1333 "MachineIndependent/glslang.y" + case 154: /* interpolation_qualifier: PERVIEWNV */ +#line 1376 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); @@ -7048,11 +7436,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perViewNV = true; } -#line 7052 "MachineIndependent/glslang_tab.cpp" +#line 7440 "MachineIndependent/glslang_tab.cpp" break; - case 149: /* interpolation_qualifier: PERTASKNV */ -#line 1340 "MachineIndependent/glslang.y" + case 155: /* interpolation_qualifier: PERTASKNV */ +#line 1383 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); @@ -7060,84 +7448,84 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perTaskNV = true; } -#line 7064 "MachineIndependent/glslang_tab.cpp" +#line 7452 "MachineIndependent/glslang_tab.cpp" break; - case 150: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ -#line 1350 "MachineIndependent/glslang.y" + case 156: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ +#line 1393 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 7072 "MachineIndependent/glslang_tab.cpp" +#line 7460 "MachineIndependent/glslang_tab.cpp" break; - case 151: /* layout_qualifier_id_list: layout_qualifier_id */ -#line 1356 "MachineIndependent/glslang.y" + case 157: /* layout_qualifier_id_list: layout_qualifier_id */ +#line 1399 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7080 "MachineIndependent/glslang_tab.cpp" +#line 7468 "MachineIndependent/glslang_tab.cpp" break; - case 152: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ -#line 1359 "MachineIndependent/glslang.y" + case 158: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ +#line 1402 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 7090 "MachineIndependent/glslang_tab.cpp" +#line 7478 "MachineIndependent/glslang_tab.cpp" break; - case 153: /* layout_qualifier_id: IDENTIFIER */ -#line 1366 "MachineIndependent/glslang.y" + case 159: /* layout_qualifier_id: IDENTIFIER */ +#line 1409 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); } -#line 7099 "MachineIndependent/glslang_tab.cpp" +#line 7487 "MachineIndependent/glslang_tab.cpp" break; - case 154: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ -#line 1370 "MachineIndependent/glslang.y" + case 160: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ +#line 1413 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-2].lex).loc); parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); } -#line 7108 "MachineIndependent/glslang_tab.cpp" +#line 7496 "MachineIndependent/glslang_tab.cpp" break; - case 155: /* layout_qualifier_id: SHARED */ -#line 1374 "MachineIndependent/glslang.y" + case 161: /* layout_qualifier_id: SHARED */ +#line 1417 "MachineIndependent/glslang.y" { // because "shared" is both an identifier and a keyword (yyval.interm.type).init((yyvsp[0].lex).loc); TString strShared("shared"); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); } -#line 7118 "MachineIndependent/glslang_tab.cpp" +#line 7506 "MachineIndependent/glslang_tab.cpp" break; - case 156: /* precise_qualifier: PRECISE */ -#line 1382 "MachineIndependent/glslang.y" + case 162: /* precise_qualifier: PRECISE */ +#line 1425 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.noContraction = true; } -#line 7129 "MachineIndependent/glslang_tab.cpp" +#line 7517 "MachineIndependent/glslang_tab.cpp" break; - case 157: /* type_qualifier: single_type_qualifier */ -#line 1391 "MachineIndependent/glslang.y" + case 163: /* type_qualifier: single_type_qualifier */ +#line 1434 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7137 "MachineIndependent/glslang_tab.cpp" +#line 7525 "MachineIndependent/glslang_tab.cpp" break; - case 158: /* type_qualifier: type_qualifier single_type_qualifier */ -#line 1394 "MachineIndependent/glslang.y" + case 164: /* type_qualifier: type_qualifier single_type_qualifier */ +#line 1437 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -7146,151 +7534,151 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 7150 "MachineIndependent/glslang_tab.cpp" +#line 7538 "MachineIndependent/glslang_tab.cpp" break; - case 159: /* single_type_qualifier: storage_qualifier */ -#line 1405 "MachineIndependent/glslang.y" + case 165: /* single_type_qualifier: storage_qualifier */ +#line 1448 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7158 "MachineIndependent/glslang_tab.cpp" +#line 7546 "MachineIndependent/glslang_tab.cpp" break; - case 160: /* single_type_qualifier: layout_qualifier */ -#line 1408 "MachineIndependent/glslang.y" + case 166: /* single_type_qualifier: layout_qualifier */ +#line 1451 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7166 "MachineIndependent/glslang_tab.cpp" +#line 7554 "MachineIndependent/glslang_tab.cpp" break; - case 161: /* single_type_qualifier: precision_qualifier */ -#line 1411 "MachineIndependent/glslang.y" + case 167: /* single_type_qualifier: precision_qualifier */ +#line 1454 "MachineIndependent/glslang.y" { parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7175 "MachineIndependent/glslang_tab.cpp" +#line 7563 "MachineIndependent/glslang_tab.cpp" break; - case 162: /* single_type_qualifier: interpolation_qualifier */ -#line 1415 "MachineIndependent/glslang.y" + case 168: /* single_type_qualifier: interpolation_qualifier */ +#line 1458 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7184 "MachineIndependent/glslang_tab.cpp" +#line 7572 "MachineIndependent/glslang_tab.cpp" break; - case 163: /* single_type_qualifier: invariant_qualifier */ -#line 1419 "MachineIndependent/glslang.y" + case 169: /* single_type_qualifier: invariant_qualifier */ +#line 1462 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7193 "MachineIndependent/glslang_tab.cpp" +#line 7581 "MachineIndependent/glslang_tab.cpp" break; - case 164: /* single_type_qualifier: precise_qualifier */ -#line 1423 "MachineIndependent/glslang.y" + case 170: /* single_type_qualifier: precise_qualifier */ +#line 1466 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7202 "MachineIndependent/glslang_tab.cpp" +#line 7590 "MachineIndependent/glslang_tab.cpp" break; - case 165: /* single_type_qualifier: non_uniform_qualifier */ -#line 1427 "MachineIndependent/glslang.y" + case 171: /* single_type_qualifier: non_uniform_qualifier */ +#line 1470 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7210 "MachineIndependent/glslang_tab.cpp" +#line 7598 "MachineIndependent/glslang_tab.cpp" break; - case 166: /* single_type_qualifier: spirv_storage_class_qualifier */ -#line 1430 "MachineIndependent/glslang.y" + case 172: /* single_type_qualifier: spirv_storage_class_qualifier */ +#line 1473 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].interm.type).loc, "spirv_storage_class"); parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7220 "MachineIndependent/glslang_tab.cpp" +#line 7608 "MachineIndependent/glslang_tab.cpp" break; - case 167: /* single_type_qualifier: spirv_decorate_qualifier */ -#line 1435 "MachineIndependent/glslang.y" + case 173: /* single_type_qualifier: spirv_decorate_qualifier */ +#line 1478 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7229 "MachineIndependent/glslang_tab.cpp" +#line 7617 "MachineIndependent/glslang_tab.cpp" break; - case 168: /* single_type_qualifier: SPIRV_BY_REFERENCE */ -#line 1439 "MachineIndependent/glslang.y" + case 174: /* single_type_qualifier: SPIRV_BY_REFERENCE */ +#line 1482 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvByReference(); } -#line 7239 "MachineIndependent/glslang_tab.cpp" +#line 7627 "MachineIndependent/glslang_tab.cpp" break; - case 169: /* single_type_qualifier: SPIRV_LITERAL */ -#line 1444 "MachineIndependent/glslang.y" + case 175: /* single_type_qualifier: SPIRV_LITERAL */ +#line 1487 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvLiteral(); } -#line 7249 "MachineIndependent/glslang_tab.cpp" +#line 7637 "MachineIndependent/glslang_tab.cpp" break; - case 170: /* storage_qualifier: CONST */ -#line 1452 "MachineIndependent/glslang.y" + case 176: /* storage_qualifier: CONST */ +#line 1495 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } -#line 7258 "MachineIndependent/glslang_tab.cpp" +#line 7646 "MachineIndependent/glslang_tab.cpp" break; - case 171: /* storage_qualifier: INOUT */ -#line 1456 "MachineIndependent/glslang.y" + case 177: /* storage_qualifier: INOUT */ +#line 1499 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqInOut; } -#line 7268 "MachineIndependent/glslang_tab.cpp" +#line 7656 "MachineIndependent/glslang_tab.cpp" break; - case 172: /* storage_qualifier: IN */ -#line 1461 "MachineIndependent/glslang.y" + case 178: /* storage_qualifier: IN */ +#line 1504 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "in"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqIn; } -#line 7279 "MachineIndependent/glslang_tab.cpp" +#line 7667 "MachineIndependent/glslang_tab.cpp" break; - case 173: /* storage_qualifier: OUT */ -#line 1467 "MachineIndependent/glslang.y" + case 179: /* storage_qualifier: OUT */ +#line 1510 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "out"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqOut; } -#line 7290 "MachineIndependent/glslang_tab.cpp" +#line 7678 "MachineIndependent/glslang_tab.cpp" break; - case 174: /* storage_qualifier: CENTROID */ -#line 1473 "MachineIndependent/glslang.y" + case 180: /* storage_qualifier: CENTROID */ +#line 1516 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -7298,31 +7686,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 7302 "MachineIndependent/glslang_tab.cpp" +#line 7690 "MachineIndependent/glslang_tab.cpp" break; - case 175: /* storage_qualifier: UNIFORM */ -#line 1480 "MachineIndependent/glslang.y" + case 181: /* storage_qualifier: UNIFORM */ +#line 1523 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqUniform; } -#line 7312 "MachineIndependent/glslang_tab.cpp" +#line 7700 "MachineIndependent/glslang_tab.cpp" break; - case 176: /* storage_qualifier: TILEIMAGEEXT */ -#line 1485 "MachineIndependent/glslang.y" + case 182: /* storage_qualifier: TILEIMAGEEXT */ +#line 1528 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "tileImageEXT"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqTileImageEXT; } -#line 7322 "MachineIndependent/glslang_tab.cpp" +#line 7710 "MachineIndependent/glslang_tab.cpp" break; - case 177: /* storage_qualifier: SHARED */ -#line 1490 "MachineIndependent/glslang.y" + case 183: /* storage_qualifier: SHARED */ +#line 1533 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); @@ -7331,21 +7719,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 7335 "MachineIndependent/glslang_tab.cpp" +#line 7723 "MachineIndependent/glslang_tab.cpp" break; - case 178: /* storage_qualifier: BUFFER */ -#line 1498 "MachineIndependent/glslang.y" + case 184: /* storage_qualifier: BUFFER */ +#line 1541 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqBuffer; } -#line 7345 "MachineIndependent/glslang_tab.cpp" +#line 7733 "MachineIndependent/glslang_tab.cpp" break; - case 179: /* storage_qualifier: ATTRIBUTE */ -#line 1503 "MachineIndependent/glslang.y" + case 185: /* storage_qualifier: ATTRIBUTE */ +#line 1546 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -7358,11 +7746,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7362 "MachineIndependent/glslang_tab.cpp" +#line 7750 "MachineIndependent/glslang_tab.cpp" break; - case 180: /* storage_qualifier: VARYING */ -#line 1515 "MachineIndependent/glslang.y" + case 186: /* storage_qualifier: VARYING */ +#line 1558 "MachineIndependent/glslang.y" { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -7377,52 +7765,52 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7381 "MachineIndependent/glslang_tab.cpp" +#line 7769 "MachineIndependent/glslang_tab.cpp" break; - case 181: /* storage_qualifier: PATCH */ -#line 1529 "MachineIndependent/glslang.y" + case 187: /* storage_qualifier: PATCH */ +#line 1572 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.patch = true; } -#line 7392 "MachineIndependent/glslang_tab.cpp" +#line 7780 "MachineIndependent/glslang_tab.cpp" break; - case 182: /* storage_qualifier: SAMPLE */ -#line 1535 "MachineIndependent/glslang.y" + case 188: /* storage_qualifier: SAMPLE */ +#line 1578 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.sample = true; } -#line 7402 "MachineIndependent/glslang_tab.cpp" +#line 7790 "MachineIndependent/glslang_tab.cpp" break; - case 183: /* storage_qualifier: RESOURCEHEAP */ -#line 1540 "MachineIndependent/glslang.y" + case 189: /* storage_qualifier: RESOURCEHEAP */ +#line 1583 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "resourceHeap"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqResourceHeap; } -#line 7412 "MachineIndependent/glslang_tab.cpp" +#line 7800 "MachineIndependent/glslang_tab.cpp" break; - case 184: /* storage_qualifier: SAMPLERHEAP */ -#line 1545 "MachineIndependent/glslang.y" + case 190: /* storage_qualifier: SAMPLERHEAP */ +#line 1588 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "samplerHeap"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqSamplerHeap; } -#line 7422 "MachineIndependent/glslang_tab.cpp" +#line 7810 "MachineIndependent/glslang_tab.cpp" break; - case 185: /* storage_qualifier: HITATTRNV */ -#line 1550 "MachineIndependent/glslang.y" + case 191: /* storage_qualifier: HITATTRNV */ +#line 1593 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7431,11 +7819,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7435 "MachineIndependent/glslang_tab.cpp" +#line 7823 "MachineIndependent/glslang_tab.cpp" break; - case 186: /* storage_qualifier: HITOBJECTATTRNV */ -#line 1558 "MachineIndependent/glslang.y" + case 192: /* storage_qualifier: HITOBJECTATTRNV */ +#line 1601 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask @@ -7444,11 +7832,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitObjectAttrNV; } -#line 7448 "MachineIndependent/glslang_tab.cpp" +#line 7836 "MachineIndependent/glslang_tab.cpp" break; - case 187: /* storage_qualifier: HITOBJECTATTREXT */ -#line 1566 "MachineIndependent/glslang.y" + case 193: /* storage_qualifier: HITOBJECTATTREXT */ +#line 1609 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask @@ -7457,11 +7845,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitObjectAttrEXT; } -#line 7461 "MachineIndependent/glslang_tab.cpp" +#line 7849 "MachineIndependent/glslang_tab.cpp" break; - case 188: /* storage_qualifier: HITATTREXT */ -#line 1574 "MachineIndependent/glslang.y" + case 194: /* storage_qualifier: HITATTREXT */ +#line 1617 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7470,11 +7858,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7474 "MachineIndependent/glslang_tab.cpp" +#line 7862 "MachineIndependent/glslang_tab.cpp" break; - case 189: /* storage_qualifier: PAYLOADNV */ -#line 1582 "MachineIndependent/glslang.y" + case 195: /* storage_qualifier: PAYLOADNV */ +#line 1625 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7483,11 +7871,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7487 "MachineIndependent/glslang_tab.cpp" +#line 7875 "MachineIndependent/glslang_tab.cpp" break; - case 190: /* storage_qualifier: PAYLOADEXT */ -#line 1590 "MachineIndependent/glslang.y" + case 196: /* storage_qualifier: PAYLOADEXT */ +#line 1633 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7496,11 +7884,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7500 "MachineIndependent/glslang_tab.cpp" +#line 7888 "MachineIndependent/glslang_tab.cpp" break; - case 191: /* storage_qualifier: PAYLOADINNV */ -#line 1598 "MachineIndependent/glslang.y" + case 197: /* storage_qualifier: PAYLOADINNV */ +#line 1641 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7509,11 +7897,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7513 "MachineIndependent/glslang_tab.cpp" +#line 7901 "MachineIndependent/glslang_tab.cpp" break; - case 192: /* storage_qualifier: PAYLOADINEXT */ -#line 1606 "MachineIndependent/glslang.y" + case 198: /* storage_qualifier: PAYLOADINEXT */ +#line 1649 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7522,11 +7910,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7526 "MachineIndependent/glslang_tab.cpp" +#line 7914 "MachineIndependent/glslang_tab.cpp" break; - case 193: /* storage_qualifier: CALLDATANV */ -#line 1614 "MachineIndependent/glslang.y" + case 199: /* storage_qualifier: CALLDATANV */ +#line 1657 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7535,11 +7923,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7539 "MachineIndependent/glslang_tab.cpp" +#line 7927 "MachineIndependent/glslang_tab.cpp" break; - case 194: /* storage_qualifier: CALLDATAEXT */ -#line 1622 "MachineIndependent/glslang.y" + case 200: /* storage_qualifier: CALLDATAEXT */ +#line 1665 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7548,11 +7936,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7552 "MachineIndependent/glslang_tab.cpp" +#line 7940 "MachineIndependent/glslang_tab.cpp" break; - case 195: /* storage_qualifier: CALLDATAINNV */ -#line 1630 "MachineIndependent/glslang.y" + case 201: /* storage_qualifier: CALLDATAINNV */ +#line 1673 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV"); @@ -7560,11 +7948,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7564 "MachineIndependent/glslang_tab.cpp" +#line 7952 "MachineIndependent/glslang_tab.cpp" break; - case 196: /* storage_qualifier: CALLDATAINEXT */ -#line 1637 "MachineIndependent/glslang.y" + case 202: /* storage_qualifier: CALLDATAINEXT */ +#line 1680 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT"); @@ -7572,147 +7960,147 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7576 "MachineIndependent/glslang_tab.cpp" +#line 7964 "MachineIndependent/glslang_tab.cpp" break; - case 197: /* storage_qualifier: COHERENT */ -#line 1644 "MachineIndependent/glslang.y" + case 203: /* storage_qualifier: COHERENT */ +#line 1687 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 7585 "MachineIndependent/glslang_tab.cpp" +#line 7973 "MachineIndependent/glslang_tab.cpp" break; - case 198: /* storage_qualifier: DEVICECOHERENT */ -#line 1648 "MachineIndependent/glslang.y" + case 204: /* storage_qualifier: DEVICECOHERENT */ +#line 1691 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); (yyval.interm.type).qualifier.devicecoherent = true; } -#line 7595 "MachineIndependent/glslang_tab.cpp" +#line 7983 "MachineIndependent/glslang_tab.cpp" break; - case 199: /* storage_qualifier: QUEUEFAMILYCOHERENT */ -#line 1653 "MachineIndependent/glslang.y" + case 205: /* storage_qualifier: QUEUEFAMILYCOHERENT */ +#line 1696 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); (yyval.interm.type).qualifier.queuefamilycoherent = true; } -#line 7605 "MachineIndependent/glslang_tab.cpp" +#line 7993 "MachineIndependent/glslang_tab.cpp" break; - case 200: /* storage_qualifier: WORKGROUPCOHERENT */ -#line 1658 "MachineIndependent/glslang.y" + case 206: /* storage_qualifier: WORKGROUPCOHERENT */ +#line 1701 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); (yyval.interm.type).qualifier.workgroupcoherent = true; } -#line 7615 "MachineIndependent/glslang_tab.cpp" +#line 8003 "MachineIndependent/glslang_tab.cpp" break; - case 201: /* storage_qualifier: SUBGROUPCOHERENT */ -#line 1663 "MachineIndependent/glslang.y" + case 207: /* storage_qualifier: SUBGROUPCOHERENT */ +#line 1706 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); (yyval.interm.type).qualifier.subgroupcoherent = true; } -#line 7625 "MachineIndependent/glslang_tab.cpp" +#line 8013 "MachineIndependent/glslang_tab.cpp" break; - case 202: /* storage_qualifier: NONPRIVATE */ -#line 1668 "MachineIndependent/glslang.y" + case 208: /* storage_qualifier: NONPRIVATE */ +#line 1711 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); (yyval.interm.type).qualifier.nonprivate = true; } -#line 7635 "MachineIndependent/glslang_tab.cpp" +#line 8023 "MachineIndependent/glslang_tab.cpp" break; - case 203: /* storage_qualifier: SHADERCALLCOHERENT */ -#line 1673 "MachineIndependent/glslang.y" + case 209: /* storage_qualifier: SHADERCALLCOHERENT */ +#line 1716 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent"); (yyval.interm.type).qualifier.shadercallcoherent = true; } -#line 7645 "MachineIndependent/glslang_tab.cpp" +#line 8033 "MachineIndependent/glslang_tab.cpp" break; - case 204: /* storage_qualifier: VOLATILE */ -#line 1678 "MachineIndependent/glslang.y" + case 210: /* storage_qualifier: VOLATILE */ +#line 1721 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 7654 "MachineIndependent/glslang_tab.cpp" +#line 8042 "MachineIndependent/glslang_tab.cpp" break; - case 205: /* storage_qualifier: RESTRICT */ -#line 1682 "MachineIndependent/glslang.y" + case 211: /* storage_qualifier: RESTRICT */ +#line 1725 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 7663 "MachineIndependent/glslang_tab.cpp" +#line 8051 "MachineIndependent/glslang_tab.cpp" break; - case 206: /* storage_qualifier: READONLY */ -#line 1686 "MachineIndependent/glslang.y" + case 212: /* storage_qualifier: READONLY */ +#line 1729 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 7672 "MachineIndependent/glslang_tab.cpp" +#line 8060 "MachineIndependent/glslang_tab.cpp" break; - case 207: /* storage_qualifier: WRITEONLY */ -#line 1690 "MachineIndependent/glslang.y" + case 213: /* storage_qualifier: WRITEONLY */ +#line 1733 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 7681 "MachineIndependent/glslang_tab.cpp" +#line 8069 "MachineIndependent/glslang_tab.cpp" break; - case 208: /* storage_qualifier: NONTEMPORAL */ -#line 1694 "MachineIndependent/glslang.y" + case 214: /* storage_qualifier: NONTEMPORAL */ +#line 1737 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nontemporal = true; } -#line 7690 "MachineIndependent/glslang_tab.cpp" +#line 8078 "MachineIndependent/glslang_tab.cpp" break; - case 209: /* storage_qualifier: SUBROUTINE */ -#line 1698 "MachineIndependent/glslang.y" + case 215: /* storage_qualifier: SUBROUTINE */ +#line 1741 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[0].lex).loc); } -#line 7701 "MachineIndependent/glslang_tab.cpp" +#line 8089 "MachineIndependent/glslang_tab.cpp" break; - case 210: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ -#line 1704 "MachineIndependent/glslang.y" + case 216: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ +#line 1747 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[-3].lex).loc); } -#line 7712 "MachineIndependent/glslang_tab.cpp" +#line 8100 "MachineIndependent/glslang_tab.cpp" break; - case 211: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ -#line 1710 "MachineIndependent/glslang.y" + case 217: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ +#line 1753 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskPayloadSharedEXT"); @@ -7720,38 +8108,38 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqtaskPayloadSharedEXT; } -#line 7724 "MachineIndependent/glslang_tab.cpp" +#line 8112 "MachineIndependent/glslang_tab.cpp" break; - case 212: /* non_uniform_qualifier: NONUNIFORM */ -#line 1720 "MachineIndependent/glslang.y" + case 218: /* non_uniform_qualifier: NONUNIFORM */ +#line 1763 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 7733 "MachineIndependent/glslang_tab.cpp" +#line 8121 "MachineIndependent/glslang_tab.cpp" break; - case 213: /* type_name_list: IDENTIFIER */ -#line 1727 "MachineIndependent/glslang.y" + case 219: /* type_name_list: IDENTIFIER */ +#line 1770 "MachineIndependent/glslang.y" { // TODO } -#line 7741 "MachineIndependent/glslang_tab.cpp" +#line 8129 "MachineIndependent/glslang_tab.cpp" break; - case 214: /* type_name_list: type_name_list COMMA IDENTIFIER */ -#line 1730 "MachineIndependent/glslang.y" + case 220: /* type_name_list: type_name_list COMMA IDENTIFIER */ +#line 1773 "MachineIndependent/glslang.y" { // TODO: 4.0 semantics: subroutines // 1) make sure each identifier is a type declared earlier with SUBROUTINE // 2) save all of the identifiers for future comparison with the declared function } -#line 7751 "MachineIndependent/glslang_tab.cpp" +#line 8139 "MachineIndependent/glslang_tab.cpp" break; - case 215: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ -#line 1738 "MachineIndependent/glslang.y" + case 221: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ +#line 1781 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); @@ -7759,11 +8147,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.typeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type)); } -#line 7763 "MachineIndependent/glslang_tab.cpp" +#line 8151 "MachineIndependent/glslang_tab.cpp" break; - case 216: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ -#line 1745 "MachineIndependent/glslang.y" + case 222: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ +#line 1788 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-2].interm.type); @@ -7772,21 +8160,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; parseContext.typeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type)); } -#line 7776 "MachineIndependent/glslang_tab.cpp" +#line 8164 "MachineIndependent/glslang_tab.cpp" break; - case 217: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ -#line 1756 "MachineIndependent/glslang.y" + case 223: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ +#line 1799 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 7786 "MachineIndependent/glslang_tab.cpp" +#line 8174 "MachineIndependent/glslang_tab.cpp" break; - case 218: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1761 "MachineIndependent/glslang.y" + case 224: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ +#line 1804 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -7795,20 +8183,20 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7799 "MachineIndependent/glslang_tab.cpp" +#line 8187 "MachineIndependent/glslang_tab.cpp" break; - case 219: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ -#line 1769 "MachineIndependent/glslang.y" + case 225: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ +#line 1812 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 7808 "MachineIndependent/glslang_tab.cpp" +#line 8196 "MachineIndependent/glslang_tab.cpp" break; - case 220: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1773 "MachineIndependent/glslang.y" + case 226: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ +#line 1816 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); @@ -7816,46 +8204,46 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7820 "MachineIndependent/glslang_tab.cpp" +#line 8208 "MachineIndependent/glslang_tab.cpp" break; - case 221: /* type_parameter_specifier_opt: type_parameter_specifier */ -#line 1783 "MachineIndependent/glslang.y" + case 227: /* type_parameter_specifier_opt: type_parameter_specifier */ +#line 1826 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); } -#line 7828 "MachineIndependent/glslang_tab.cpp" +#line 8216 "MachineIndependent/glslang_tab.cpp" break; - case 222: /* type_parameter_specifier_opt: %empty */ -#line 1786 "MachineIndependent/glslang.y" + case 228: /* type_parameter_specifier_opt: %empty */ +#line 1829 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = 0; } -#line 7836 "MachineIndependent/glslang_tab.cpp" +#line 8224 "MachineIndependent/glslang_tab.cpp" break; - case 223: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ -#line 1792 "MachineIndependent/glslang.y" + case 229: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ +#line 1835 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); } -#line 7844 "MachineIndependent/glslang_tab.cpp" +#line 8232 "MachineIndependent/glslang_tab.cpp" break; - case 224: /* type_parameter_specifier_list: type_specifier */ -#line 1798 "MachineIndependent/glslang.y" + case 230: /* type_parameter_specifier_list: type_specifier */ +#line 1841 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; (yyval.interm.typeParameters)->spirvType = (yyvsp[0].interm.type).spirvType; (yyval.interm.typeParameters)->basicType = (yyvsp[0].interm.type).basicType; } -#line 7855 "MachineIndependent/glslang_tab.cpp" +#line 8243 "MachineIndependent/glslang_tab.cpp" break; - case 225: /* type_parameter_specifier_list: unary_expression */ -#line 1804 "MachineIndependent/glslang.y" + case 231: /* type_parameter_specifier_list: unary_expression */ +#line 1847 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; @@ -7864,11 +8252,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7868 "MachineIndependent/glslang_tab.cpp" +#line 8256 "MachineIndependent/glslang_tab.cpp" break; - case 226: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ -#line 1812 "MachineIndependent/glslang.y" + case 232: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ +#line 1855 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); @@ -7876,300 +8264,300 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7880 "MachineIndependent/glslang_tab.cpp" +#line 8268 "MachineIndependent/glslang_tab.cpp" break; - case 227: /* type_specifier_nonarray: VOID */ -#line 1822 "MachineIndependent/glslang.y" + case 233: /* type_specifier_nonarray: VOID */ +#line 1865 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 7889 "MachineIndependent/glslang_tab.cpp" +#line 8277 "MachineIndependent/glslang_tab.cpp" break; - case 228: /* type_specifier_nonarray: FLOAT */ -#line 1826 "MachineIndependent/glslang.y" + case 234: /* type_specifier_nonarray: FLOAT */ +#line 1869 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7898 "MachineIndependent/glslang_tab.cpp" +#line 8286 "MachineIndependent/glslang_tab.cpp" break; - case 229: /* type_specifier_nonarray: INT */ -#line 1830 "MachineIndependent/glslang.y" + case 235: /* type_specifier_nonarray: INT */ +#line 1873 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 7907 "MachineIndependent/glslang_tab.cpp" +#line 8295 "MachineIndependent/glslang_tab.cpp" break; - case 230: /* type_specifier_nonarray: UINT */ -#line 1834 "MachineIndependent/glslang.y" + case 236: /* type_specifier_nonarray: UINT */ +#line 1877 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 7917 "MachineIndependent/glslang_tab.cpp" +#line 8305 "MachineIndependent/glslang_tab.cpp" break; - case 231: /* type_specifier_nonarray: BOOL */ -#line 1839 "MachineIndependent/glslang.y" + case 237: /* type_specifier_nonarray: BOOL */ +#line 1882 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; } -#line 7926 "MachineIndependent/glslang_tab.cpp" +#line 8314 "MachineIndependent/glslang_tab.cpp" break; - case 232: /* type_specifier_nonarray: VEC2 */ -#line 1843 "MachineIndependent/glslang.y" + case 238: /* type_specifier_nonarray: VEC2 */ +#line 1886 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 7936 "MachineIndependent/glslang_tab.cpp" +#line 8324 "MachineIndependent/glslang_tab.cpp" break; - case 233: /* type_specifier_nonarray: VEC3 */ -#line 1848 "MachineIndependent/glslang.y" + case 239: /* type_specifier_nonarray: VEC3 */ +#line 1891 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 7946 "MachineIndependent/glslang_tab.cpp" +#line 8334 "MachineIndependent/glslang_tab.cpp" break; - case 234: /* type_specifier_nonarray: VEC4 */ -#line 1853 "MachineIndependent/glslang.y" + case 240: /* type_specifier_nonarray: VEC4 */ +#line 1896 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 7956 "MachineIndependent/glslang_tab.cpp" +#line 8344 "MachineIndependent/glslang_tab.cpp" break; - case 235: /* type_specifier_nonarray: BVEC2 */ -#line 1858 "MachineIndependent/glslang.y" + case 241: /* type_specifier_nonarray: BVEC2 */ +#line 1901 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(2); } -#line 7966 "MachineIndependent/glslang_tab.cpp" +#line 8354 "MachineIndependent/glslang_tab.cpp" break; - case 236: /* type_specifier_nonarray: BVEC3 */ -#line 1863 "MachineIndependent/glslang.y" + case 242: /* type_specifier_nonarray: BVEC3 */ +#line 1906 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(3); } -#line 7976 "MachineIndependent/glslang_tab.cpp" +#line 8364 "MachineIndependent/glslang_tab.cpp" break; - case 237: /* type_specifier_nonarray: BVEC4 */ -#line 1868 "MachineIndependent/glslang.y" + case 243: /* type_specifier_nonarray: BVEC4 */ +#line 1911 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(4); } -#line 7986 "MachineIndependent/glslang_tab.cpp" +#line 8374 "MachineIndependent/glslang_tab.cpp" break; - case 238: /* type_specifier_nonarray: IVEC2 */ -#line 1873 "MachineIndependent/glslang.y" + case 244: /* type_specifier_nonarray: IVEC2 */ +#line 1916 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 7996 "MachineIndependent/glslang_tab.cpp" +#line 8384 "MachineIndependent/glslang_tab.cpp" break; - case 239: /* type_specifier_nonarray: IVEC3 */ -#line 1878 "MachineIndependent/glslang.y" + case 245: /* type_specifier_nonarray: IVEC3 */ +#line 1921 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 8006 "MachineIndependent/glslang_tab.cpp" +#line 8394 "MachineIndependent/glslang_tab.cpp" break; - case 240: /* type_specifier_nonarray: IVEC4 */ -#line 1883 "MachineIndependent/glslang.y" + case 246: /* type_specifier_nonarray: IVEC4 */ +#line 1926 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 8016 "MachineIndependent/glslang_tab.cpp" +#line 8404 "MachineIndependent/glslang_tab.cpp" break; - case 241: /* type_specifier_nonarray: UVEC2 */ -#line 1888 "MachineIndependent/glslang.y" + case 247: /* type_specifier_nonarray: UVEC2 */ +#line 1931 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 8027 "MachineIndependent/glslang_tab.cpp" +#line 8415 "MachineIndependent/glslang_tab.cpp" break; - case 242: /* type_specifier_nonarray: UVEC3 */ -#line 1894 "MachineIndependent/glslang.y" + case 248: /* type_specifier_nonarray: UVEC3 */ +#line 1937 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 8038 "MachineIndependent/glslang_tab.cpp" +#line 8426 "MachineIndependent/glslang_tab.cpp" break; - case 243: /* type_specifier_nonarray: UVEC4 */ -#line 1900 "MachineIndependent/glslang.y" + case 249: /* type_specifier_nonarray: UVEC4 */ +#line 1943 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 8049 "MachineIndependent/glslang_tab.cpp" +#line 8437 "MachineIndependent/glslang_tab.cpp" break; - case 244: /* type_specifier_nonarray: MAT2 */ -#line 1906 "MachineIndependent/glslang.y" + case 250: /* type_specifier_nonarray: MAT2 */ +#line 1949 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8059 "MachineIndependent/glslang_tab.cpp" +#line 8447 "MachineIndependent/glslang_tab.cpp" break; - case 245: /* type_specifier_nonarray: MAT3 */ -#line 1911 "MachineIndependent/glslang.y" + case 251: /* type_specifier_nonarray: MAT3 */ +#line 1954 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8069 "MachineIndependent/glslang_tab.cpp" +#line 8457 "MachineIndependent/glslang_tab.cpp" break; - case 246: /* type_specifier_nonarray: MAT4 */ -#line 1916 "MachineIndependent/glslang.y" + case 252: /* type_specifier_nonarray: MAT4 */ +#line 1959 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8079 "MachineIndependent/glslang_tab.cpp" +#line 8467 "MachineIndependent/glslang_tab.cpp" break; - case 247: /* type_specifier_nonarray: MAT2X2 */ -#line 1921 "MachineIndependent/glslang.y" + case 253: /* type_specifier_nonarray: MAT2X2 */ +#line 1964 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8089 "MachineIndependent/glslang_tab.cpp" +#line 8477 "MachineIndependent/glslang_tab.cpp" break; - case 248: /* type_specifier_nonarray: MAT2X3 */ -#line 1926 "MachineIndependent/glslang.y" + case 254: /* type_specifier_nonarray: MAT2X3 */ +#line 1969 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 8099 "MachineIndependent/glslang_tab.cpp" +#line 8487 "MachineIndependent/glslang_tab.cpp" break; - case 249: /* type_specifier_nonarray: MAT2X4 */ -#line 1931 "MachineIndependent/glslang.y" + case 255: /* type_specifier_nonarray: MAT2X4 */ +#line 1974 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 8109 "MachineIndependent/glslang_tab.cpp" +#line 8497 "MachineIndependent/glslang_tab.cpp" break; - case 250: /* type_specifier_nonarray: MAT3X2 */ -#line 1936 "MachineIndependent/glslang.y" + case 256: /* type_specifier_nonarray: MAT3X2 */ +#line 1979 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 8119 "MachineIndependent/glslang_tab.cpp" +#line 8507 "MachineIndependent/glslang_tab.cpp" break; - case 251: /* type_specifier_nonarray: MAT3X3 */ -#line 1941 "MachineIndependent/glslang.y" + case 257: /* type_specifier_nonarray: MAT3X3 */ +#line 1984 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8129 "MachineIndependent/glslang_tab.cpp" +#line 8517 "MachineIndependent/glslang_tab.cpp" break; - case 252: /* type_specifier_nonarray: MAT3X4 */ -#line 1946 "MachineIndependent/glslang.y" + case 258: /* type_specifier_nonarray: MAT3X4 */ +#line 1989 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 8139 "MachineIndependent/glslang_tab.cpp" +#line 8527 "MachineIndependent/glslang_tab.cpp" break; - case 253: /* type_specifier_nonarray: MAT4X2 */ -#line 1951 "MachineIndependent/glslang.y" + case 259: /* type_specifier_nonarray: MAT4X2 */ +#line 1994 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 8149 "MachineIndependent/glslang_tab.cpp" +#line 8537 "MachineIndependent/glslang_tab.cpp" break; - case 254: /* type_specifier_nonarray: MAT4X3 */ -#line 1956 "MachineIndependent/glslang.y" + case 260: /* type_specifier_nonarray: MAT4X3 */ +#line 1999 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 8159 "MachineIndependent/glslang_tab.cpp" +#line 8547 "MachineIndependent/glslang_tab.cpp" break; - case 255: /* type_specifier_nonarray: MAT4X4 */ -#line 1961 "MachineIndependent/glslang.y" + case 261: /* type_specifier_nonarray: MAT4X4 */ +#line 2004 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8169 "MachineIndependent/glslang_tab.cpp" +#line 8557 "MachineIndependent/glslang_tab.cpp" break; - case 256: /* type_specifier_nonarray: DOUBLE */ -#line 1966 "MachineIndependent/glslang.y" + case 262: /* type_specifier_nonarray: DOUBLE */ +#line 2009 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8177,151 +8565,151 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 8181 "MachineIndependent/glslang_tab.cpp" +#line 8569 "MachineIndependent/glslang_tab.cpp" break; - case 257: /* type_specifier_nonarray: BFLOAT16_T */ -#line 1973 "MachineIndependent/glslang.y" + case 263: /* type_specifier_nonarray: BFLOAT16_T */ +#line 2016 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "bfloat16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; } -#line 8191 "MachineIndependent/glslang_tab.cpp" +#line 8579 "MachineIndependent/glslang_tab.cpp" break; - case 258: /* type_specifier_nonarray: FLOATE5M2_T */ -#line 1978 "MachineIndependent/glslang.y" + case 264: /* type_specifier_nonarray: FLOATE5M2_T */ +#line 2021 "MachineIndependent/glslang.y" { parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "floate5m2_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE5M2; } -#line 8201 "MachineIndependent/glslang_tab.cpp" +#line 8589 "MachineIndependent/glslang_tab.cpp" break; - case 259: /* type_specifier_nonarray: FLOATE4M3_T */ -#line 1983 "MachineIndependent/glslang.y" + case 265: /* type_specifier_nonarray: FLOATE4M3_T */ +#line 2026 "MachineIndependent/glslang.y" { parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "floate4m3_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE4M3; } -#line 8211 "MachineIndependent/glslang_tab.cpp" +#line 8599 "MachineIndependent/glslang_tab.cpp" break; - case 260: /* type_specifier_nonarray: FLOAT16_T */ -#line 1988 "MachineIndependent/glslang.y" + case 266: /* type_specifier_nonarray: FLOAT16_T */ +#line 2031 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; } -#line 8221 "MachineIndependent/glslang_tab.cpp" +#line 8609 "MachineIndependent/glslang_tab.cpp" break; - case 261: /* type_specifier_nonarray: FLOAT32_T */ -#line 1993 "MachineIndependent/glslang.y" + case 267: /* type_specifier_nonarray: FLOAT32_T */ +#line 2036 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 8231 "MachineIndependent/glslang_tab.cpp" +#line 8619 "MachineIndependent/glslang_tab.cpp" break; - case 262: /* type_specifier_nonarray: FLOAT64_T */ -#line 1998 "MachineIndependent/glslang.y" + case 268: /* type_specifier_nonarray: FLOAT64_T */ +#line 2041 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 8241 "MachineIndependent/glslang_tab.cpp" +#line 8629 "MachineIndependent/glslang_tab.cpp" break; - case 263: /* type_specifier_nonarray: INT8_T */ -#line 2003 "MachineIndependent/glslang.y" + case 269: /* type_specifier_nonarray: INT8_T */ +#line 2046 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; } -#line 8251 "MachineIndependent/glslang_tab.cpp" +#line 8639 "MachineIndependent/glslang_tab.cpp" break; - case 264: /* type_specifier_nonarray: UINT8_T */ -#line 2008 "MachineIndependent/glslang.y" + case 270: /* type_specifier_nonarray: UINT8_T */ +#line 2051 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; } -#line 8261 "MachineIndependent/glslang_tab.cpp" +#line 8649 "MachineIndependent/glslang_tab.cpp" break; - case 265: /* type_specifier_nonarray: INT16_T */ -#line 2013 "MachineIndependent/glslang.y" + case 271: /* type_specifier_nonarray: INT16_T */ +#line 2056 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; } -#line 8271 "MachineIndependent/glslang_tab.cpp" +#line 8659 "MachineIndependent/glslang_tab.cpp" break; - case 266: /* type_specifier_nonarray: UINT16_T */ -#line 2018 "MachineIndependent/glslang.y" + case 272: /* type_specifier_nonarray: UINT16_T */ +#line 2061 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; } -#line 8281 "MachineIndependent/glslang_tab.cpp" +#line 8669 "MachineIndependent/glslang_tab.cpp" break; - case 267: /* type_specifier_nonarray: INT32_T */ -#line 2023 "MachineIndependent/glslang.y" + case 273: /* type_specifier_nonarray: INT32_T */ +#line 2066 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 8291 "MachineIndependent/glslang_tab.cpp" +#line 8679 "MachineIndependent/glslang_tab.cpp" break; - case 268: /* type_specifier_nonarray: UINT32_T */ -#line 2028 "MachineIndependent/glslang.y" + case 274: /* type_specifier_nonarray: UINT32_T */ +#line 2071 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 8301 "MachineIndependent/glslang_tab.cpp" +#line 8689 "MachineIndependent/glslang_tab.cpp" break; - case 269: /* type_specifier_nonarray: INT64_T */ -#line 2033 "MachineIndependent/glslang.y" + case 275: /* type_specifier_nonarray: INT64_T */ +#line 2076 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; } -#line 8311 "MachineIndependent/glslang_tab.cpp" +#line 8699 "MachineIndependent/glslang_tab.cpp" break; - case 270: /* type_specifier_nonarray: UINT64_T */ -#line 2038 "MachineIndependent/glslang.y" + case 276: /* type_specifier_nonarray: UINT64_T */ +#line 2081 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; } -#line 8321 "MachineIndependent/glslang_tab.cpp" +#line 8709 "MachineIndependent/glslang_tab.cpp" break; - case 271: /* type_specifier_nonarray: DVEC2 */ -#line 2043 "MachineIndependent/glslang.y" + case 277: /* type_specifier_nonarray: DVEC2 */ +#line 2086 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8330,11 +8718,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 8334 "MachineIndependent/glslang_tab.cpp" +#line 8722 "MachineIndependent/glslang_tab.cpp" break; - case 272: /* type_specifier_nonarray: DVEC3 */ -#line 2051 "MachineIndependent/glslang.y" + case 278: /* type_specifier_nonarray: DVEC3 */ +#line 2094 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8343,11 +8731,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8347 "MachineIndependent/glslang_tab.cpp" +#line 8735 "MachineIndependent/glslang_tab.cpp" break; - case 273: /* type_specifier_nonarray: DVEC4 */ -#line 2059 "MachineIndependent/glslang.y" + case 279: /* type_specifier_nonarray: DVEC4 */ +#line 2102 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8356,473 +8744,473 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8360 "MachineIndependent/glslang_tab.cpp" +#line 8748 "MachineIndependent/glslang_tab.cpp" break; - case 274: /* type_specifier_nonarray: BF16VEC2 */ -#line 2067 "MachineIndependent/glslang.y" + case 280: /* type_specifier_nonarray: BF16VEC2 */ +#line 2110 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(2); } -#line 8371 "MachineIndependent/glslang_tab.cpp" +#line 8759 "MachineIndependent/glslang_tab.cpp" break; - case 275: /* type_specifier_nonarray: BF16VEC3 */ -#line 2073 "MachineIndependent/glslang.y" + case 281: /* type_specifier_nonarray: BF16VEC3 */ +#line 2116 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(3); } -#line 8382 "MachineIndependent/glslang_tab.cpp" +#line 8770 "MachineIndependent/glslang_tab.cpp" break; - case 276: /* type_specifier_nonarray: BF16VEC4 */ -#line 2079 "MachineIndependent/glslang.y" + case 282: /* type_specifier_nonarray: BF16VEC4 */ +#line 2122 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(4); } -#line 8393 "MachineIndependent/glslang_tab.cpp" +#line 8781 "MachineIndependent/glslang_tab.cpp" break; - case 277: /* type_specifier_nonarray: FE5M2VEC2 */ -#line 2085 "MachineIndependent/glslang.y" + case 283: /* type_specifier_nonarray: FE5M2VEC2 */ +#line 2128 "MachineIndependent/glslang.y" { parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE5M2; (yyval.interm.type).setVector(2); } -#line 8404 "MachineIndependent/glslang_tab.cpp" +#line 8792 "MachineIndependent/glslang_tab.cpp" break; - case 278: /* type_specifier_nonarray: FE5M2VEC3 */ -#line 2091 "MachineIndependent/glslang.y" + case 284: /* type_specifier_nonarray: FE5M2VEC3 */ +#line 2134 "MachineIndependent/glslang.y" { parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE5M2; (yyval.interm.type).setVector(3); } -#line 8415 "MachineIndependent/glslang_tab.cpp" +#line 8803 "MachineIndependent/glslang_tab.cpp" break; - case 279: /* type_specifier_nonarray: FE5M2VEC4 */ -#line 2097 "MachineIndependent/glslang.y" + case 285: /* type_specifier_nonarray: FE5M2VEC4 */ +#line 2140 "MachineIndependent/glslang.y" { parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE5M2; (yyval.interm.type).setVector(4); } -#line 8426 "MachineIndependent/glslang_tab.cpp" +#line 8814 "MachineIndependent/glslang_tab.cpp" break; - case 280: /* type_specifier_nonarray: FE4M3VEC2 */ -#line 2103 "MachineIndependent/glslang.y" + case 286: /* type_specifier_nonarray: FE4M3VEC2 */ +#line 2146 "MachineIndependent/glslang.y" { parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE4M3; (yyval.interm.type).setVector(2); } -#line 8437 "MachineIndependent/glslang_tab.cpp" +#line 8825 "MachineIndependent/glslang_tab.cpp" break; - case 281: /* type_specifier_nonarray: FE4M3VEC3 */ -#line 2109 "MachineIndependent/glslang.y" + case 287: /* type_specifier_nonarray: FE4M3VEC3 */ +#line 2152 "MachineIndependent/glslang.y" { parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE4M3; (yyval.interm.type).setVector(3); } -#line 8448 "MachineIndependent/glslang_tab.cpp" +#line 8836 "MachineIndependent/glslang_tab.cpp" break; - case 282: /* type_specifier_nonarray: FE4M3VEC4 */ -#line 2115 "MachineIndependent/glslang.y" + case 288: /* type_specifier_nonarray: FE4M3VEC4 */ +#line 2158 "MachineIndependent/glslang.y" { parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloatE4M3; (yyval.interm.type).setVector(4); } -#line 8459 "MachineIndependent/glslang_tab.cpp" +#line 8847 "MachineIndependent/glslang_tab.cpp" break; - case 283: /* type_specifier_nonarray: F16VEC2 */ -#line 2121 "MachineIndependent/glslang.y" + case 289: /* type_specifier_nonarray: F16VEC2 */ +#line 2164 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(2); } -#line 8470 "MachineIndependent/glslang_tab.cpp" +#line 8858 "MachineIndependent/glslang_tab.cpp" break; - case 284: /* type_specifier_nonarray: F16VEC3 */ -#line 2127 "MachineIndependent/glslang.y" + case 290: /* type_specifier_nonarray: F16VEC3 */ +#line 2170 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(3); } -#line 8481 "MachineIndependent/glslang_tab.cpp" +#line 8869 "MachineIndependent/glslang_tab.cpp" break; - case 285: /* type_specifier_nonarray: F16VEC4 */ -#line 2133 "MachineIndependent/glslang.y" + case 291: /* type_specifier_nonarray: F16VEC4 */ +#line 2176 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(4); } -#line 8492 "MachineIndependent/glslang_tab.cpp" +#line 8880 "MachineIndependent/glslang_tab.cpp" break; - case 286: /* type_specifier_nonarray: F32VEC2 */ -#line 2139 "MachineIndependent/glslang.y" + case 292: /* type_specifier_nonarray: F32VEC2 */ +#line 2182 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 8503 "MachineIndependent/glslang_tab.cpp" +#line 8891 "MachineIndependent/glslang_tab.cpp" break; - case 287: /* type_specifier_nonarray: F32VEC3 */ -#line 2145 "MachineIndependent/glslang.y" + case 293: /* type_specifier_nonarray: F32VEC3 */ +#line 2188 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 8514 "MachineIndependent/glslang_tab.cpp" +#line 8902 "MachineIndependent/glslang_tab.cpp" break; - case 288: /* type_specifier_nonarray: F32VEC4 */ -#line 2151 "MachineIndependent/glslang.y" + case 294: /* type_specifier_nonarray: F32VEC4 */ +#line 2194 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 8525 "MachineIndependent/glslang_tab.cpp" +#line 8913 "MachineIndependent/glslang_tab.cpp" break; - case 289: /* type_specifier_nonarray: F64VEC2 */ -#line 2157 "MachineIndependent/glslang.y" + case 295: /* type_specifier_nonarray: F64VEC2 */ +#line 2200 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 8536 "MachineIndependent/glslang_tab.cpp" +#line 8924 "MachineIndependent/glslang_tab.cpp" break; - case 290: /* type_specifier_nonarray: F64VEC3 */ -#line 2163 "MachineIndependent/glslang.y" + case 296: /* type_specifier_nonarray: F64VEC3 */ +#line 2206 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8547 "MachineIndependent/glslang_tab.cpp" +#line 8935 "MachineIndependent/glslang_tab.cpp" break; - case 291: /* type_specifier_nonarray: F64VEC4 */ -#line 2169 "MachineIndependent/glslang.y" + case 297: /* type_specifier_nonarray: F64VEC4 */ +#line 2212 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8558 "MachineIndependent/glslang_tab.cpp" +#line 8946 "MachineIndependent/glslang_tab.cpp" break; - case 292: /* type_specifier_nonarray: I8VEC2 */ -#line 2175 "MachineIndependent/glslang.y" + case 298: /* type_specifier_nonarray: I8VEC2 */ +#line 2218 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(2); } -#line 8569 "MachineIndependent/glslang_tab.cpp" +#line 8957 "MachineIndependent/glslang_tab.cpp" break; - case 293: /* type_specifier_nonarray: I8VEC3 */ -#line 2181 "MachineIndependent/glslang.y" + case 299: /* type_specifier_nonarray: I8VEC3 */ +#line 2224 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(3); } -#line 8580 "MachineIndependent/glslang_tab.cpp" +#line 8968 "MachineIndependent/glslang_tab.cpp" break; - case 294: /* type_specifier_nonarray: I8VEC4 */ -#line 2187 "MachineIndependent/glslang.y" + case 300: /* type_specifier_nonarray: I8VEC4 */ +#line 2230 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(4); } -#line 8591 "MachineIndependent/glslang_tab.cpp" +#line 8979 "MachineIndependent/glslang_tab.cpp" break; - case 295: /* type_specifier_nonarray: I16VEC2 */ -#line 2193 "MachineIndependent/glslang.y" + case 301: /* type_specifier_nonarray: I16VEC2 */ +#line 2236 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(2); } -#line 8602 "MachineIndependent/glslang_tab.cpp" +#line 8990 "MachineIndependent/glslang_tab.cpp" break; - case 296: /* type_specifier_nonarray: I16VEC3 */ -#line 2199 "MachineIndependent/glslang.y" + case 302: /* type_specifier_nonarray: I16VEC3 */ +#line 2242 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(3); } -#line 8613 "MachineIndependent/glslang_tab.cpp" +#line 9001 "MachineIndependent/glslang_tab.cpp" break; - case 297: /* type_specifier_nonarray: I16VEC4 */ -#line 2205 "MachineIndependent/glslang.y" + case 303: /* type_specifier_nonarray: I16VEC4 */ +#line 2248 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(4); } -#line 8624 "MachineIndependent/glslang_tab.cpp" +#line 9012 "MachineIndependent/glslang_tab.cpp" break; - case 298: /* type_specifier_nonarray: I32VEC2 */ -#line 2211 "MachineIndependent/glslang.y" + case 304: /* type_specifier_nonarray: I32VEC2 */ +#line 2254 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 8635 "MachineIndependent/glslang_tab.cpp" +#line 9023 "MachineIndependent/glslang_tab.cpp" break; - case 299: /* type_specifier_nonarray: I32VEC3 */ -#line 2217 "MachineIndependent/glslang.y" + case 305: /* type_specifier_nonarray: I32VEC3 */ +#line 2260 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 8646 "MachineIndependent/glslang_tab.cpp" +#line 9034 "MachineIndependent/glslang_tab.cpp" break; - case 300: /* type_specifier_nonarray: I32VEC4 */ -#line 2223 "MachineIndependent/glslang.y" + case 306: /* type_specifier_nonarray: I32VEC4 */ +#line 2266 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 8657 "MachineIndependent/glslang_tab.cpp" +#line 9045 "MachineIndependent/glslang_tab.cpp" break; - case 301: /* type_specifier_nonarray: I64VEC2 */ -#line 2229 "MachineIndependent/glslang.y" + case 307: /* type_specifier_nonarray: I64VEC2 */ +#line 2272 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(2); } -#line 8668 "MachineIndependent/glslang_tab.cpp" +#line 9056 "MachineIndependent/glslang_tab.cpp" break; - case 302: /* type_specifier_nonarray: I64VEC3 */ -#line 2235 "MachineIndependent/glslang.y" + case 308: /* type_specifier_nonarray: I64VEC3 */ +#line 2278 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(3); } -#line 8679 "MachineIndependent/glslang_tab.cpp" +#line 9067 "MachineIndependent/glslang_tab.cpp" break; - case 303: /* type_specifier_nonarray: I64VEC4 */ -#line 2241 "MachineIndependent/glslang.y" + case 309: /* type_specifier_nonarray: I64VEC4 */ +#line 2284 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(4); } -#line 8690 "MachineIndependent/glslang_tab.cpp" +#line 9078 "MachineIndependent/glslang_tab.cpp" break; - case 304: /* type_specifier_nonarray: U8VEC2 */ -#line 2247 "MachineIndependent/glslang.y" + case 310: /* type_specifier_nonarray: U8VEC2 */ +#line 2290 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(2); } -#line 8701 "MachineIndependent/glslang_tab.cpp" +#line 9089 "MachineIndependent/glslang_tab.cpp" break; - case 305: /* type_specifier_nonarray: U8VEC3 */ -#line 2253 "MachineIndependent/glslang.y" + case 311: /* type_specifier_nonarray: U8VEC3 */ +#line 2296 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(3); } -#line 8712 "MachineIndependent/glslang_tab.cpp" +#line 9100 "MachineIndependent/glslang_tab.cpp" break; - case 306: /* type_specifier_nonarray: U8VEC4 */ -#line 2259 "MachineIndependent/glslang.y" + case 312: /* type_specifier_nonarray: U8VEC4 */ +#line 2302 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(4); } -#line 8723 "MachineIndependent/glslang_tab.cpp" +#line 9111 "MachineIndependent/glslang_tab.cpp" break; - case 307: /* type_specifier_nonarray: U16VEC2 */ -#line 2265 "MachineIndependent/glslang.y" + case 313: /* type_specifier_nonarray: U16VEC2 */ +#line 2308 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(2); } -#line 8734 "MachineIndependent/glslang_tab.cpp" +#line 9122 "MachineIndependent/glslang_tab.cpp" break; - case 308: /* type_specifier_nonarray: U16VEC3 */ -#line 2271 "MachineIndependent/glslang.y" + case 314: /* type_specifier_nonarray: U16VEC3 */ +#line 2314 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(3); } -#line 8745 "MachineIndependent/glslang_tab.cpp" +#line 9133 "MachineIndependent/glslang_tab.cpp" break; - case 309: /* type_specifier_nonarray: U16VEC4 */ -#line 2277 "MachineIndependent/glslang.y" + case 315: /* type_specifier_nonarray: U16VEC4 */ +#line 2320 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(4); } -#line 8756 "MachineIndependent/glslang_tab.cpp" +#line 9144 "MachineIndependent/glslang_tab.cpp" break; - case 310: /* type_specifier_nonarray: U32VEC2 */ -#line 2283 "MachineIndependent/glslang.y" + case 316: /* type_specifier_nonarray: U32VEC2 */ +#line 2326 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 8767 "MachineIndependent/glslang_tab.cpp" +#line 9155 "MachineIndependent/glslang_tab.cpp" break; - case 311: /* type_specifier_nonarray: U32VEC3 */ -#line 2289 "MachineIndependent/glslang.y" + case 317: /* type_specifier_nonarray: U32VEC3 */ +#line 2332 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 8778 "MachineIndependent/glslang_tab.cpp" +#line 9166 "MachineIndependent/glslang_tab.cpp" break; - case 312: /* type_specifier_nonarray: U32VEC4 */ -#line 2295 "MachineIndependent/glslang.y" + case 318: /* type_specifier_nonarray: U32VEC4 */ +#line 2338 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 8789 "MachineIndependent/glslang_tab.cpp" +#line 9177 "MachineIndependent/glslang_tab.cpp" break; - case 313: /* type_specifier_nonarray: U64VEC2 */ -#line 2301 "MachineIndependent/glslang.y" + case 319: /* type_specifier_nonarray: U64VEC2 */ +#line 2344 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(2); } -#line 8800 "MachineIndependent/glslang_tab.cpp" +#line 9188 "MachineIndependent/glslang_tab.cpp" break; - case 314: /* type_specifier_nonarray: U64VEC3 */ -#line 2307 "MachineIndependent/glslang.y" + case 320: /* type_specifier_nonarray: U64VEC3 */ +#line 2350 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(3); } -#line 8811 "MachineIndependent/glslang_tab.cpp" +#line 9199 "MachineIndependent/glslang_tab.cpp" break; - case 315: /* type_specifier_nonarray: U64VEC4 */ -#line 2313 "MachineIndependent/glslang.y" + case 321: /* type_specifier_nonarray: U64VEC4 */ +#line 2356 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(4); } -#line 8822 "MachineIndependent/glslang_tab.cpp" +#line 9210 "MachineIndependent/glslang_tab.cpp" break; - case 316: /* type_specifier_nonarray: DMAT2 */ -#line 2319 "MachineIndependent/glslang.y" + case 322: /* type_specifier_nonarray: DMAT2 */ +#line 2362 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8831,11 +9219,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8835 "MachineIndependent/glslang_tab.cpp" +#line 9223 "MachineIndependent/glslang_tab.cpp" break; - case 317: /* type_specifier_nonarray: DMAT3 */ -#line 2327 "MachineIndependent/glslang.y" + case 323: /* type_specifier_nonarray: DMAT3 */ +#line 2370 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8844,11 +9232,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8848 "MachineIndependent/glslang_tab.cpp" +#line 9236 "MachineIndependent/glslang_tab.cpp" break; - case 318: /* type_specifier_nonarray: DMAT4 */ -#line 2335 "MachineIndependent/glslang.y" + case 324: /* type_specifier_nonarray: DMAT4 */ +#line 2378 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8857,11 +9245,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8861 "MachineIndependent/glslang_tab.cpp" +#line 9249 "MachineIndependent/glslang_tab.cpp" break; - case 319: /* type_specifier_nonarray: DMAT2X2 */ -#line 2343 "MachineIndependent/glslang.y" + case 325: /* type_specifier_nonarray: DMAT2X2 */ +#line 2386 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8870,11 +9258,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8874 "MachineIndependent/glslang_tab.cpp" +#line 9262 "MachineIndependent/glslang_tab.cpp" break; - case 320: /* type_specifier_nonarray: DMAT2X3 */ -#line 2351 "MachineIndependent/glslang.y" + case 326: /* type_specifier_nonarray: DMAT2X3 */ +#line 2394 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8883,11 +9271,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 8887 "MachineIndependent/glslang_tab.cpp" +#line 9275 "MachineIndependent/glslang_tab.cpp" break; - case 321: /* type_specifier_nonarray: DMAT2X4 */ -#line 2359 "MachineIndependent/glslang.y" + case 327: /* type_specifier_nonarray: DMAT2X4 */ +#line 2402 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8896,11 +9284,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 8900 "MachineIndependent/glslang_tab.cpp" +#line 9288 "MachineIndependent/glslang_tab.cpp" break; - case 322: /* type_specifier_nonarray: DMAT3X2 */ -#line 2367 "MachineIndependent/glslang.y" + case 328: /* type_specifier_nonarray: DMAT3X2 */ +#line 2410 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8909,11 +9297,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 8913 "MachineIndependent/glslang_tab.cpp" +#line 9301 "MachineIndependent/glslang_tab.cpp" break; - case 323: /* type_specifier_nonarray: DMAT3X3 */ -#line 2375 "MachineIndependent/glslang.y" + case 329: /* type_specifier_nonarray: DMAT3X3 */ +#line 2418 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8922,11 +9310,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8926 "MachineIndependent/glslang_tab.cpp" +#line 9314 "MachineIndependent/glslang_tab.cpp" break; - case 324: /* type_specifier_nonarray: DMAT3X4 */ -#line 2383 "MachineIndependent/glslang.y" + case 330: /* type_specifier_nonarray: DMAT3X4 */ +#line 2426 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8935,11 +9323,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 8939 "MachineIndependent/glslang_tab.cpp" +#line 9327 "MachineIndependent/glslang_tab.cpp" break; - case 325: /* type_specifier_nonarray: DMAT4X2 */ -#line 2391 "MachineIndependent/glslang.y" + case 331: /* type_specifier_nonarray: DMAT4X2 */ +#line 2434 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8948,11 +9336,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 8952 "MachineIndependent/glslang_tab.cpp" +#line 9340 "MachineIndependent/glslang_tab.cpp" break; - case 326: /* type_specifier_nonarray: DMAT4X3 */ -#line 2399 "MachineIndependent/glslang.y" + case 332: /* type_specifier_nonarray: DMAT4X3 */ +#line 2442 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8961,11 +9349,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 8965 "MachineIndependent/glslang_tab.cpp" +#line 9353 "MachineIndependent/glslang_tab.cpp" break; - case 327: /* type_specifier_nonarray: DMAT4X4 */ -#line 2407 "MachineIndependent/glslang.y" + case 333: /* type_specifier_nonarray: DMAT4X4 */ +#line 2450 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8974,2261 +9362,2261 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8978 "MachineIndependent/glslang_tab.cpp" +#line 9366 "MachineIndependent/glslang_tab.cpp" break; - case 328: /* type_specifier_nonarray: F16MAT2 */ -#line 2415 "MachineIndependent/glslang.y" + case 334: /* type_specifier_nonarray: F16MAT2 */ +#line 2458 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 8989 "MachineIndependent/glslang_tab.cpp" +#line 9377 "MachineIndependent/glslang_tab.cpp" break; - case 329: /* type_specifier_nonarray: F16MAT3 */ -#line 2421 "MachineIndependent/glslang.y" + case 335: /* type_specifier_nonarray: F16MAT3 */ +#line 2464 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 9000 "MachineIndependent/glslang_tab.cpp" +#line 9388 "MachineIndependent/glslang_tab.cpp" break; - case 330: /* type_specifier_nonarray: F16MAT4 */ -#line 2427 "MachineIndependent/glslang.y" + case 336: /* type_specifier_nonarray: F16MAT4 */ +#line 2470 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 9011 "MachineIndependent/glslang_tab.cpp" +#line 9399 "MachineIndependent/glslang_tab.cpp" break; - case 331: /* type_specifier_nonarray: F16MAT2X2 */ -#line 2433 "MachineIndependent/glslang.y" + case 337: /* type_specifier_nonarray: F16MAT2X2 */ +#line 2476 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 9022 "MachineIndependent/glslang_tab.cpp" +#line 9410 "MachineIndependent/glslang_tab.cpp" break; - case 332: /* type_specifier_nonarray: F16MAT2X3 */ -#line 2439 "MachineIndependent/glslang.y" + case 338: /* type_specifier_nonarray: F16MAT2X3 */ +#line 2482 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 3); } -#line 9033 "MachineIndependent/glslang_tab.cpp" +#line 9421 "MachineIndependent/glslang_tab.cpp" break; - case 333: /* type_specifier_nonarray: F16MAT2X4 */ -#line 2445 "MachineIndependent/glslang.y" + case 339: /* type_specifier_nonarray: F16MAT2X4 */ +#line 2488 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 4); } -#line 9044 "MachineIndependent/glslang_tab.cpp" +#line 9432 "MachineIndependent/glslang_tab.cpp" break; - case 334: /* type_specifier_nonarray: F16MAT3X2 */ -#line 2451 "MachineIndependent/glslang.y" + case 340: /* type_specifier_nonarray: F16MAT3X2 */ +#line 2494 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 2); } -#line 9055 "MachineIndependent/glslang_tab.cpp" +#line 9443 "MachineIndependent/glslang_tab.cpp" break; - case 335: /* type_specifier_nonarray: F16MAT3X3 */ -#line 2457 "MachineIndependent/glslang.y" + case 341: /* type_specifier_nonarray: F16MAT3X3 */ +#line 2500 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 9066 "MachineIndependent/glslang_tab.cpp" +#line 9454 "MachineIndependent/glslang_tab.cpp" break; - case 336: /* type_specifier_nonarray: F16MAT3X4 */ -#line 2463 "MachineIndependent/glslang.y" + case 342: /* type_specifier_nonarray: F16MAT3X4 */ +#line 2506 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 4); } -#line 9077 "MachineIndependent/glslang_tab.cpp" +#line 9465 "MachineIndependent/glslang_tab.cpp" break; - case 337: /* type_specifier_nonarray: F16MAT4X2 */ -#line 2469 "MachineIndependent/glslang.y" + case 343: /* type_specifier_nonarray: F16MAT4X2 */ +#line 2512 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 2); } -#line 9088 "MachineIndependent/glslang_tab.cpp" +#line 9476 "MachineIndependent/glslang_tab.cpp" break; - case 338: /* type_specifier_nonarray: F16MAT4X3 */ -#line 2475 "MachineIndependent/glslang.y" + case 344: /* type_specifier_nonarray: F16MAT4X3 */ +#line 2518 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 3); } -#line 9099 "MachineIndependent/glslang_tab.cpp" +#line 9487 "MachineIndependent/glslang_tab.cpp" break; - case 339: /* type_specifier_nonarray: F16MAT4X4 */ -#line 2481 "MachineIndependent/glslang.y" + case 345: /* type_specifier_nonarray: F16MAT4X4 */ +#line 2524 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 9110 "MachineIndependent/glslang_tab.cpp" +#line 9498 "MachineIndependent/glslang_tab.cpp" break; - case 340: /* type_specifier_nonarray: F32MAT2 */ -#line 2487 "MachineIndependent/glslang.y" + case 346: /* type_specifier_nonarray: F32MAT2 */ +#line 2530 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 9121 "MachineIndependent/glslang_tab.cpp" +#line 9509 "MachineIndependent/glslang_tab.cpp" break; - case 341: /* type_specifier_nonarray: F32MAT3 */ -#line 2493 "MachineIndependent/glslang.y" + case 347: /* type_specifier_nonarray: F32MAT3 */ +#line 2536 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 9132 "MachineIndependent/glslang_tab.cpp" +#line 9520 "MachineIndependent/glslang_tab.cpp" break; - case 342: /* type_specifier_nonarray: F32MAT4 */ -#line 2499 "MachineIndependent/glslang.y" + case 348: /* type_specifier_nonarray: F32MAT4 */ +#line 2542 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 9143 "MachineIndependent/glslang_tab.cpp" +#line 9531 "MachineIndependent/glslang_tab.cpp" break; - case 343: /* type_specifier_nonarray: F32MAT2X2 */ -#line 2505 "MachineIndependent/glslang.y" + case 349: /* type_specifier_nonarray: F32MAT2X2 */ +#line 2548 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 9154 "MachineIndependent/glslang_tab.cpp" +#line 9542 "MachineIndependent/glslang_tab.cpp" break; - case 344: /* type_specifier_nonarray: F32MAT2X3 */ -#line 2511 "MachineIndependent/glslang.y" + case 350: /* type_specifier_nonarray: F32MAT2X3 */ +#line 2554 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 9165 "MachineIndependent/glslang_tab.cpp" +#line 9553 "MachineIndependent/glslang_tab.cpp" break; - case 345: /* type_specifier_nonarray: F32MAT2X4 */ -#line 2517 "MachineIndependent/glslang.y" + case 351: /* type_specifier_nonarray: F32MAT2X4 */ +#line 2560 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 9176 "MachineIndependent/glslang_tab.cpp" +#line 9564 "MachineIndependent/glslang_tab.cpp" break; - case 346: /* type_specifier_nonarray: F32MAT3X2 */ -#line 2523 "MachineIndependent/glslang.y" + case 352: /* type_specifier_nonarray: F32MAT3X2 */ +#line 2566 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 9187 "MachineIndependent/glslang_tab.cpp" +#line 9575 "MachineIndependent/glslang_tab.cpp" break; - case 347: /* type_specifier_nonarray: F32MAT3X3 */ -#line 2529 "MachineIndependent/glslang.y" + case 353: /* type_specifier_nonarray: F32MAT3X3 */ +#line 2572 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 9198 "MachineIndependent/glslang_tab.cpp" +#line 9586 "MachineIndependent/glslang_tab.cpp" break; - case 348: /* type_specifier_nonarray: F32MAT3X4 */ -#line 2535 "MachineIndependent/glslang.y" + case 354: /* type_specifier_nonarray: F32MAT3X4 */ +#line 2578 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 9209 "MachineIndependent/glslang_tab.cpp" +#line 9597 "MachineIndependent/glslang_tab.cpp" break; - case 349: /* type_specifier_nonarray: F32MAT4X2 */ -#line 2541 "MachineIndependent/glslang.y" + case 355: /* type_specifier_nonarray: F32MAT4X2 */ +#line 2584 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 9220 "MachineIndependent/glslang_tab.cpp" +#line 9608 "MachineIndependent/glslang_tab.cpp" break; - case 350: /* type_specifier_nonarray: F32MAT4X3 */ -#line 2547 "MachineIndependent/glslang.y" + case 356: /* type_specifier_nonarray: F32MAT4X3 */ +#line 2590 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 9231 "MachineIndependent/glslang_tab.cpp" +#line 9619 "MachineIndependent/glslang_tab.cpp" break; - case 351: /* type_specifier_nonarray: F32MAT4X4 */ -#line 2553 "MachineIndependent/glslang.y" + case 357: /* type_specifier_nonarray: F32MAT4X4 */ +#line 2596 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 9242 "MachineIndependent/glslang_tab.cpp" +#line 9630 "MachineIndependent/glslang_tab.cpp" break; - case 352: /* type_specifier_nonarray: F64MAT2 */ -#line 2559 "MachineIndependent/glslang.y" + case 358: /* type_specifier_nonarray: F64MAT2 */ +#line 2602 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 9253 "MachineIndependent/glslang_tab.cpp" +#line 9641 "MachineIndependent/glslang_tab.cpp" break; - case 353: /* type_specifier_nonarray: F64MAT3 */ -#line 2565 "MachineIndependent/glslang.y" + case 359: /* type_specifier_nonarray: F64MAT3 */ +#line 2608 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 9264 "MachineIndependent/glslang_tab.cpp" +#line 9652 "MachineIndependent/glslang_tab.cpp" break; - case 354: /* type_specifier_nonarray: F64MAT4 */ -#line 2571 "MachineIndependent/glslang.y" + case 360: /* type_specifier_nonarray: F64MAT4 */ +#line 2614 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 9275 "MachineIndependent/glslang_tab.cpp" +#line 9663 "MachineIndependent/glslang_tab.cpp" break; - case 355: /* type_specifier_nonarray: F64MAT2X2 */ -#line 2577 "MachineIndependent/glslang.y" + case 361: /* type_specifier_nonarray: F64MAT2X2 */ +#line 2620 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 9286 "MachineIndependent/glslang_tab.cpp" +#line 9674 "MachineIndependent/glslang_tab.cpp" break; - case 356: /* type_specifier_nonarray: F64MAT2X3 */ -#line 2583 "MachineIndependent/glslang.y" + case 362: /* type_specifier_nonarray: F64MAT2X3 */ +#line 2626 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 9297 "MachineIndependent/glslang_tab.cpp" +#line 9685 "MachineIndependent/glslang_tab.cpp" break; - case 357: /* type_specifier_nonarray: F64MAT2X4 */ -#line 2589 "MachineIndependent/glslang.y" + case 363: /* type_specifier_nonarray: F64MAT2X4 */ +#line 2632 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 9308 "MachineIndependent/glslang_tab.cpp" +#line 9696 "MachineIndependent/glslang_tab.cpp" break; - case 358: /* type_specifier_nonarray: F64MAT3X2 */ -#line 2595 "MachineIndependent/glslang.y" + case 364: /* type_specifier_nonarray: F64MAT3X2 */ +#line 2638 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 9319 "MachineIndependent/glslang_tab.cpp" +#line 9707 "MachineIndependent/glslang_tab.cpp" break; - case 359: /* type_specifier_nonarray: F64MAT3X3 */ -#line 2601 "MachineIndependent/glslang.y" + case 365: /* type_specifier_nonarray: F64MAT3X3 */ +#line 2644 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 9330 "MachineIndependent/glslang_tab.cpp" +#line 9718 "MachineIndependent/glslang_tab.cpp" break; - case 360: /* type_specifier_nonarray: F64MAT3X4 */ -#line 2607 "MachineIndependent/glslang.y" + case 366: /* type_specifier_nonarray: F64MAT3X4 */ +#line 2650 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 9341 "MachineIndependent/glslang_tab.cpp" +#line 9729 "MachineIndependent/glslang_tab.cpp" break; - case 361: /* type_specifier_nonarray: F64MAT4X2 */ -#line 2613 "MachineIndependent/glslang.y" + case 367: /* type_specifier_nonarray: F64MAT4X2 */ +#line 2656 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 9352 "MachineIndependent/glslang_tab.cpp" +#line 9740 "MachineIndependent/glslang_tab.cpp" break; - case 362: /* type_specifier_nonarray: F64MAT4X3 */ -#line 2619 "MachineIndependent/glslang.y" + case 368: /* type_specifier_nonarray: F64MAT4X3 */ +#line 2662 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 9363 "MachineIndependent/glslang_tab.cpp" +#line 9751 "MachineIndependent/glslang_tab.cpp" break; - case 363: /* type_specifier_nonarray: F64MAT4X4 */ -#line 2625 "MachineIndependent/glslang.y" + case 369: /* type_specifier_nonarray: F64MAT4X4 */ +#line 2668 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 9374 "MachineIndependent/glslang_tab.cpp" +#line 9762 "MachineIndependent/glslang_tab.cpp" break; - case 364: /* type_specifier_nonarray: ACCSTRUCTNV */ -#line 2631 "MachineIndependent/glslang.y" + case 370: /* type_specifier_nonarray: ACCSTRUCTNV */ +#line 2674 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 9383 "MachineIndependent/glslang_tab.cpp" +#line 9771 "MachineIndependent/glslang_tab.cpp" break; - case 365: /* type_specifier_nonarray: ACCSTRUCTEXT */ -#line 2635 "MachineIndependent/glslang.y" + case 371: /* type_specifier_nonarray: ACCSTRUCTEXT */ +#line 2678 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 9392 "MachineIndependent/glslang_tab.cpp" +#line 9780 "MachineIndependent/glslang_tab.cpp" break; - case 366: /* type_specifier_nonarray: RAYQUERYEXT */ -#line 2639 "MachineIndependent/glslang.y" + case 372: /* type_specifier_nonarray: RAYQUERYEXT */ +#line 2682 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtRayQuery; } -#line 9401 "MachineIndependent/glslang_tab.cpp" +#line 9789 "MachineIndependent/glslang_tab.cpp" break; - case 367: /* type_specifier_nonarray: ATOMIC_UINT */ -#line 2643 "MachineIndependent/glslang.y" + case 373: /* type_specifier_nonarray: ATOMIC_UINT */ +#line 2686 "MachineIndependent/glslang.y" { parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAtomicUint; } -#line 9411 "MachineIndependent/glslang_tab.cpp" +#line 9799 "MachineIndependent/glslang_tab.cpp" break; - case 368: /* type_specifier_nonarray: SAMPLER1D */ -#line 2648 "MachineIndependent/glslang.y" + case 374: /* type_specifier_nonarray: SAMPLER1D */ +#line 2691 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D); } -#line 9421 "MachineIndependent/glslang_tab.cpp" +#line 9809 "MachineIndependent/glslang_tab.cpp" break; - case 369: /* type_specifier_nonarray: SAMPLER2D */ -#line 2653 "MachineIndependent/glslang.y" + case 375: /* type_specifier_nonarray: SAMPLER2D */ +#line 2696 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); } -#line 9431 "MachineIndependent/glslang_tab.cpp" +#line 9819 "MachineIndependent/glslang_tab.cpp" break; - case 370: /* type_specifier_nonarray: SAMPLER3D */ -#line 2658 "MachineIndependent/glslang.y" + case 376: /* type_specifier_nonarray: SAMPLER3D */ +#line 2701 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd3D); } -#line 9441 "MachineIndependent/glslang_tab.cpp" +#line 9829 "MachineIndependent/glslang_tab.cpp" break; - case 371: /* type_specifier_nonarray: SAMPLERCUBE */ -#line 2663 "MachineIndependent/glslang.y" + case 377: /* type_specifier_nonarray: SAMPLERCUBE */ +#line 2706 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube); } -#line 9451 "MachineIndependent/glslang_tab.cpp" +#line 9839 "MachineIndependent/glslang_tab.cpp" break; - case 372: /* type_specifier_nonarray: SAMPLER2DSHADOW */ -#line 2668 "MachineIndependent/glslang.y" + case 378: /* type_specifier_nonarray: SAMPLER2DSHADOW */ +#line 2711 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); } -#line 9461 "MachineIndependent/glslang_tab.cpp" +#line 9849 "MachineIndependent/glslang_tab.cpp" break; - case 373: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ -#line 2673 "MachineIndependent/glslang.y" + case 379: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ +#line 2716 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); } -#line 9471 "MachineIndependent/glslang_tab.cpp" +#line 9859 "MachineIndependent/glslang_tab.cpp" break; - case 374: /* type_specifier_nonarray: SAMPLER2DARRAY */ -#line 2678 "MachineIndependent/glslang.y" + case 380: /* type_specifier_nonarray: SAMPLER2DARRAY */ +#line 2721 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); } -#line 9481 "MachineIndependent/glslang_tab.cpp" +#line 9869 "MachineIndependent/glslang_tab.cpp" break; - case 375: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ -#line 2683 "MachineIndependent/glslang.y" + case 381: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ +#line 2726 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); } -#line 9491 "MachineIndependent/glslang_tab.cpp" +#line 9879 "MachineIndependent/glslang_tab.cpp" break; - case 376: /* type_specifier_nonarray: SAMPLER1DSHADOW */ -#line 2688 "MachineIndependent/glslang.y" + case 382: /* type_specifier_nonarray: SAMPLER1DSHADOW */ +#line 2731 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); } -#line 9501 "MachineIndependent/glslang_tab.cpp" +#line 9889 "MachineIndependent/glslang_tab.cpp" break; - case 377: /* type_specifier_nonarray: SAMPLER1DARRAY */ -#line 2693 "MachineIndependent/glslang.y" + case 383: /* type_specifier_nonarray: SAMPLER1DARRAY */ +#line 2736 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); } -#line 9511 "MachineIndependent/glslang_tab.cpp" +#line 9899 "MachineIndependent/glslang_tab.cpp" break; - case 378: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ -#line 2698 "MachineIndependent/glslang.y" + case 384: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ +#line 2741 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); } -#line 9521 "MachineIndependent/glslang_tab.cpp" +#line 9909 "MachineIndependent/glslang_tab.cpp" break; - case 379: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ -#line 2703 "MachineIndependent/glslang.y" + case 385: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ +#line 2746 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); } -#line 9531 "MachineIndependent/glslang_tab.cpp" +#line 9919 "MachineIndependent/glslang_tab.cpp" break; - case 380: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ -#line 2708 "MachineIndependent/glslang.y" + case 386: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ +#line 2751 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); } -#line 9541 "MachineIndependent/glslang_tab.cpp" +#line 9929 "MachineIndependent/glslang_tab.cpp" break; - case 381: /* type_specifier_nonarray: F16SAMPLER1D */ -#line 2713 "MachineIndependent/glslang.y" + case 387: /* type_specifier_nonarray: F16SAMPLER1D */ +#line 2756 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); } -#line 9552 "MachineIndependent/glslang_tab.cpp" +#line 9940 "MachineIndependent/glslang_tab.cpp" break; - case 382: /* type_specifier_nonarray: F16SAMPLER2D */ -#line 2719 "MachineIndependent/glslang.y" + case 388: /* type_specifier_nonarray: F16SAMPLER2D */ +#line 2762 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); } -#line 9563 "MachineIndependent/glslang_tab.cpp" +#line 9951 "MachineIndependent/glslang_tab.cpp" break; - case 383: /* type_specifier_nonarray: F16SAMPLER3D */ -#line 2725 "MachineIndependent/glslang.y" + case 389: /* type_specifier_nonarray: F16SAMPLER3D */ +#line 2768 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); } -#line 9574 "MachineIndependent/glslang_tab.cpp" +#line 9962 "MachineIndependent/glslang_tab.cpp" break; - case 384: /* type_specifier_nonarray: F16SAMPLERCUBE */ -#line 2731 "MachineIndependent/glslang.y" + case 390: /* type_specifier_nonarray: F16SAMPLERCUBE */ +#line 2774 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); } -#line 9585 "MachineIndependent/glslang_tab.cpp" +#line 9973 "MachineIndependent/glslang_tab.cpp" break; - case 385: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ -#line 2737 "MachineIndependent/glslang.y" + case 391: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ +#line 2780 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); } -#line 9596 "MachineIndependent/glslang_tab.cpp" +#line 9984 "MachineIndependent/glslang_tab.cpp" break; - case 386: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ -#line 2743 "MachineIndependent/glslang.y" + case 392: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ +#line 2786 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); } -#line 9607 "MachineIndependent/glslang_tab.cpp" +#line 9995 "MachineIndependent/glslang_tab.cpp" break; - case 387: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ -#line 2749 "MachineIndependent/glslang.y" + case 393: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ +#line 2792 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); } -#line 9618 "MachineIndependent/glslang_tab.cpp" +#line 10006 "MachineIndependent/glslang_tab.cpp" break; - case 388: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ -#line 2755 "MachineIndependent/glslang.y" + case 394: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ +#line 2798 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); } -#line 9629 "MachineIndependent/glslang_tab.cpp" +#line 10017 "MachineIndependent/glslang_tab.cpp" break; - case 389: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ -#line 2761 "MachineIndependent/glslang.y" + case 395: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ +#line 2804 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); } -#line 9640 "MachineIndependent/glslang_tab.cpp" +#line 10028 "MachineIndependent/glslang_tab.cpp" break; - case 390: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ -#line 2767 "MachineIndependent/glslang.y" + case 396: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ +#line 2810 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); } -#line 9651 "MachineIndependent/glslang_tab.cpp" +#line 10039 "MachineIndependent/glslang_tab.cpp" break; - case 391: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ -#line 2773 "MachineIndependent/glslang.y" + case 397: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ +#line 2816 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); } -#line 9662 "MachineIndependent/glslang_tab.cpp" +#line 10050 "MachineIndependent/glslang_tab.cpp" break; - case 392: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ -#line 2779 "MachineIndependent/glslang.y" + case 398: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ +#line 2822 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); } -#line 9673 "MachineIndependent/glslang_tab.cpp" +#line 10061 "MachineIndependent/glslang_tab.cpp" break; - case 393: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ -#line 2785 "MachineIndependent/glslang.y" + case 399: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ +#line 2828 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); } -#line 9684 "MachineIndependent/glslang_tab.cpp" +#line 10072 "MachineIndependent/glslang_tab.cpp" break; - case 394: /* type_specifier_nonarray: ISAMPLER1D */ -#line 2791 "MachineIndependent/glslang.y" + case 400: /* type_specifier_nonarray: ISAMPLER1D */ +#line 2834 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D); } -#line 9694 "MachineIndependent/glslang_tab.cpp" +#line 10082 "MachineIndependent/glslang_tab.cpp" break; - case 395: /* type_specifier_nonarray: ISAMPLER2D */ -#line 2796 "MachineIndependent/glslang.y" + case 401: /* type_specifier_nonarray: ISAMPLER2D */ +#line 2839 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D); } -#line 9704 "MachineIndependent/glslang_tab.cpp" +#line 10092 "MachineIndependent/glslang_tab.cpp" break; - case 396: /* type_specifier_nonarray: ISAMPLER3D */ -#line 2801 "MachineIndependent/glslang.y" + case 402: /* type_specifier_nonarray: ISAMPLER3D */ +#line 2844 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd3D); } -#line 9714 "MachineIndependent/glslang_tab.cpp" +#line 10102 "MachineIndependent/glslang_tab.cpp" break; - case 397: /* type_specifier_nonarray: ISAMPLERCUBE */ -#line 2806 "MachineIndependent/glslang.y" + case 403: /* type_specifier_nonarray: ISAMPLERCUBE */ +#line 2849 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube); } -#line 9724 "MachineIndependent/glslang_tab.cpp" +#line 10112 "MachineIndependent/glslang_tab.cpp" break; - case 398: /* type_specifier_nonarray: ISAMPLER2DARRAY */ -#line 2811 "MachineIndependent/glslang.y" + case 404: /* type_specifier_nonarray: ISAMPLER2DARRAY */ +#line 2854 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); } -#line 9734 "MachineIndependent/glslang_tab.cpp" +#line 10122 "MachineIndependent/glslang_tab.cpp" break; - case 399: /* type_specifier_nonarray: USAMPLER2D */ -#line 2816 "MachineIndependent/glslang.y" + case 405: /* type_specifier_nonarray: USAMPLER2D */ +#line 2859 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D); } -#line 9744 "MachineIndependent/glslang_tab.cpp" +#line 10132 "MachineIndependent/glslang_tab.cpp" break; - case 400: /* type_specifier_nonarray: USAMPLER3D */ -#line 2821 "MachineIndependent/glslang.y" + case 406: /* type_specifier_nonarray: USAMPLER3D */ +#line 2864 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd3D); } -#line 9754 "MachineIndependent/glslang_tab.cpp" +#line 10142 "MachineIndependent/glslang_tab.cpp" break; - case 401: /* type_specifier_nonarray: USAMPLERCUBE */ -#line 2826 "MachineIndependent/glslang.y" + case 407: /* type_specifier_nonarray: USAMPLERCUBE */ +#line 2869 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube); } -#line 9764 "MachineIndependent/glslang_tab.cpp" +#line 10152 "MachineIndependent/glslang_tab.cpp" break; - case 402: /* type_specifier_nonarray: ISAMPLER1DARRAY */ -#line 2831 "MachineIndependent/glslang.y" + case 408: /* type_specifier_nonarray: ISAMPLER1DARRAY */ +#line 2874 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); } -#line 9774 "MachineIndependent/glslang_tab.cpp" +#line 10162 "MachineIndependent/glslang_tab.cpp" break; - case 403: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ -#line 2836 "MachineIndependent/glslang.y" + case 409: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ +#line 2879 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); } -#line 9784 "MachineIndependent/glslang_tab.cpp" +#line 10172 "MachineIndependent/glslang_tab.cpp" break; - case 404: /* type_specifier_nonarray: USAMPLER1D */ -#line 2841 "MachineIndependent/glslang.y" + case 410: /* type_specifier_nonarray: USAMPLER1D */ +#line 2884 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D); } -#line 9794 "MachineIndependent/glslang_tab.cpp" +#line 10182 "MachineIndependent/glslang_tab.cpp" break; - case 405: /* type_specifier_nonarray: USAMPLER1DARRAY */ -#line 2846 "MachineIndependent/glslang.y" + case 411: /* type_specifier_nonarray: USAMPLER1DARRAY */ +#line 2889 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); } -#line 9804 "MachineIndependent/glslang_tab.cpp" +#line 10192 "MachineIndependent/glslang_tab.cpp" break; - case 406: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ -#line 2851 "MachineIndependent/glslang.y" + case 412: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ +#line 2894 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); } -#line 9814 "MachineIndependent/glslang_tab.cpp" +#line 10202 "MachineIndependent/glslang_tab.cpp" break; - case 407: /* type_specifier_nonarray: TEXTURECUBEARRAY */ -#line 2856 "MachineIndependent/glslang.y" + case 413: /* type_specifier_nonarray: TEXTURECUBEARRAY */ +#line 2899 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); } -#line 9824 "MachineIndependent/glslang_tab.cpp" +#line 10212 "MachineIndependent/glslang_tab.cpp" break; - case 408: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ -#line 2861 "MachineIndependent/glslang.y" + case 414: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ +#line 2904 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); } -#line 9834 "MachineIndependent/glslang_tab.cpp" +#line 10222 "MachineIndependent/glslang_tab.cpp" break; - case 409: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ -#line 2866 "MachineIndependent/glslang.y" + case 415: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ +#line 2909 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); } -#line 9844 "MachineIndependent/glslang_tab.cpp" +#line 10232 "MachineIndependent/glslang_tab.cpp" break; - case 410: /* type_specifier_nonarray: USAMPLER2DARRAY */ -#line 2871 "MachineIndependent/glslang.y" + case 416: /* type_specifier_nonarray: USAMPLER2DARRAY */ +#line 2914 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); } -#line 9854 "MachineIndependent/glslang_tab.cpp" +#line 10242 "MachineIndependent/glslang_tab.cpp" break; - case 411: /* type_specifier_nonarray: TEXTURE2D */ -#line 2876 "MachineIndependent/glslang.y" + case 417: /* type_specifier_nonarray: TEXTURE2D */ +#line 2919 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); } -#line 9864 "MachineIndependent/glslang_tab.cpp" +#line 10252 "MachineIndependent/glslang_tab.cpp" break; - case 412: /* type_specifier_nonarray: TEXTURE3D */ -#line 2881 "MachineIndependent/glslang.y" + case 418: /* type_specifier_nonarray: TEXTURE3D */ +#line 2924 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); } -#line 9874 "MachineIndependent/glslang_tab.cpp" +#line 10262 "MachineIndependent/glslang_tab.cpp" break; - case 413: /* type_specifier_nonarray: TEXTURE2DARRAY */ -#line 2886 "MachineIndependent/glslang.y" + case 419: /* type_specifier_nonarray: TEXTURE2DARRAY */ +#line 2929 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); } -#line 9884 "MachineIndependent/glslang_tab.cpp" +#line 10272 "MachineIndependent/glslang_tab.cpp" break; - case 414: /* type_specifier_nonarray: TEXTURECUBE */ -#line 2891 "MachineIndependent/glslang.y" + case 420: /* type_specifier_nonarray: TEXTURECUBE */ +#line 2934 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); } -#line 9894 "MachineIndependent/glslang_tab.cpp" +#line 10282 "MachineIndependent/glslang_tab.cpp" break; - case 415: /* type_specifier_nonarray: ITEXTURE2D */ -#line 2896 "MachineIndependent/glslang.y" + case 421: /* type_specifier_nonarray: ITEXTURE2D */ +#line 2939 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); } -#line 9904 "MachineIndependent/glslang_tab.cpp" +#line 10292 "MachineIndependent/glslang_tab.cpp" break; - case 416: /* type_specifier_nonarray: ITEXTURE3D */ -#line 2901 "MachineIndependent/glslang.y" + case 422: /* type_specifier_nonarray: ITEXTURE3D */ +#line 2944 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); } -#line 9914 "MachineIndependent/glslang_tab.cpp" +#line 10302 "MachineIndependent/glslang_tab.cpp" break; - case 417: /* type_specifier_nonarray: ITEXTURECUBE */ -#line 2906 "MachineIndependent/glslang.y" + case 423: /* type_specifier_nonarray: ITEXTURECUBE */ +#line 2949 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); } -#line 9924 "MachineIndependent/glslang_tab.cpp" +#line 10312 "MachineIndependent/glslang_tab.cpp" break; - case 418: /* type_specifier_nonarray: ITEXTURE2DARRAY */ -#line 2911 "MachineIndependent/glslang.y" + case 424: /* type_specifier_nonarray: ITEXTURE2DARRAY */ +#line 2954 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); } -#line 9934 "MachineIndependent/glslang_tab.cpp" +#line 10322 "MachineIndependent/glslang_tab.cpp" break; - case 419: /* type_specifier_nonarray: UTEXTURE2D */ -#line 2916 "MachineIndependent/glslang.y" + case 425: /* type_specifier_nonarray: UTEXTURE2D */ +#line 2959 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); } -#line 9944 "MachineIndependent/glslang_tab.cpp" +#line 10332 "MachineIndependent/glslang_tab.cpp" break; - case 420: /* type_specifier_nonarray: UTEXTURE3D */ -#line 2921 "MachineIndependent/glslang.y" + case 426: /* type_specifier_nonarray: UTEXTURE3D */ +#line 2964 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); } -#line 9954 "MachineIndependent/glslang_tab.cpp" +#line 10342 "MachineIndependent/glslang_tab.cpp" break; - case 421: /* type_specifier_nonarray: UTEXTURECUBE */ -#line 2926 "MachineIndependent/glslang.y" + case 427: /* type_specifier_nonarray: UTEXTURECUBE */ +#line 2969 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); } -#line 9964 "MachineIndependent/glslang_tab.cpp" +#line 10352 "MachineIndependent/glslang_tab.cpp" break; - case 422: /* type_specifier_nonarray: UTEXTURE2DARRAY */ -#line 2931 "MachineIndependent/glslang.y" + case 428: /* type_specifier_nonarray: UTEXTURE2DARRAY */ +#line 2974 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); } -#line 9974 "MachineIndependent/glslang_tab.cpp" +#line 10362 "MachineIndependent/glslang_tab.cpp" break; - case 423: /* type_specifier_nonarray: SAMPLER */ -#line 2936 "MachineIndependent/glslang.y" + case 429: /* type_specifier_nonarray: SAMPLER */ +#line 2979 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(false); } -#line 9984 "MachineIndependent/glslang_tab.cpp" +#line 10372 "MachineIndependent/glslang_tab.cpp" break; - case 424: /* type_specifier_nonarray: SAMPLERSHADOW */ -#line 2941 "MachineIndependent/glslang.y" + case 430: /* type_specifier_nonarray: SAMPLERSHADOW */ +#line 2984 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(true); } -#line 9994 "MachineIndependent/glslang_tab.cpp" +#line 10382 "MachineIndependent/glslang_tab.cpp" break; - case 425: /* type_specifier_nonarray: SAMPLER2DRECT */ -#line 2946 "MachineIndependent/glslang.y" + case 431: /* type_specifier_nonarray: SAMPLER2DRECT */ +#line 2989 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect); } -#line 10004 "MachineIndependent/glslang_tab.cpp" +#line 10392 "MachineIndependent/glslang_tab.cpp" break; - case 426: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ -#line 2951 "MachineIndependent/glslang.y" + case 432: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ +#line 2994 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); } -#line 10014 "MachineIndependent/glslang_tab.cpp" +#line 10402 "MachineIndependent/glslang_tab.cpp" break; - case 427: /* type_specifier_nonarray: F16SAMPLER2DRECT */ -#line 2956 "MachineIndependent/glslang.y" + case 433: /* type_specifier_nonarray: F16SAMPLER2DRECT */ +#line 2999 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); } -#line 10025 "MachineIndependent/glslang_tab.cpp" +#line 10413 "MachineIndependent/glslang_tab.cpp" break; - case 428: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ -#line 2962 "MachineIndependent/glslang.y" + case 434: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ +#line 3005 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); } -#line 10036 "MachineIndependent/glslang_tab.cpp" +#line 10424 "MachineIndependent/glslang_tab.cpp" break; - case 429: /* type_specifier_nonarray: ISAMPLER2DRECT */ -#line 2968 "MachineIndependent/glslang.y" + case 435: /* type_specifier_nonarray: ISAMPLER2DRECT */ +#line 3011 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdRect); } -#line 10046 "MachineIndependent/glslang_tab.cpp" +#line 10434 "MachineIndependent/glslang_tab.cpp" break; - case 430: /* type_specifier_nonarray: USAMPLER2DRECT */ -#line 2973 "MachineIndependent/glslang.y" + case 436: /* type_specifier_nonarray: USAMPLER2DRECT */ +#line 3016 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdRect); } -#line 10056 "MachineIndependent/glslang_tab.cpp" +#line 10444 "MachineIndependent/glslang_tab.cpp" break; - case 431: /* type_specifier_nonarray: SAMPLERBUFFER */ -#line 2978 "MachineIndependent/glslang.y" + case 437: /* type_specifier_nonarray: SAMPLERBUFFER */ +#line 3021 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); } -#line 10066 "MachineIndependent/glslang_tab.cpp" +#line 10454 "MachineIndependent/glslang_tab.cpp" break; - case 432: /* type_specifier_nonarray: F16SAMPLERBUFFER */ -#line 2983 "MachineIndependent/glslang.y" + case 438: /* type_specifier_nonarray: F16SAMPLERBUFFER */ +#line 3026 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); } -#line 10077 "MachineIndependent/glslang_tab.cpp" +#line 10465 "MachineIndependent/glslang_tab.cpp" break; - case 433: /* type_specifier_nonarray: ISAMPLERBUFFER */ -#line 2989 "MachineIndependent/glslang.y" + case 439: /* type_specifier_nonarray: ISAMPLERBUFFER */ +#line 3032 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); } -#line 10087 "MachineIndependent/glslang_tab.cpp" +#line 10475 "MachineIndependent/glslang_tab.cpp" break; - case 434: /* type_specifier_nonarray: USAMPLERBUFFER */ -#line 2994 "MachineIndependent/glslang.y" + case 440: /* type_specifier_nonarray: USAMPLERBUFFER */ +#line 3037 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); } -#line 10097 "MachineIndependent/glslang_tab.cpp" +#line 10485 "MachineIndependent/glslang_tab.cpp" break; - case 435: /* type_specifier_nonarray: SAMPLER2DMS */ -#line 2999 "MachineIndependent/glslang.y" + case 441: /* type_specifier_nonarray: SAMPLER2DMS */ +#line 3042 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); } -#line 10107 "MachineIndependent/glslang_tab.cpp" +#line 10495 "MachineIndependent/glslang_tab.cpp" break; - case 436: /* type_specifier_nonarray: F16SAMPLER2DMS */ -#line 3004 "MachineIndependent/glslang.y" + case 442: /* type_specifier_nonarray: F16SAMPLER2DMS */ +#line 3047 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); } -#line 10118 "MachineIndependent/glslang_tab.cpp" +#line 10506 "MachineIndependent/glslang_tab.cpp" break; - case 437: /* type_specifier_nonarray: ISAMPLER2DMS */ -#line 3010 "MachineIndependent/glslang.y" + case 443: /* type_specifier_nonarray: ISAMPLER2DMS */ +#line 3053 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 10128 "MachineIndependent/glslang_tab.cpp" +#line 10516 "MachineIndependent/glslang_tab.cpp" break; - case 438: /* type_specifier_nonarray: USAMPLER2DMS */ -#line 3015 "MachineIndependent/glslang.y" + case 444: /* type_specifier_nonarray: USAMPLER2DMS */ +#line 3058 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 10138 "MachineIndependent/glslang_tab.cpp" +#line 10526 "MachineIndependent/glslang_tab.cpp" break; - case 439: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ -#line 3020 "MachineIndependent/glslang.y" + case 445: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ +#line 3063 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 10148 "MachineIndependent/glslang_tab.cpp" +#line 10536 "MachineIndependent/glslang_tab.cpp" break; - case 440: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ -#line 3025 "MachineIndependent/glslang.y" + case 446: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ +#line 3068 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); } -#line 10159 "MachineIndependent/glslang_tab.cpp" +#line 10547 "MachineIndependent/glslang_tab.cpp" break; - case 441: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ -#line 3031 "MachineIndependent/glslang.y" + case 447: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ +#line 3074 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); } -#line 10169 "MachineIndependent/glslang_tab.cpp" +#line 10557 "MachineIndependent/glslang_tab.cpp" break; - case 442: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ -#line 3036 "MachineIndependent/glslang.y" + case 448: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ +#line 3079 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); } -#line 10179 "MachineIndependent/glslang_tab.cpp" +#line 10567 "MachineIndependent/glslang_tab.cpp" break; - case 443: /* type_specifier_nonarray: TEXTURE1D */ -#line 3041 "MachineIndependent/glslang.y" + case 449: /* type_specifier_nonarray: TEXTURE1D */ +#line 3084 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); } -#line 10189 "MachineIndependent/glslang_tab.cpp" +#line 10577 "MachineIndependent/glslang_tab.cpp" break; - case 444: /* type_specifier_nonarray: F16TEXTURE1D */ -#line 3046 "MachineIndependent/glslang.y" + case 450: /* type_specifier_nonarray: F16TEXTURE1D */ +#line 3089 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); } -#line 10200 "MachineIndependent/glslang_tab.cpp" +#line 10588 "MachineIndependent/glslang_tab.cpp" break; - case 445: /* type_specifier_nonarray: F16TEXTURE2D */ -#line 3052 "MachineIndependent/glslang.y" + case 451: /* type_specifier_nonarray: F16TEXTURE2D */ +#line 3095 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); } -#line 10211 "MachineIndependent/glslang_tab.cpp" +#line 10599 "MachineIndependent/glslang_tab.cpp" break; - case 446: /* type_specifier_nonarray: F16TEXTURE3D */ -#line 3058 "MachineIndependent/glslang.y" + case 452: /* type_specifier_nonarray: F16TEXTURE3D */ +#line 3101 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); } -#line 10222 "MachineIndependent/glslang_tab.cpp" +#line 10610 "MachineIndependent/glslang_tab.cpp" break; - case 447: /* type_specifier_nonarray: F16TEXTURECUBE */ -#line 3064 "MachineIndependent/glslang.y" + case 453: /* type_specifier_nonarray: F16TEXTURECUBE */ +#line 3107 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); } -#line 10233 "MachineIndependent/glslang_tab.cpp" +#line 10621 "MachineIndependent/glslang_tab.cpp" break; - case 448: /* type_specifier_nonarray: TEXTURE1DARRAY */ -#line 3070 "MachineIndependent/glslang.y" + case 454: /* type_specifier_nonarray: TEXTURE1DARRAY */ +#line 3113 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); } -#line 10243 "MachineIndependent/glslang_tab.cpp" +#line 10631 "MachineIndependent/glslang_tab.cpp" break; - case 449: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ -#line 3075 "MachineIndependent/glslang.y" + case 455: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ +#line 3118 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); } -#line 10254 "MachineIndependent/glslang_tab.cpp" +#line 10642 "MachineIndependent/glslang_tab.cpp" break; - case 450: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ -#line 3081 "MachineIndependent/glslang.y" + case 456: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ +#line 3124 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); } -#line 10265 "MachineIndependent/glslang_tab.cpp" +#line 10653 "MachineIndependent/glslang_tab.cpp" break; - case 451: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ -#line 3087 "MachineIndependent/glslang.y" + case 457: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ +#line 3130 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); } -#line 10276 "MachineIndependent/glslang_tab.cpp" +#line 10664 "MachineIndependent/glslang_tab.cpp" break; - case 452: /* type_specifier_nonarray: ITEXTURE1D */ -#line 3093 "MachineIndependent/glslang.y" + case 458: /* type_specifier_nonarray: ITEXTURE1D */ +#line 3136 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 10286 "MachineIndependent/glslang_tab.cpp" +#line 10674 "MachineIndependent/glslang_tab.cpp" break; - case 453: /* type_specifier_nonarray: ITEXTURE1DARRAY */ -#line 3098 "MachineIndependent/glslang.y" + case 459: /* type_specifier_nonarray: ITEXTURE1DARRAY */ +#line 3141 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 10296 "MachineIndependent/glslang_tab.cpp" +#line 10684 "MachineIndependent/glslang_tab.cpp" break; - case 454: /* type_specifier_nonarray: UTEXTURE1D */ -#line 3103 "MachineIndependent/glslang.y" + case 460: /* type_specifier_nonarray: UTEXTURE1D */ +#line 3146 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 10306 "MachineIndependent/glslang_tab.cpp" +#line 10694 "MachineIndependent/glslang_tab.cpp" break; - case 455: /* type_specifier_nonarray: UTEXTURE1DARRAY */ -#line 3108 "MachineIndependent/glslang.y" + case 461: /* type_specifier_nonarray: UTEXTURE1DARRAY */ +#line 3151 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); } -#line 10316 "MachineIndependent/glslang_tab.cpp" +#line 10704 "MachineIndependent/glslang_tab.cpp" break; - case 456: /* type_specifier_nonarray: TEXTURE2DRECT */ -#line 3113 "MachineIndependent/glslang.y" + case 462: /* type_specifier_nonarray: TEXTURE2DRECT */ +#line 3156 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); } -#line 10326 "MachineIndependent/glslang_tab.cpp" +#line 10714 "MachineIndependent/glslang_tab.cpp" break; - case 457: /* type_specifier_nonarray: F16TEXTURE2DRECT */ -#line 3118 "MachineIndependent/glslang.y" + case 463: /* type_specifier_nonarray: F16TEXTURE2DRECT */ +#line 3161 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); } -#line 10337 "MachineIndependent/glslang_tab.cpp" +#line 10725 "MachineIndependent/glslang_tab.cpp" break; - case 458: /* type_specifier_nonarray: ITEXTURE2DRECT */ -#line 3124 "MachineIndependent/glslang.y" + case 464: /* type_specifier_nonarray: ITEXTURE2DRECT */ +#line 3167 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 10347 "MachineIndependent/glslang_tab.cpp" +#line 10735 "MachineIndependent/glslang_tab.cpp" break; - case 459: /* type_specifier_nonarray: UTEXTURE2DRECT */ -#line 3129 "MachineIndependent/glslang.y" + case 465: /* type_specifier_nonarray: UTEXTURE2DRECT */ +#line 3172 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); } -#line 10357 "MachineIndependent/glslang_tab.cpp" +#line 10745 "MachineIndependent/glslang_tab.cpp" break; - case 460: /* type_specifier_nonarray: TEXTUREBUFFER */ -#line 3134 "MachineIndependent/glslang.y" + case 466: /* type_specifier_nonarray: TEXTUREBUFFER */ +#line 3177 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); } -#line 10367 "MachineIndependent/glslang_tab.cpp" +#line 10755 "MachineIndependent/glslang_tab.cpp" break; - case 461: /* type_specifier_nonarray: F16TEXTUREBUFFER */ -#line 3139 "MachineIndependent/glslang.y" + case 467: /* type_specifier_nonarray: F16TEXTUREBUFFER */ +#line 3182 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); } -#line 10378 "MachineIndependent/glslang_tab.cpp" +#line 10766 "MachineIndependent/glslang_tab.cpp" break; - case 462: /* type_specifier_nonarray: ITEXTUREBUFFER */ -#line 3145 "MachineIndependent/glslang.y" + case 468: /* type_specifier_nonarray: ITEXTUREBUFFER */ +#line 3188 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 10388 "MachineIndependent/glslang_tab.cpp" +#line 10776 "MachineIndependent/glslang_tab.cpp" break; - case 463: /* type_specifier_nonarray: UTEXTUREBUFFER */ -#line 3150 "MachineIndependent/glslang.y" + case 469: /* type_specifier_nonarray: UTEXTUREBUFFER */ +#line 3193 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); } -#line 10398 "MachineIndependent/glslang_tab.cpp" +#line 10786 "MachineIndependent/glslang_tab.cpp" break; - case 464: /* type_specifier_nonarray: TEXTURE2DMS */ -#line 3155 "MachineIndependent/glslang.y" + case 470: /* type_specifier_nonarray: TEXTURE2DMS */ +#line 3198 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); } -#line 10408 "MachineIndependent/glslang_tab.cpp" +#line 10796 "MachineIndependent/glslang_tab.cpp" break; - case 465: /* type_specifier_nonarray: F16TEXTURE2DMS */ -#line 3160 "MachineIndependent/glslang.y" + case 471: /* type_specifier_nonarray: F16TEXTURE2DMS */ +#line 3203 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); } -#line 10419 "MachineIndependent/glslang_tab.cpp" +#line 10807 "MachineIndependent/glslang_tab.cpp" break; - case 466: /* type_specifier_nonarray: ITEXTURE2DMS */ -#line 3166 "MachineIndependent/glslang.y" + case 472: /* type_specifier_nonarray: ITEXTURE2DMS */ +#line 3209 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); } -#line 10429 "MachineIndependent/glslang_tab.cpp" +#line 10817 "MachineIndependent/glslang_tab.cpp" break; - case 467: /* type_specifier_nonarray: UTEXTURE2DMS */ -#line 3171 "MachineIndependent/glslang.y" + case 473: /* type_specifier_nonarray: UTEXTURE2DMS */ +#line 3214 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); } -#line 10439 "MachineIndependent/glslang_tab.cpp" +#line 10827 "MachineIndependent/glslang_tab.cpp" break; - case 468: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ -#line 3176 "MachineIndependent/glslang.y" + case 474: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ +#line 3219 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); } -#line 10449 "MachineIndependent/glslang_tab.cpp" +#line 10837 "MachineIndependent/glslang_tab.cpp" break; - case 469: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ -#line 3181 "MachineIndependent/glslang.y" + case 475: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ +#line 3224 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); } -#line 10460 "MachineIndependent/glslang_tab.cpp" +#line 10848 "MachineIndependent/glslang_tab.cpp" break; - case 470: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ -#line 3187 "MachineIndependent/glslang.y" + case 476: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ +#line 3230 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); } -#line 10470 "MachineIndependent/glslang_tab.cpp" +#line 10858 "MachineIndependent/glslang_tab.cpp" break; - case 471: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ -#line 3192 "MachineIndependent/glslang.y" + case 477: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ +#line 3235 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); } -#line 10480 "MachineIndependent/glslang_tab.cpp" +#line 10868 "MachineIndependent/glslang_tab.cpp" break; - case 472: /* type_specifier_nonarray: IMAGE1D */ -#line 3197 "MachineIndependent/glslang.y" + case 478: /* type_specifier_nonarray: IMAGE1D */ +#line 3240 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 10490 "MachineIndependent/glslang_tab.cpp" +#line 10878 "MachineIndependent/glslang_tab.cpp" break; - case 473: /* type_specifier_nonarray: F16IMAGE1D */ -#line 3202 "MachineIndependent/glslang.y" + case 479: /* type_specifier_nonarray: F16IMAGE1D */ +#line 3245 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); } -#line 10501 "MachineIndependent/glslang_tab.cpp" +#line 10889 "MachineIndependent/glslang_tab.cpp" break; - case 474: /* type_specifier_nonarray: IIMAGE1D */ -#line 3208 "MachineIndependent/glslang.y" + case 480: /* type_specifier_nonarray: IIMAGE1D */ +#line 3251 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); } -#line 10511 "MachineIndependent/glslang_tab.cpp" +#line 10899 "MachineIndependent/glslang_tab.cpp" break; - case 475: /* type_specifier_nonarray: UIMAGE1D */ -#line 3213 "MachineIndependent/glslang.y" + case 481: /* type_specifier_nonarray: UIMAGE1D */ +#line 3256 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); } -#line 10521 "MachineIndependent/glslang_tab.cpp" +#line 10909 "MachineIndependent/glslang_tab.cpp" break; - case 476: /* type_specifier_nonarray: IMAGE2D */ -#line 3218 "MachineIndependent/glslang.y" + case 482: /* type_specifier_nonarray: IMAGE2D */ +#line 3261 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); } -#line 10531 "MachineIndependent/glslang_tab.cpp" +#line 10919 "MachineIndependent/glslang_tab.cpp" break; - case 477: /* type_specifier_nonarray: F16IMAGE2D */ -#line 3223 "MachineIndependent/glslang.y" + case 483: /* type_specifier_nonarray: F16IMAGE2D */ +#line 3266 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); } -#line 10542 "MachineIndependent/glslang_tab.cpp" +#line 10930 "MachineIndependent/glslang_tab.cpp" break; - case 478: /* type_specifier_nonarray: IIMAGE2D */ -#line 3229 "MachineIndependent/glslang.y" + case 484: /* type_specifier_nonarray: IIMAGE2D */ +#line 3272 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); } -#line 10552 "MachineIndependent/glslang_tab.cpp" +#line 10940 "MachineIndependent/glslang_tab.cpp" break; - case 479: /* type_specifier_nonarray: UIMAGE2D */ -#line 3234 "MachineIndependent/glslang.y" + case 485: /* type_specifier_nonarray: UIMAGE2D */ +#line 3277 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); } -#line 10562 "MachineIndependent/glslang_tab.cpp" +#line 10950 "MachineIndependent/glslang_tab.cpp" break; - case 480: /* type_specifier_nonarray: IMAGE3D */ -#line 3239 "MachineIndependent/glslang.y" + case 486: /* type_specifier_nonarray: IMAGE3D */ +#line 3282 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); } -#line 10572 "MachineIndependent/glslang_tab.cpp" +#line 10960 "MachineIndependent/glslang_tab.cpp" break; - case 481: /* type_specifier_nonarray: F16IMAGE3D */ -#line 3244 "MachineIndependent/glslang.y" + case 487: /* type_specifier_nonarray: F16IMAGE3D */ +#line 3287 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); } -#line 10583 "MachineIndependent/glslang_tab.cpp" +#line 10971 "MachineIndependent/glslang_tab.cpp" break; - case 482: /* type_specifier_nonarray: IIMAGE3D */ -#line 3250 "MachineIndependent/glslang.y" + case 488: /* type_specifier_nonarray: IIMAGE3D */ +#line 3293 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); } -#line 10593 "MachineIndependent/glslang_tab.cpp" +#line 10981 "MachineIndependent/glslang_tab.cpp" break; - case 483: /* type_specifier_nonarray: UIMAGE3D */ -#line 3255 "MachineIndependent/glslang.y" + case 489: /* type_specifier_nonarray: UIMAGE3D */ +#line 3298 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); } -#line 10603 "MachineIndependent/glslang_tab.cpp" +#line 10991 "MachineIndependent/glslang_tab.cpp" break; - case 484: /* type_specifier_nonarray: IMAGE2DRECT */ -#line 3260 "MachineIndependent/glslang.y" + case 490: /* type_specifier_nonarray: IMAGE2DRECT */ +#line 3303 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); } -#line 10613 "MachineIndependent/glslang_tab.cpp" +#line 11001 "MachineIndependent/glslang_tab.cpp" break; - case 485: /* type_specifier_nonarray: F16IMAGE2DRECT */ -#line 3265 "MachineIndependent/glslang.y" + case 491: /* type_specifier_nonarray: F16IMAGE2DRECT */ +#line 3308 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); } -#line 10624 "MachineIndependent/glslang_tab.cpp" +#line 11012 "MachineIndependent/glslang_tab.cpp" break; - case 486: /* type_specifier_nonarray: IIMAGE2DRECT */ -#line 3271 "MachineIndependent/glslang.y" + case 492: /* type_specifier_nonarray: IIMAGE2DRECT */ +#line 3314 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); } -#line 10634 "MachineIndependent/glslang_tab.cpp" +#line 11022 "MachineIndependent/glslang_tab.cpp" break; - case 487: /* type_specifier_nonarray: UIMAGE2DRECT */ -#line 3276 "MachineIndependent/glslang.y" + case 493: /* type_specifier_nonarray: UIMAGE2DRECT */ +#line 3319 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); } -#line 10644 "MachineIndependent/glslang_tab.cpp" +#line 11032 "MachineIndependent/glslang_tab.cpp" break; - case 488: /* type_specifier_nonarray: IMAGECUBE */ -#line 3281 "MachineIndependent/glslang.y" + case 494: /* type_specifier_nonarray: IMAGECUBE */ +#line 3324 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); } -#line 10654 "MachineIndependent/glslang_tab.cpp" +#line 11042 "MachineIndependent/glslang_tab.cpp" break; - case 489: /* type_specifier_nonarray: F16IMAGECUBE */ -#line 3286 "MachineIndependent/glslang.y" + case 495: /* type_specifier_nonarray: F16IMAGECUBE */ +#line 3329 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); } -#line 10665 "MachineIndependent/glslang_tab.cpp" +#line 11053 "MachineIndependent/glslang_tab.cpp" break; - case 490: /* type_specifier_nonarray: IIMAGECUBE */ -#line 3292 "MachineIndependent/glslang.y" + case 496: /* type_specifier_nonarray: IIMAGECUBE */ +#line 3335 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); } -#line 10675 "MachineIndependent/glslang_tab.cpp" +#line 11063 "MachineIndependent/glslang_tab.cpp" break; - case 491: /* type_specifier_nonarray: UIMAGECUBE */ -#line 3297 "MachineIndependent/glslang.y" + case 497: /* type_specifier_nonarray: UIMAGECUBE */ +#line 3340 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); } -#line 10685 "MachineIndependent/glslang_tab.cpp" +#line 11073 "MachineIndependent/glslang_tab.cpp" break; - case 492: /* type_specifier_nonarray: IMAGEBUFFER */ -#line 3302 "MachineIndependent/glslang.y" + case 498: /* type_specifier_nonarray: IMAGEBUFFER */ +#line 3345 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); } -#line 10695 "MachineIndependent/glslang_tab.cpp" +#line 11083 "MachineIndependent/glslang_tab.cpp" break; - case 493: /* type_specifier_nonarray: F16IMAGEBUFFER */ -#line 3307 "MachineIndependent/glslang.y" + case 499: /* type_specifier_nonarray: F16IMAGEBUFFER */ +#line 3350 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); } -#line 10706 "MachineIndependent/glslang_tab.cpp" +#line 11094 "MachineIndependent/glslang_tab.cpp" break; - case 494: /* type_specifier_nonarray: IIMAGEBUFFER */ -#line 3313 "MachineIndependent/glslang.y" + case 500: /* type_specifier_nonarray: IIMAGEBUFFER */ +#line 3356 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); } -#line 10716 "MachineIndependent/glslang_tab.cpp" +#line 11104 "MachineIndependent/glslang_tab.cpp" break; - case 495: /* type_specifier_nonarray: UIMAGEBUFFER */ -#line 3318 "MachineIndependent/glslang.y" + case 501: /* type_specifier_nonarray: UIMAGEBUFFER */ +#line 3361 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); } -#line 10726 "MachineIndependent/glslang_tab.cpp" +#line 11114 "MachineIndependent/glslang_tab.cpp" break; - case 496: /* type_specifier_nonarray: IMAGE1DARRAY */ -#line 3323 "MachineIndependent/glslang.y" + case 502: /* type_specifier_nonarray: IMAGE1DARRAY */ +#line 3366 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); } -#line 10736 "MachineIndependent/glslang_tab.cpp" +#line 11124 "MachineIndependent/glslang_tab.cpp" break; - case 497: /* type_specifier_nonarray: F16IMAGE1DARRAY */ -#line 3328 "MachineIndependent/glslang.y" + case 503: /* type_specifier_nonarray: F16IMAGE1DARRAY */ +#line 3371 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); } -#line 10747 "MachineIndependent/glslang_tab.cpp" +#line 11135 "MachineIndependent/glslang_tab.cpp" break; - case 498: /* type_specifier_nonarray: IIMAGE1DARRAY */ -#line 3334 "MachineIndependent/glslang.y" + case 504: /* type_specifier_nonarray: IIMAGE1DARRAY */ +#line 3377 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); } -#line 10757 "MachineIndependent/glslang_tab.cpp" +#line 11145 "MachineIndependent/glslang_tab.cpp" break; - case 499: /* type_specifier_nonarray: UIMAGE1DARRAY */ -#line 3339 "MachineIndependent/glslang.y" + case 505: /* type_specifier_nonarray: UIMAGE1DARRAY */ +#line 3382 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); } -#line 10767 "MachineIndependent/glslang_tab.cpp" +#line 11155 "MachineIndependent/glslang_tab.cpp" break; - case 500: /* type_specifier_nonarray: IMAGE2DARRAY */ -#line 3344 "MachineIndependent/glslang.y" + case 506: /* type_specifier_nonarray: IMAGE2DARRAY */ +#line 3387 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); } -#line 10777 "MachineIndependent/glslang_tab.cpp" +#line 11165 "MachineIndependent/glslang_tab.cpp" break; - case 501: /* type_specifier_nonarray: F16IMAGE2DARRAY */ -#line 3349 "MachineIndependent/glslang.y" + case 507: /* type_specifier_nonarray: F16IMAGE2DARRAY */ +#line 3392 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); } -#line 10788 "MachineIndependent/glslang_tab.cpp" +#line 11176 "MachineIndependent/glslang_tab.cpp" break; - case 502: /* type_specifier_nonarray: IIMAGE2DARRAY */ -#line 3355 "MachineIndependent/glslang.y" + case 508: /* type_specifier_nonarray: IIMAGE2DARRAY */ +#line 3398 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); } -#line 10798 "MachineIndependent/glslang_tab.cpp" +#line 11186 "MachineIndependent/glslang_tab.cpp" break; - case 503: /* type_specifier_nonarray: UIMAGE2DARRAY */ -#line 3360 "MachineIndependent/glslang.y" + case 509: /* type_specifier_nonarray: UIMAGE2DARRAY */ +#line 3403 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); } -#line 10808 "MachineIndependent/glslang_tab.cpp" +#line 11196 "MachineIndependent/glslang_tab.cpp" break; - case 504: /* type_specifier_nonarray: IMAGECUBEARRAY */ -#line 3365 "MachineIndependent/glslang.y" + case 510: /* type_specifier_nonarray: IMAGECUBEARRAY */ +#line 3408 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); } -#line 10818 "MachineIndependent/glslang_tab.cpp" +#line 11206 "MachineIndependent/glslang_tab.cpp" break; - case 505: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ -#line 3370 "MachineIndependent/glslang.y" + case 511: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ +#line 3413 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); } -#line 10829 "MachineIndependent/glslang_tab.cpp" +#line 11217 "MachineIndependent/glslang_tab.cpp" break; - case 506: /* type_specifier_nonarray: IIMAGECUBEARRAY */ -#line 3376 "MachineIndependent/glslang.y" + case 512: /* type_specifier_nonarray: IIMAGECUBEARRAY */ +#line 3419 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); } -#line 10839 "MachineIndependent/glslang_tab.cpp" +#line 11227 "MachineIndependent/glslang_tab.cpp" break; - case 507: /* type_specifier_nonarray: UIMAGECUBEARRAY */ -#line 3381 "MachineIndependent/glslang.y" + case 513: /* type_specifier_nonarray: UIMAGECUBEARRAY */ +#line 3424 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); } -#line 10849 "MachineIndependent/glslang_tab.cpp" +#line 11237 "MachineIndependent/glslang_tab.cpp" break; - case 508: /* type_specifier_nonarray: IMAGE2DMS */ -#line 3386 "MachineIndependent/glslang.y" + case 514: /* type_specifier_nonarray: IMAGE2DMS */ +#line 3429 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); } -#line 10859 "MachineIndependent/glslang_tab.cpp" +#line 11247 "MachineIndependent/glslang_tab.cpp" break; - case 509: /* type_specifier_nonarray: F16IMAGE2DMS */ -#line 3391 "MachineIndependent/glslang.y" + case 515: /* type_specifier_nonarray: F16IMAGE2DMS */ +#line 3434 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); } -#line 10870 "MachineIndependent/glslang_tab.cpp" +#line 11258 "MachineIndependent/glslang_tab.cpp" break; - case 510: /* type_specifier_nonarray: IIMAGE2DMS */ -#line 3397 "MachineIndependent/glslang.y" + case 516: /* type_specifier_nonarray: IIMAGE2DMS */ +#line 3440 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); } -#line 10880 "MachineIndependent/glslang_tab.cpp" +#line 11268 "MachineIndependent/glslang_tab.cpp" break; - case 511: /* type_specifier_nonarray: UIMAGE2DMS */ -#line 3402 "MachineIndependent/glslang.y" + case 517: /* type_specifier_nonarray: UIMAGE2DMS */ +#line 3445 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); } -#line 10890 "MachineIndependent/glslang_tab.cpp" +#line 11278 "MachineIndependent/glslang_tab.cpp" break; - case 512: /* type_specifier_nonarray: IMAGE2DMSARRAY */ -#line 3407 "MachineIndependent/glslang.y" + case 518: /* type_specifier_nonarray: IMAGE2DMSARRAY */ +#line 3450 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); } -#line 10900 "MachineIndependent/glslang_tab.cpp" +#line 11288 "MachineIndependent/glslang_tab.cpp" break; - case 513: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ -#line 3412 "MachineIndependent/glslang.y" + case 519: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ +#line 3455 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); } -#line 10911 "MachineIndependent/glslang_tab.cpp" +#line 11299 "MachineIndependent/glslang_tab.cpp" break; - case 514: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ -#line 3418 "MachineIndependent/glslang.y" + case 520: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ +#line 3461 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); } -#line 10921 "MachineIndependent/glslang_tab.cpp" +#line 11309 "MachineIndependent/glslang_tab.cpp" break; - case 515: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ -#line 3423 "MachineIndependent/glslang.y" + case 521: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ +#line 3466 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); } -#line 10931 "MachineIndependent/glslang_tab.cpp" +#line 11319 "MachineIndependent/glslang_tab.cpp" break; - case 516: /* type_specifier_nonarray: I64IMAGE1D */ -#line 3428 "MachineIndependent/glslang.y" + case 522: /* type_specifier_nonarray: I64IMAGE1D */ +#line 3471 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D); } -#line 10941 "MachineIndependent/glslang_tab.cpp" +#line 11329 "MachineIndependent/glslang_tab.cpp" break; - case 517: /* type_specifier_nonarray: U64IMAGE1D */ -#line 3433 "MachineIndependent/glslang.y" + case 523: /* type_specifier_nonarray: U64IMAGE1D */ +#line 3476 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D); } -#line 10951 "MachineIndependent/glslang_tab.cpp" +#line 11339 "MachineIndependent/glslang_tab.cpp" break; - case 518: /* type_specifier_nonarray: I64IMAGE2D */ -#line 3438 "MachineIndependent/glslang.y" + case 524: /* type_specifier_nonarray: I64IMAGE2D */ +#line 3481 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D); } -#line 10961 "MachineIndependent/glslang_tab.cpp" +#line 11349 "MachineIndependent/glslang_tab.cpp" break; - case 519: /* type_specifier_nonarray: U64IMAGE2D */ -#line 3443 "MachineIndependent/glslang.y" + case 525: /* type_specifier_nonarray: U64IMAGE2D */ +#line 3486 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D); } -#line 10971 "MachineIndependent/glslang_tab.cpp" +#line 11359 "MachineIndependent/glslang_tab.cpp" break; - case 520: /* type_specifier_nonarray: I64IMAGE3D */ -#line 3448 "MachineIndependent/glslang.y" + case 526: /* type_specifier_nonarray: I64IMAGE3D */ +#line 3491 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D); } -#line 10981 "MachineIndependent/glslang_tab.cpp" +#line 11369 "MachineIndependent/glslang_tab.cpp" break; - case 521: /* type_specifier_nonarray: U64IMAGE3D */ -#line 3453 "MachineIndependent/glslang.y" + case 527: /* type_specifier_nonarray: U64IMAGE3D */ +#line 3496 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd3D); } -#line 10991 "MachineIndependent/glslang_tab.cpp" +#line 11379 "MachineIndependent/glslang_tab.cpp" break; - case 522: /* type_specifier_nonarray: I64IMAGE2DRECT */ -#line 3458 "MachineIndependent/glslang.y" + case 528: /* type_specifier_nonarray: I64IMAGE2DRECT */ +#line 3501 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdRect); } -#line 11001 "MachineIndependent/glslang_tab.cpp" +#line 11389 "MachineIndependent/glslang_tab.cpp" break; - case 523: /* type_specifier_nonarray: U64IMAGE2DRECT */ -#line 3463 "MachineIndependent/glslang.y" + case 529: /* type_specifier_nonarray: U64IMAGE2DRECT */ +#line 3506 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdRect); } -#line 11011 "MachineIndependent/glslang_tab.cpp" +#line 11399 "MachineIndependent/glslang_tab.cpp" break; - case 524: /* type_specifier_nonarray: I64IMAGECUBE */ -#line 3468 "MachineIndependent/glslang.y" + case 530: /* type_specifier_nonarray: I64IMAGECUBE */ +#line 3511 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube); } -#line 11021 "MachineIndependent/glslang_tab.cpp" +#line 11409 "MachineIndependent/glslang_tab.cpp" break; - case 525: /* type_specifier_nonarray: U64IMAGECUBE */ -#line 3473 "MachineIndependent/glslang.y" + case 531: /* type_specifier_nonarray: U64IMAGECUBE */ +#line 3516 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube); } -#line 11031 "MachineIndependent/glslang_tab.cpp" +#line 11419 "MachineIndependent/glslang_tab.cpp" break; - case 526: /* type_specifier_nonarray: I64IMAGEBUFFER */ -#line 3478 "MachineIndependent/glslang.y" + case 532: /* type_specifier_nonarray: I64IMAGEBUFFER */ +#line 3521 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdBuffer); } -#line 11041 "MachineIndependent/glslang_tab.cpp" +#line 11429 "MachineIndependent/glslang_tab.cpp" break; - case 527: /* type_specifier_nonarray: U64IMAGEBUFFER */ -#line 3483 "MachineIndependent/glslang.y" + case 533: /* type_specifier_nonarray: U64IMAGEBUFFER */ +#line 3526 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdBuffer); } -#line 11051 "MachineIndependent/glslang_tab.cpp" +#line 11439 "MachineIndependent/glslang_tab.cpp" break; - case 528: /* type_specifier_nonarray: I64IMAGE1DARRAY */ -#line 3488 "MachineIndependent/glslang.y" + case 534: /* type_specifier_nonarray: I64IMAGE1DARRAY */ +#line 3531 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D, true); } -#line 11061 "MachineIndependent/glslang_tab.cpp" +#line 11449 "MachineIndependent/glslang_tab.cpp" break; - case 529: /* type_specifier_nonarray: U64IMAGE1DARRAY */ -#line 3493 "MachineIndependent/glslang.y" + case 535: /* type_specifier_nonarray: U64IMAGE1DARRAY */ +#line 3536 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D, true); } -#line 11071 "MachineIndependent/glslang_tab.cpp" +#line 11459 "MachineIndependent/glslang_tab.cpp" break; - case 530: /* type_specifier_nonarray: I64IMAGE2DARRAY */ -#line 3498 "MachineIndependent/glslang.y" + case 536: /* type_specifier_nonarray: I64IMAGE2DARRAY */ +#line 3541 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true); } -#line 11081 "MachineIndependent/glslang_tab.cpp" +#line 11469 "MachineIndependent/glslang_tab.cpp" break; - case 531: /* type_specifier_nonarray: U64IMAGE2DARRAY */ -#line 3503 "MachineIndependent/glslang.y" + case 537: /* type_specifier_nonarray: U64IMAGE2DARRAY */ +#line 3546 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true); } -#line 11091 "MachineIndependent/glslang_tab.cpp" +#line 11479 "MachineIndependent/glslang_tab.cpp" break; - case 532: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ -#line 3508 "MachineIndependent/glslang.y" + case 538: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ +#line 3551 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube, true); } -#line 11101 "MachineIndependent/glslang_tab.cpp" +#line 11489 "MachineIndependent/glslang_tab.cpp" break; - case 533: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ -#line 3513 "MachineIndependent/glslang.y" + case 539: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ +#line 3556 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube, true); } -#line 11111 "MachineIndependent/glslang_tab.cpp" +#line 11499 "MachineIndependent/glslang_tab.cpp" break; - case 534: /* type_specifier_nonarray: I64IMAGE2DMS */ -#line 3518 "MachineIndependent/glslang.y" + case 540: /* type_specifier_nonarray: I64IMAGE2DMS */ +#line 3561 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, false, false, true); } -#line 11121 "MachineIndependent/glslang_tab.cpp" +#line 11509 "MachineIndependent/glslang_tab.cpp" break; - case 535: /* type_specifier_nonarray: U64IMAGE2DMS */ -#line 3523 "MachineIndependent/glslang.y" + case 541: /* type_specifier_nonarray: U64IMAGE2DMS */ +#line 3566 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, false, false, true); } -#line 11131 "MachineIndependent/glslang_tab.cpp" +#line 11519 "MachineIndependent/glslang_tab.cpp" break; - case 536: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ -#line 3528 "MachineIndependent/glslang.y" + case 542: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ +#line 3571 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true, false, true); } -#line 11141 "MachineIndependent/glslang_tab.cpp" +#line 11529 "MachineIndependent/glslang_tab.cpp" break; - case 537: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ -#line 3533 "MachineIndependent/glslang.y" + case 543: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ +#line 3576 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true, false, true); } -#line 11151 "MachineIndependent/glslang_tab.cpp" +#line 11539 "MachineIndependent/glslang_tab.cpp" break; - case 538: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ -#line 3538 "MachineIndependent/glslang.y" + case 544: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ +#line 3581 "MachineIndependent/glslang.y" { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.external = true; } -#line 11162 "MachineIndependent/glslang_tab.cpp" +#line 11550 "MachineIndependent/glslang_tab.cpp" break; - case 539: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ -#line 3544 "MachineIndependent/glslang.y" + case 545: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ +#line 3587 "MachineIndependent/glslang.y" { // GL_EXT_YUV_target (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.yuv = true; } -#line 11173 "MachineIndependent/glslang_tab.cpp" +#line 11561 "MachineIndependent/glslang_tab.cpp" break; - case 540: /* type_specifier_nonarray: ATTACHMENTEXT */ -#line 3550 "MachineIndependent/glslang.y" + case 546: /* type_specifier_nonarray: ATTACHMENTEXT */ +#line 3593 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtFloat); } -#line 11184 "MachineIndependent/glslang_tab.cpp" +#line 11572 "MachineIndependent/glslang_tab.cpp" break; - case 541: /* type_specifier_nonarray: IATTACHMENTEXT */ -#line 3556 "MachineIndependent/glslang.y" + case 547: /* type_specifier_nonarray: IATTACHMENTEXT */ +#line 3599 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtInt); } -#line 11195 "MachineIndependent/glslang_tab.cpp" +#line 11583 "MachineIndependent/glslang_tab.cpp" break; - case 542: /* type_specifier_nonarray: UATTACHMENTEXT */ -#line 3562 "MachineIndependent/glslang.y" + case 548: /* type_specifier_nonarray: UATTACHMENTEXT */ +#line 3605 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtUint); } -#line 11206 "MachineIndependent/glslang_tab.cpp" +#line 11594 "MachineIndependent/glslang_tab.cpp" break; - case 543: /* type_specifier_nonarray: SUBPASSINPUT */ -#line 3568 "MachineIndependent/glslang.y" + case 549: /* type_specifier_nonarray: SUBPASSINPUT */ +#line 3611 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat); } -#line 11217 "MachineIndependent/glslang_tab.cpp" +#line 11605 "MachineIndependent/glslang_tab.cpp" break; - case 544: /* type_specifier_nonarray: SUBPASSINPUTMS */ -#line 3574 "MachineIndependent/glslang.y" + case 550: /* type_specifier_nonarray: SUBPASSINPUTMS */ +#line 3617 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat, true); } -#line 11228 "MachineIndependent/glslang_tab.cpp" +#line 11616 "MachineIndependent/glslang_tab.cpp" break; - case 545: /* type_specifier_nonarray: F16SUBPASSINPUT */ -#line 3580 "MachineIndependent/glslang.y" + case 551: /* type_specifier_nonarray: F16SUBPASSINPUT */ +#line 3623 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -11236,11 +11624,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16); } -#line 11240 "MachineIndependent/glslang_tab.cpp" +#line 11628 "MachineIndependent/glslang_tab.cpp" break; - case 546: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ -#line 3587 "MachineIndependent/glslang.y" + case 552: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ +#line 3630 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -11248,55 +11636,55 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); } -#line 11252 "MachineIndependent/glslang_tab.cpp" +#line 11640 "MachineIndependent/glslang_tab.cpp" break; - case 547: /* type_specifier_nonarray: ISUBPASSINPUT */ -#line 3594 "MachineIndependent/glslang.y" + case 553: /* type_specifier_nonarray: ISUBPASSINPUT */ +#line 3637 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt); } -#line 11263 "MachineIndependent/glslang_tab.cpp" +#line 11651 "MachineIndependent/glslang_tab.cpp" break; - case 548: /* type_specifier_nonarray: ISUBPASSINPUTMS */ -#line 3600 "MachineIndependent/glslang.y" + case 554: /* type_specifier_nonarray: ISUBPASSINPUTMS */ +#line 3643 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt, true); } -#line 11274 "MachineIndependent/glslang_tab.cpp" +#line 11662 "MachineIndependent/glslang_tab.cpp" break; - case 549: /* type_specifier_nonarray: USUBPASSINPUT */ -#line 3606 "MachineIndependent/glslang.y" + case 555: /* type_specifier_nonarray: USUBPASSINPUT */ +#line 3649 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint); } -#line 11285 "MachineIndependent/glslang_tab.cpp" +#line 11673 "MachineIndependent/glslang_tab.cpp" break; - case 550: /* type_specifier_nonarray: USUBPASSINPUTMS */ -#line 3612 "MachineIndependent/glslang.y" + case 556: /* type_specifier_nonarray: USUBPASSINPUTMS */ +#line 3655 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint, true); } -#line 11296 "MachineIndependent/glslang_tab.cpp" +#line 11684 "MachineIndependent/glslang_tab.cpp" break; - case 551: /* type_specifier_nonarray: FCOOPMATNV */ -#line 3618 "MachineIndependent/glslang.y" + case 557: /* type_specifier_nonarray: FCOOPMATNV */ +#line 3661 "MachineIndependent/glslang.y" { parseContext.fcoopmatCheckNV((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -11304,11 +11692,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 11308 "MachineIndependent/glslang_tab.cpp" +#line 11696 "MachineIndependent/glslang_tab.cpp" break; - case 552: /* type_specifier_nonarray: ICOOPMATNV */ -#line 3625 "MachineIndependent/glslang.y" + case 558: /* type_specifier_nonarray: ICOOPMATNV */ +#line 3668 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -11316,11 +11704,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 11320 "MachineIndependent/glslang_tab.cpp" +#line 11708 "MachineIndependent/glslang_tab.cpp" break; - case 553: /* type_specifier_nonarray: UCOOPMATNV */ -#line 3632 "MachineIndependent/glslang.y" + case 559: /* type_specifier_nonarray: UCOOPMATNV */ +#line 3675 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -11328,11 +11716,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 11332 "MachineIndependent/glslang_tab.cpp" +#line 11720 "MachineIndependent/glslang_tab.cpp" break; - case 554: /* type_specifier_nonarray: COOPMAT */ -#line 3639 "MachineIndependent/glslang.y" + case 560: /* type_specifier_nonarray: COOPMAT */ +#line 3682 "MachineIndependent/glslang.y" { parseContext.coopmatCheck((yyvsp[0].lex).loc, "coopmat", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -11340,110 +11728,120 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = false; (yyval.interm.type).coopmatKHR = true; } -#line 11344 "MachineIndependent/glslang_tab.cpp" +#line 11732 "MachineIndependent/glslang_tab.cpp" break; - case 555: /* type_specifier_nonarray: TENSORLAYOUTNV */ -#line 3646 "MachineIndependent/glslang.y" + case 561: /* type_specifier_nonarray: TENSORLAYOUTNV */ +#line 3689 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorLayoutNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorLayoutNV; } -#line 11354 "MachineIndependent/glslang_tab.cpp" +#line 11742 "MachineIndependent/glslang_tab.cpp" break; - case 556: /* type_specifier_nonarray: TENSORVIEWNV */ -#line 3651 "MachineIndependent/glslang.y" + case 562: /* type_specifier_nonarray: TENSORVIEWNV */ +#line 3694 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorViewNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorViewNV; } -#line 11364 "MachineIndependent/glslang_tab.cpp" +#line 11752 "MachineIndependent/glslang_tab.cpp" break; - case 557: /* type_specifier_nonarray: FUNCTION */ -#line 3656 "MachineIndependent/glslang.y" + case 563: /* type_specifier_nonarray: FUNCTION */ +#line 3699 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).basicType = EbtFunction; } -#line 11373 "MachineIndependent/glslang_tab.cpp" +#line 11761 "MachineIndependent/glslang_tab.cpp" break; - case 558: /* type_specifier_nonarray: COOPVECNV */ -#line 3660 "MachineIndependent/glslang.y" + case 564: /* type_specifier_nonarray: COOPVECNV */ +#line 3703 "MachineIndependent/glslang.y" { parseContext.coopvecCheck((yyvsp[0].lex).loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtCoopvecNV; (yyval.interm.type).coopvecNV = true; } -#line 11384 "MachineIndependent/glslang_tab.cpp" +#line 11772 "MachineIndependent/glslang_tab.cpp" break; - case 559: /* type_specifier_nonarray: TENSORARM */ -#line 3666 "MachineIndependent/glslang.y" + case 565: /* type_specifier_nonarray: TENSORARM */ +#line 3709 "MachineIndependent/glslang.y" { parseContext.tensorCheckARM((yyvsp[0].lex).loc, "tensorARM", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).tensorRankARM = 1; // placeholder value (yyval.interm.type).basicType = EbtTensorARM; } -#line 11395 "MachineIndependent/glslang_tab.cpp" +#line 11783 "MachineIndependent/glslang_tab.cpp" break; - case 560: /* type_specifier_nonarray: VECTOR */ -#line 3672 "MachineIndependent/glslang.y" + case 566: /* type_specifier_nonarray: VECTOR */ +#line 3715 "MachineIndependent/glslang.y" { parseContext.longVectorCheck((yyvsp[0].lex).loc, "vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtLongVector; (yyval.interm.type).longVector = true; } -#line 11406 "MachineIndependent/glslang_tab.cpp" +#line 11794 "MachineIndependent/glslang_tab.cpp" break; - case 561: /* type_specifier_nonarray: spirv_type_specifier */ -#line 3678 "MachineIndependent/glslang.y" + case 567: /* type_specifier_nonarray: spirv_type_specifier */ +#line 3721 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 11415 "MachineIndependent/glslang_tab.cpp" +#line 11803 "MachineIndependent/glslang_tab.cpp" break; - case 562: /* type_specifier_nonarray: HITOBJECTNV */ -#line 3682 "MachineIndependent/glslang.y" + case 568: /* type_specifier_nonarray: SPIRV_STRING */ +#line 3725 "MachineIndependent/glslang.y" + { + parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics_string, "spirv_string type specifier"); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtString; + } +#line 11813 "MachineIndependent/glslang_tab.cpp" + break; + + case 569: /* type_specifier_nonarray: HITOBJECTNV */ +#line 3730 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtHitObjectNV; } -#line 11424 "MachineIndependent/glslang_tab.cpp" +#line 11822 "MachineIndependent/glslang_tab.cpp" break; - case 563: /* type_specifier_nonarray: HITOBJECTEXT */ -#line 3686 "MachineIndependent/glslang.y" + case 570: /* type_specifier_nonarray: HITOBJECTEXT */ +#line 3734 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtHitObjectEXT; } -#line 11433 "MachineIndependent/glslang_tab.cpp" +#line 11831 "MachineIndependent/glslang_tab.cpp" break; - case 564: /* type_specifier_nonarray: struct_specifier */ -#line 3690 "MachineIndependent/glslang.y" + case 571: /* type_specifier_nonarray: struct_specifier */ +#line 3738 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); } -#line 11443 "MachineIndependent/glslang_tab.cpp" +#line 11841 "MachineIndependent/glslang_tab.cpp" break; - case 565: /* type_specifier_nonarray: TYPE_NAME */ -#line 3695 "MachineIndependent/glslang.y" + case 572: /* type_specifier_nonarray: TYPE_NAME */ +#line 3743 "MachineIndependent/glslang.y" { // // This is for user defined type names. The lexical phase looked up the @@ -11457,47 +11855,47 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 11461 "MachineIndependent/glslang_tab.cpp" +#line 11859 "MachineIndependent/glslang_tab.cpp" break; - case 566: /* precision_qualifier: HIGH_PRECISION */ -#line 3711 "MachineIndependent/glslang.y" + case 573: /* precision_qualifier: HIGH_PRECISION */ +#line 3759 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); } -#line 11471 "MachineIndependent/glslang_tab.cpp" +#line 11869 "MachineIndependent/glslang_tab.cpp" break; - case 567: /* precision_qualifier: MEDIUM_PRECISION */ -#line 3716 "MachineIndependent/glslang.y" + case 574: /* precision_qualifier: MEDIUM_PRECISION */ +#line 3764 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); } -#line 11481 "MachineIndependent/glslang_tab.cpp" +#line 11879 "MachineIndependent/glslang_tab.cpp" break; - case 568: /* precision_qualifier: LOW_PRECISION */ -#line 3721 "MachineIndependent/glslang.y" + case 575: /* precision_qualifier: LOW_PRECISION */ +#line 3769 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); } -#line 11491 "MachineIndependent/glslang_tab.cpp" +#line 11889 "MachineIndependent/glslang_tab.cpp" break; - case 569: /* $@3: %empty */ -#line 3729 "MachineIndependent/glslang.y" + case 576: /* $@3: %empty */ +#line 3777 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 11497 "MachineIndependent/glslang_tab.cpp" +#line 11895 "MachineIndependent/glslang_tab.cpp" break; - case 570: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ -#line 3729 "MachineIndependent/glslang.y" + case 577: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ +#line 3777 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); @@ -11514,17 +11912,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11518 "MachineIndependent/glslang_tab.cpp" +#line 11916 "MachineIndependent/glslang_tab.cpp" break; - case 571: /* $@4: %empty */ -#line 3745 "MachineIndependent/glslang.y" + case 578: /* $@4: %empty */ +#line 3793 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 11524 "MachineIndependent/glslang_tab.cpp" +#line 11922 "MachineIndependent/glslang_tab.cpp" break; - case 572: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ -#line 3745 "MachineIndependent/glslang.y" + case 579: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ +#line 3793 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -11532,27 +11930,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11536 "MachineIndependent/glslang_tab.cpp" +#line 11934 "MachineIndependent/glslang_tab.cpp" break; - case 573: /* struct_declaration_list: struct_declaration_without_heap */ -#line 3755 "MachineIndependent/glslang.y" + case 580: /* struct_declaration_list: struct_declaration_without_heap */ +#line 3803 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11544 "MachineIndependent/glslang_tab.cpp" +#line 11942 "MachineIndependent/glslang_tab.cpp" break; - case 574: /* struct_declaration_list: struct_declaration_with_heap */ -#line 3758 "MachineIndependent/glslang.y" + case 581: /* struct_declaration_list: struct_declaration_with_heap */ +#line 3806 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11552 "MachineIndependent/glslang_tab.cpp" +#line 11950 "MachineIndependent/glslang_tab.cpp" break; - case 575: /* struct_declaration_list: struct_declaration_with_heap struct_declaration_without_heap */ -#line 3761 "MachineIndependent/glslang.y" + case 582: /* struct_declaration_list: struct_declaration_with_heap struct_declaration_without_heap */ +#line 3809 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11563,11 +11961,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11567 "MachineIndependent/glslang_tab.cpp" +#line 11965 "MachineIndependent/glslang_tab.cpp" break; - case 576: /* struct_declaration_list: struct_declaration_without_heap struct_declaration_with_heap */ -#line 3771 "MachineIndependent/glslang.y" + case 583: /* struct_declaration_list: struct_declaration_without_heap struct_declaration_with_heap */ +#line 3819 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11578,11 +11976,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11582 "MachineIndependent/glslang_tab.cpp" +#line 11980 "MachineIndependent/glslang_tab.cpp" break; - case 577: /* struct_declaration_with_heap: block_heap_inner_structure struct_declarator_list SEMICOLON */ -#line 3784 "MachineIndependent/glslang.y" + case 584: /* struct_declaration_with_heap: block_heap_inner_structure struct_declarator_list SEMICOLON */ +#line 3832 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); @@ -11597,17 +11995,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11601 "MachineIndependent/glslang_tab.cpp" +#line 11999 "MachineIndependent/glslang_tab.cpp" break; - case 578: /* $@5: %empty */ -#line 3801 "MachineIndependent/glslang.y" + case 585: /* $@5: %empty */ +#line 3849 "MachineIndependent/glslang.y" { parseContext.nestedBlockCheck((yyvsp[-1].interm.type).loc, true); } -#line 11607 "MachineIndependent/glslang_tab.cpp" +#line 12005 "MachineIndependent/glslang_tab.cpp" break; - case 579: /* block_heap_inner_structure: type_qualifier LEFT_BRACE $@5 struct_declaration_without_heap RIGHT_BRACE */ -#line 3801 "MachineIndependent/glslang.y" + case 586: /* block_heap_inner_structure: type_qualifier LEFT_BRACE $@5 struct_declaration_without_heap RIGHT_BRACE */ +#line 3849 "MachineIndependent/glslang.y" { --parseContext.blockNestingLevel; parseContext.globalQualifierFixCheck((yyvsp[-4].interm.type).loc, (yyvsp[-4].interm.type).qualifier); @@ -11620,19 +12018,19 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).qualifier.layoutDescriptorHeap = true; (yyval.interm.type).qualifier.layoutDescriptorInnerBlock = true; } -#line 11624 "MachineIndependent/glslang_tab.cpp" +#line 12022 "MachineIndependent/glslang_tab.cpp" break; - case 580: /* struct_declaration_without_heap: struct_declaration */ -#line 3816 "MachineIndependent/glslang.y" + case 587: /* struct_declaration_without_heap: struct_declaration */ +#line 3864 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11632 "MachineIndependent/glslang_tab.cpp" +#line 12030 "MachineIndependent/glslang_tab.cpp" break; - case 581: /* struct_declaration_without_heap: struct_declaration_without_heap struct_declaration */ -#line 3819 "MachineIndependent/glslang.y" + case 588: /* struct_declaration_without_heap: struct_declaration_without_heap struct_declaration */ +#line 3867 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11643,11 +12041,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11647 "MachineIndependent/glslang_tab.cpp" +#line 12045 "MachineIndependent/glslang_tab.cpp" break; - case 582: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ -#line 3832 "MachineIndependent/glslang.y" + case 589: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ +#line 3880 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11670,11 +12068,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11674 "MachineIndependent/glslang_tab.cpp" +#line 12072 "MachineIndependent/glslang_tab.cpp" break; - case 583: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ -#line 3854 "MachineIndependent/glslang.y" + case 590: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ +#line 3902 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11699,38 +12097,38 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11703 "MachineIndependent/glslang_tab.cpp" +#line 12101 "MachineIndependent/glslang_tab.cpp" break; - case 584: /* struct_declarator_list: struct_declarator */ -#line 3881 "MachineIndependent/glslang.y" + case 591: /* struct_declarator_list: struct_declarator */ +#line 3929 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11712 "MachineIndependent/glslang_tab.cpp" +#line 12110 "MachineIndependent/glslang_tab.cpp" break; - case 585: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ -#line 3885 "MachineIndependent/glslang.y" + case 592: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ +#line 3933 "MachineIndependent/glslang.y" { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11720 "MachineIndependent/glslang_tab.cpp" +#line 12118 "MachineIndependent/glslang_tab.cpp" break; - case 586: /* struct_declarator: IDENTIFIER */ -#line 3891 "MachineIndependent/glslang.y" + case 593: /* struct_declarator: IDENTIFIER */ +#line 3939 "MachineIndependent/glslang.y" { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); } -#line 11730 "MachineIndependent/glslang_tab.cpp" +#line 12128 "MachineIndependent/glslang_tab.cpp" break; - case 587: /* struct_declarator: IDENTIFIER array_specifier */ -#line 3896 "MachineIndependent/glslang.y" + case 594: /* struct_declarator: IDENTIFIER array_specifier */ +#line 3944 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -11739,168 +12137,168 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 11743 "MachineIndependent/glslang_tab.cpp" +#line 12141 "MachineIndependent/glslang_tab.cpp" break; - case 588: /* initializer: assignment_expression */ -#line 3907 "MachineIndependent/glslang.y" + case 595: /* initializer: assignment_expression */ +#line 3955 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11751 "MachineIndependent/glslang_tab.cpp" +#line 12149 "MachineIndependent/glslang_tab.cpp" break; - case 589: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ -#line 3910 "MachineIndependent/glslang.y" + case 596: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ +#line 3958 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); } -#line 11762 "MachineIndependent/glslang_tab.cpp" +#line 12160 "MachineIndependent/glslang_tab.cpp" break; - case 590: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ -#line 3916 "MachineIndependent/glslang.y" + case 597: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ +#line 3964 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 11773 "MachineIndependent/glslang_tab.cpp" +#line 12171 "MachineIndependent/glslang_tab.cpp" break; - case 591: /* initializer: LEFT_BRACE RIGHT_BRACE */ -#line 3922 "MachineIndependent/glslang.y" + case 598: /* initializer: LEFT_BRACE RIGHT_BRACE */ +#line 3970 "MachineIndependent/glslang.y" { const char* initFeature = "empty { } initializer"; parseContext.profileRequires((yyvsp[-1].lex).loc, EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); parseContext.profileRequires((yyvsp[-1].lex).loc, ~EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); (yyval.interm.intermTypedNode) = parseContext.intermediate.makeAggregate((yyvsp[-1].lex).loc); } -#line 11784 "MachineIndependent/glslang_tab.cpp" +#line 12182 "MachineIndependent/glslang_tab.cpp" break; - case 592: /* initializer_list: initializer */ -#line 3931 "MachineIndependent/glslang.y" + case 599: /* initializer_list: initializer */ +#line 3979 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); } -#line 11792 "MachineIndependent/glslang_tab.cpp" +#line 12190 "MachineIndependent/glslang_tab.cpp" break; - case 593: /* initializer_list: initializer_list COMMA initializer */ -#line 3934 "MachineIndependent/glslang.y" + case 600: /* initializer_list: initializer_list COMMA initializer */ +#line 3982 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); } -#line 11800 "MachineIndependent/glslang_tab.cpp" +#line 12198 "MachineIndependent/glslang_tab.cpp" break; - case 594: /* declaration_statement: declaration */ -#line 3940 "MachineIndependent/glslang.y" + case 601: /* declaration_statement: declaration */ +#line 3988 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11806 "MachineIndependent/glslang_tab.cpp" +#line 12204 "MachineIndependent/glslang_tab.cpp" break; - case 595: /* statement: compound_statement */ -#line 3944 "MachineIndependent/glslang.y" + case 602: /* statement: compound_statement */ +#line 3992 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11812 "MachineIndependent/glslang_tab.cpp" +#line 12210 "MachineIndependent/glslang_tab.cpp" break; - case 596: /* statement: simple_statement */ -#line 3945 "MachineIndependent/glslang.y" + case 603: /* statement: simple_statement */ +#line 3993 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11818 "MachineIndependent/glslang_tab.cpp" +#line 12216 "MachineIndependent/glslang_tab.cpp" break; - case 597: /* simple_statement: declaration_statement */ -#line 3951 "MachineIndependent/glslang.y" + case 604: /* simple_statement: declaration_statement */ +#line 3999 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11824 "MachineIndependent/glslang_tab.cpp" +#line 12222 "MachineIndependent/glslang_tab.cpp" break; - case 598: /* simple_statement: expression_statement */ -#line 3952 "MachineIndependent/glslang.y" + case 605: /* simple_statement: expression_statement */ +#line 4000 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11830 "MachineIndependent/glslang_tab.cpp" +#line 12228 "MachineIndependent/glslang_tab.cpp" break; - case 599: /* simple_statement: selection_statement */ -#line 3953 "MachineIndependent/glslang.y" + case 606: /* simple_statement: selection_statement */ +#line 4001 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11836 "MachineIndependent/glslang_tab.cpp" +#line 12234 "MachineIndependent/glslang_tab.cpp" break; - case 600: /* simple_statement: switch_statement */ -#line 3954 "MachineIndependent/glslang.y" + case 607: /* simple_statement: switch_statement */ +#line 4002 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11842 "MachineIndependent/glslang_tab.cpp" +#line 12240 "MachineIndependent/glslang_tab.cpp" break; - case 601: /* simple_statement: case_label */ -#line 3955 "MachineIndependent/glslang.y" + case 608: /* simple_statement: case_label */ +#line 4003 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11848 "MachineIndependent/glslang_tab.cpp" +#line 12246 "MachineIndependent/glslang_tab.cpp" break; - case 602: /* simple_statement: iteration_statement */ -#line 3956 "MachineIndependent/glslang.y" + case 609: /* simple_statement: iteration_statement */ +#line 4004 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11854 "MachineIndependent/glslang_tab.cpp" +#line 12252 "MachineIndependent/glslang_tab.cpp" break; - case 603: /* simple_statement: jump_statement */ -#line 3957 "MachineIndependent/glslang.y" + case 610: /* simple_statement: jump_statement */ +#line 4005 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11860 "MachineIndependent/glslang_tab.cpp" +#line 12258 "MachineIndependent/glslang_tab.cpp" break; - case 604: /* simple_statement: demote_statement */ -#line 3958 "MachineIndependent/glslang.y" + case 611: /* simple_statement: demote_statement */ +#line 4006 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11866 "MachineIndependent/glslang_tab.cpp" +#line 12264 "MachineIndependent/glslang_tab.cpp" break; - case 605: /* demote_statement: DEMOTE SEMICOLON */ -#line 3962 "MachineIndependent/glslang.y" + case 612: /* demote_statement: DEMOTE SEMICOLON */ +#line 4010 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote"); parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc); } -#line 11876 "MachineIndependent/glslang_tab.cpp" +#line 12274 "MachineIndependent/glslang_tab.cpp" break; - case 606: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ -#line 3970 "MachineIndependent/glslang.y" + case 613: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ +#line 4018 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11882 "MachineIndependent/glslang_tab.cpp" +#line 12280 "MachineIndependent/glslang_tab.cpp" break; - case 607: /* $@6: %empty */ -#line 3971 "MachineIndependent/glslang.y" + case 614: /* $@6: %empty */ +#line 4019 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 11891 "MachineIndependent/glslang_tab.cpp" +#line 12289 "MachineIndependent/glslang_tab.cpp" break; - case 608: /* $@7: %empty */ -#line 3975 "MachineIndependent/glslang.y" + case 615: /* $@7: %empty */ +#line 4023 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 11900 "MachineIndependent/glslang_tab.cpp" +#line 12298 "MachineIndependent/glslang_tab.cpp" break; - case 609: /* compound_statement: LEFT_BRACE $@6 statement_list $@7 RIGHT_BRACE */ -#line 3979 "MachineIndependent/glslang.y" + case 616: /* compound_statement: LEFT_BRACE $@6 statement_list $@7 RIGHT_BRACE */ +#line 4027 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) { (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(parseContext.intermediate.getDebugInfo() ? EOpScope : EOpSequence); @@ -11908,69 +12306,69 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 11912 "MachineIndependent/glslang_tab.cpp" +#line 12310 "MachineIndependent/glslang_tab.cpp" break; - case 610: /* statement_no_new_scope: compound_statement_no_new_scope */ -#line 3989 "MachineIndependent/glslang.y" + case 617: /* statement_no_new_scope: compound_statement_no_new_scope */ +#line 4037 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11918 "MachineIndependent/glslang_tab.cpp" +#line 12316 "MachineIndependent/glslang_tab.cpp" break; - case 611: /* statement_no_new_scope: simple_statement */ -#line 3990 "MachineIndependent/glslang.y" + case 618: /* statement_no_new_scope: simple_statement */ +#line 4038 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11924 "MachineIndependent/glslang_tab.cpp" +#line 12322 "MachineIndependent/glslang_tab.cpp" break; - case 612: /* $@8: %empty */ -#line 3994 "MachineIndependent/glslang.y" + case 619: /* $@8: %empty */ +#line 4042 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 11932 "MachineIndependent/glslang_tab.cpp" +#line 12330 "MachineIndependent/glslang_tab.cpp" break; - case 613: /* statement_scoped: $@8 compound_statement */ -#line 3997 "MachineIndependent/glslang.y" + case 620: /* statement_scoped: $@8 compound_statement */ +#line 4045 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11941 "MachineIndependent/glslang_tab.cpp" +#line 12339 "MachineIndependent/glslang_tab.cpp" break; - case 614: /* $@9: %empty */ -#line 4001 "MachineIndependent/glslang.y" + case 621: /* $@9: %empty */ +#line 4049 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11951 "MachineIndependent/glslang_tab.cpp" +#line 12349 "MachineIndependent/glslang_tab.cpp" break; - case 615: /* statement_scoped: $@9 simple_statement */ -#line 4006 "MachineIndependent/glslang.y" + case 622: /* statement_scoped: $@9 simple_statement */ +#line 4054 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11962 "MachineIndependent/glslang_tab.cpp" +#line 12360 "MachineIndependent/glslang_tab.cpp" break; - case 616: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ -#line 4015 "MachineIndependent/glslang.y" + case 623: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ +#line 4063 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11970 "MachineIndependent/glslang_tab.cpp" +#line 12368 "MachineIndependent/glslang_tab.cpp" break; - case 617: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ -#line 4018 "MachineIndependent/glslang.y" + case 624: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ +#line 4066 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) { (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -11978,11 +12376,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 11982 "MachineIndependent/glslang_tab.cpp" +#line 12380 "MachineIndependent/glslang_tab.cpp" break; - case 618: /* statement_list: statement */ -#line 4028 "MachineIndependent/glslang.y" + case 625: /* statement_list: statement */ +#line 4076 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -11991,11 +12389,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 11995 "MachineIndependent/glslang_tab.cpp" +#line 12393 "MachineIndependent/glslang_tab.cpp" break; - case 619: /* statement_list: statement_list statement */ -#line 4036 "MachineIndependent/glslang.y" + case 626: /* statement_list: statement_list statement */ +#line 4084 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -12004,106 +12402,106 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12008 "MachineIndependent/glslang_tab.cpp" +#line 12406 "MachineIndependent/glslang_tab.cpp" break; - case 620: /* expression_statement: SEMICOLON */ -#line 4047 "MachineIndependent/glslang.y" + case 627: /* expression_statement: SEMICOLON */ +#line 4095 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 12014 "MachineIndependent/glslang_tab.cpp" +#line 12412 "MachineIndependent/glslang_tab.cpp" break; - case 621: /* expression_statement: expression SEMICOLON */ -#line 4048 "MachineIndependent/glslang.y" + case 628: /* expression_statement: expression SEMICOLON */ +#line 4096 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 12020 "MachineIndependent/glslang_tab.cpp" +#line 12418 "MachineIndependent/glslang_tab.cpp" break; - case 622: /* selection_statement: selection_statement_nonattributed */ -#line 4052 "MachineIndependent/glslang.y" + case 629: /* selection_statement: selection_statement_nonattributed */ +#line 4100 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12028 "MachineIndependent/glslang_tab.cpp" +#line 12426 "MachineIndependent/glslang_tab.cpp" break; - case 623: /* selection_statement: attribute selection_statement_nonattributed */ -#line 4055 "MachineIndependent/glslang.y" + case 630: /* selection_statement: attribute selection_statement_nonattributed */ +#line 4103 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12038 "MachineIndependent/glslang_tab.cpp" +#line 12436 "MachineIndependent/glslang_tab.cpp" break; - case 624: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ -#line 4062 "MachineIndependent/glslang.y" + case 631: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ +#line 4110 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); } -#line 12047 "MachineIndependent/glslang_tab.cpp" +#line 12445 "MachineIndependent/glslang_tab.cpp" break; - case 625: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ -#line 4069 "MachineIndependent/glslang.y" + case 632: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ +#line 4117 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 12056 "MachineIndependent/glslang_tab.cpp" +#line 12454 "MachineIndependent/glslang_tab.cpp" break; - case 626: /* selection_rest_statement: statement_scoped */ -#line 4073 "MachineIndependent/glslang.y" + case 633: /* selection_rest_statement: statement_scoped */ +#line 4121 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 12065 "MachineIndependent/glslang_tab.cpp" +#line 12463 "MachineIndependent/glslang_tab.cpp" break; - case 627: /* condition: expression */ -#line 4081 "MachineIndependent/glslang.y" + case 634: /* condition: expression */ +#line 4129 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 12074 "MachineIndependent/glslang_tab.cpp" +#line 12472 "MachineIndependent/glslang_tab.cpp" break; - case 628: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 4085 "MachineIndependent/glslang.y" + case 635: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 4133 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); TType type((yyvsp[-3].interm.type)); (yyval.interm.intermNode) = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); } -#line 12085 "MachineIndependent/glslang_tab.cpp" +#line 12483 "MachineIndependent/glslang_tab.cpp" break; - case 629: /* switch_statement: switch_statement_nonattributed */ -#line 4094 "MachineIndependent/glslang.y" + case 636: /* switch_statement: switch_statement_nonattributed */ +#line 4142 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12093 "MachineIndependent/glslang_tab.cpp" +#line 12491 "MachineIndependent/glslang_tab.cpp" break; - case 630: /* switch_statement: attribute switch_statement_nonattributed */ -#line 4097 "MachineIndependent/glslang.y" + case 637: /* switch_statement: attribute switch_statement_nonattributed */ +#line 4145 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12103 "MachineIndependent/glslang_tab.cpp" +#line 12501 "MachineIndependent/glslang_tab.cpp" break; - case 631: /* $@10: %empty */ -#line 4104 "MachineIndependent/glslang.y" + case 638: /* $@10: %empty */ +#line 4152 "MachineIndependent/glslang.y" { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -12112,11 +12510,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 12116 "MachineIndependent/glslang_tab.cpp" +#line 12514 "MachineIndependent/glslang_tab.cpp" break; - case 632: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@10 LEFT_BRACE switch_statement_list RIGHT_BRACE */ -#line 4112 "MachineIndependent/glslang.y" + case 639: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@10 LEFT_BRACE switch_statement_list RIGHT_BRACE */ +#line 4160 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -12126,27 +12524,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 12130 "MachineIndependent/glslang_tab.cpp" +#line 12528 "MachineIndependent/glslang_tab.cpp" break; - case 633: /* switch_statement_list: %empty */ -#line 4124 "MachineIndependent/glslang.y" + case 640: /* switch_statement_list: %empty */ +#line 4172 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 12138 "MachineIndependent/glslang_tab.cpp" +#line 12536 "MachineIndependent/glslang_tab.cpp" break; - case 634: /* switch_statement_list: statement_list */ -#line 4127 "MachineIndependent/glslang.y" + case 641: /* switch_statement_list: statement_list */ +#line 4175 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12146 "MachineIndependent/glslang_tab.cpp" +#line 12544 "MachineIndependent/glslang_tab.cpp" break; - case 635: /* case_label: CASE expression COLON */ -#line 4133 "MachineIndependent/glslang.y" + case 642: /* case_label: CASE expression COLON */ +#line 4181 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -12159,11 +12557,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 12163 "MachineIndependent/glslang_tab.cpp" +#line 12561 "MachineIndependent/glslang_tab.cpp" break; - case 636: /* case_label: DEFAULT COLON */ -#line 4145 "MachineIndependent/glslang.y" + case 643: /* case_label: DEFAULT COLON */ +#line 4193 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -12173,30 +12571,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 12177 "MachineIndependent/glslang_tab.cpp" +#line 12575 "MachineIndependent/glslang_tab.cpp" break; - case 637: /* iteration_statement: iteration_statement_nonattributed */ -#line 4157 "MachineIndependent/glslang.y" + case 644: /* iteration_statement: iteration_statement_nonattributed */ +#line 4205 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12185 "MachineIndependent/glslang_tab.cpp" +#line 12583 "MachineIndependent/glslang_tab.cpp" break; - case 638: /* iteration_statement: attribute iteration_statement_nonattributed */ -#line 4160 "MachineIndependent/glslang.y" + case 645: /* iteration_statement: attribute iteration_statement_nonattributed */ +#line 4208 "MachineIndependent/glslang.y" { const char * extensions[2] = { E_GL_EXT_control_flow_attributes, E_GL_EXT_control_flow_attributes2 }; parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 2, extensions, "attribute"); parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12196 "MachineIndependent/glslang_tab.cpp" +#line 12594 "MachineIndependent/glslang_tab.cpp" break; - case 639: /* $@11: %empty */ -#line 4168 "MachineIndependent/glslang.y" + case 646: /* $@11: %empty */ +#line 4216 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -12205,11 +12603,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 12209 "MachineIndependent/glslang_tab.cpp" +#line 12607 "MachineIndependent/glslang_tab.cpp" break; - case 640: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@11 condition RIGHT_PAREN statement_no_new_scope */ -#line 4176 "MachineIndependent/glslang.y" + case 647: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@11 condition RIGHT_PAREN statement_no_new_scope */ +#line 4224 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermNode), 0, true, (yyvsp[-5].lex).loc); @@ -12221,22 +12619,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 12225 "MachineIndependent/glslang_tab.cpp" +#line 12623 "MachineIndependent/glslang_tab.cpp" break; - case 641: /* $@12: %empty */ -#line 4187 "MachineIndependent/glslang.y" + case 648: /* $@12: %empty */ +#line 4235 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 12236 "MachineIndependent/glslang_tab.cpp" +#line 12634 "MachineIndependent/glslang_tab.cpp" break; - case 642: /* iteration_statement_nonattributed: DO $@12 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ -#line 4193 "MachineIndependent/glslang.y" + case 649: /* iteration_statement_nonattributed: DO $@12 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ +#line 4241 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -12253,22 +12651,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 12257 "MachineIndependent/glslang_tab.cpp" +#line 12655 "MachineIndependent/glslang_tab.cpp" break; - case 643: /* $@13: %empty */ -#line 4209 "MachineIndependent/glslang.y" + case 650: /* $@13: %empty */ +#line 4257 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 12268 "MachineIndependent/glslang_tab.cpp" +#line 12666 "MachineIndependent/glslang_tab.cpp" break; - case 644: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@13 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ -#line 4215 "MachineIndependent/glslang.y" + case 651: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@13 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ +#line 4263 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -12281,81 +12679,81 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 12285 "MachineIndependent/glslang_tab.cpp" +#line 12683 "MachineIndependent/glslang_tab.cpp" break; - case 645: /* for_init_statement: expression_statement */ -#line 4230 "MachineIndependent/glslang.y" + case 652: /* for_init_statement: expression_statement */ +#line 4278 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12293 "MachineIndependent/glslang_tab.cpp" +#line 12691 "MachineIndependent/glslang_tab.cpp" break; - case 646: /* for_init_statement: declaration_statement */ -#line 4233 "MachineIndependent/glslang.y" + case 653: /* for_init_statement: declaration_statement */ +#line 4281 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12301 "MachineIndependent/glslang_tab.cpp" +#line 12699 "MachineIndependent/glslang_tab.cpp" break; - case 647: /* conditionopt: condition */ -#line 4239 "MachineIndependent/glslang.y" + case 654: /* conditionopt: condition */ +#line 4287 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12309 "MachineIndependent/glslang_tab.cpp" +#line 12707 "MachineIndependent/glslang_tab.cpp" break; - case 648: /* conditionopt: %empty */ -#line 4242 "MachineIndependent/glslang.y" + case 655: /* conditionopt: %empty */ +#line 4290 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 12317 "MachineIndependent/glslang_tab.cpp" +#line 12715 "MachineIndependent/glslang_tab.cpp" break; - case 649: /* for_rest_statement: conditionopt SEMICOLON */ -#line 4248 "MachineIndependent/glslang.y" + case 656: /* for_rest_statement: conditionopt SEMICOLON */ +#line 4296 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 12326 "MachineIndependent/glslang_tab.cpp" +#line 12724 "MachineIndependent/glslang_tab.cpp" break; - case 650: /* for_rest_statement: conditionopt SEMICOLON expression */ -#line 4252 "MachineIndependent/glslang.y" + case 657: /* for_rest_statement: conditionopt SEMICOLON expression */ +#line 4300 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 12335 "MachineIndependent/glslang_tab.cpp" +#line 12733 "MachineIndependent/glslang_tab.cpp" break; - case 651: /* jump_statement: CONTINUE SEMICOLON */ -#line 4259 "MachineIndependent/glslang.y" + case 658: /* jump_statement: CONTINUE SEMICOLON */ +#line 4307 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); } -#line 12345 "MachineIndependent/glslang_tab.cpp" +#line 12743 "MachineIndependent/glslang_tab.cpp" break; - case 652: /* jump_statement: BREAK SEMICOLON */ -#line 4264 "MachineIndependent/glslang.y" + case 659: /* jump_statement: BREAK SEMICOLON */ +#line 4312 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); } -#line 12355 "MachineIndependent/glslang_tab.cpp" +#line 12753 "MachineIndependent/glslang_tab.cpp" break; - case 653: /* jump_statement: RETURN SEMICOLON */ -#line 4269 "MachineIndependent/glslang.y" + case 660: /* jump_statement: RETURN SEMICOLON */ +#line 4317 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -12363,101 +12761,101 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 12367 "MachineIndependent/glslang_tab.cpp" +#line 12765 "MachineIndependent/glslang_tab.cpp" break; - case 654: /* jump_statement: RETURN expression SEMICOLON */ -#line 4276 "MachineIndependent/glslang.y" + case 661: /* jump_statement: RETURN expression SEMICOLON */ +#line 4324 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 12375 "MachineIndependent/glslang_tab.cpp" +#line 12773 "MachineIndependent/glslang_tab.cpp" break; - case 655: /* jump_statement: DISCARD SEMICOLON */ -#line 4279 "MachineIndependent/glslang.y" + case 662: /* jump_statement: DISCARD SEMICOLON */ +#line 4327 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 12384 "MachineIndependent/glslang_tab.cpp" +#line 12782 "MachineIndependent/glslang_tab.cpp" break; - case 656: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ -#line 4283 "MachineIndependent/glslang.y" + case 663: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ +#line 4331 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc); } -#line 12393 "MachineIndependent/glslang_tab.cpp" +#line 12791 "MachineIndependent/glslang_tab.cpp" break; - case 657: /* jump_statement: TERMINATE_RAY SEMICOLON */ -#line 4287 "MachineIndependent/glslang.y" + case 664: /* jump_statement: TERMINATE_RAY SEMICOLON */ +#line 4335 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc); } -#line 12402 "MachineIndependent/glslang_tab.cpp" +#line 12800 "MachineIndependent/glslang_tab.cpp" break; - case 658: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ -#line 4291 "MachineIndependent/glslang.y" + case 665: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ +#line 4339 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc); } -#line 12411 "MachineIndependent/glslang_tab.cpp" +#line 12809 "MachineIndependent/glslang_tab.cpp" break; - case 659: /* translation_unit: external_declaration */ -#line 4300 "MachineIndependent/glslang.y" + case 666: /* translation_unit: external_declaration */ +#line 4348 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 12420 "MachineIndependent/glslang_tab.cpp" +#line 12818 "MachineIndependent/glslang_tab.cpp" break; - case 660: /* translation_unit: translation_unit external_declaration */ -#line 4304 "MachineIndependent/glslang.y" + case 667: /* translation_unit: translation_unit external_declaration */ +#line 4352 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) != nullptr) { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } } -#line 12431 "MachineIndependent/glslang_tab.cpp" +#line 12829 "MachineIndependent/glslang_tab.cpp" break; - case 661: /* external_declaration: function_definition */ -#line 4313 "MachineIndependent/glslang.y" + case 668: /* external_declaration: function_definition */ +#line 4361 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12439 "MachineIndependent/glslang_tab.cpp" +#line 12837 "MachineIndependent/glslang_tab.cpp" break; - case 662: /* external_declaration: declaration */ -#line 4316 "MachineIndependent/glslang.y" + case 669: /* external_declaration: declaration */ +#line 4364 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 12447 "MachineIndependent/glslang_tab.cpp" +#line 12845 "MachineIndependent/glslang_tab.cpp" break; - case 663: /* external_declaration: SEMICOLON */ -#line 4319 "MachineIndependent/glslang.y" + case 670: /* external_declaration: SEMICOLON */ +#line 4367 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); (yyval.interm.intermNode) = nullptr; } -#line 12457 "MachineIndependent/glslang_tab.cpp" +#line 12855 "MachineIndependent/glslang_tab.cpp" break; - case 664: /* $@14: %empty */ -#line 4327 "MachineIndependent/glslang.y" + case 671: /* $@14: %empty */ +#line 4375 "MachineIndependent/glslang.y" { (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); @@ -12470,11 +12868,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; } } -#line 12474 "MachineIndependent/glslang_tab.cpp" +#line 12872 "MachineIndependent/glslang_tab.cpp" break; - case 665: /* function_definition: function_prototype $@14 compound_statement_no_new_scope */ -#line 4339 "MachineIndependent/glslang.y" + case 672: /* function_definition: function_prototype $@14 compound_statement_no_new_scope */ +#line 4387 "MachineIndependent/glslang.y" { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -12502,228 +12900,228 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; } } -#line 12506 "MachineIndependent/glslang_tab.cpp" +#line 12904 "MachineIndependent/glslang_tab.cpp" break; - case 666: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ -#line 4369 "MachineIndependent/glslang.y" + case 673: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ +#line 4417 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); } -#line 12514 "MachineIndependent/glslang_tab.cpp" +#line 12912 "MachineIndependent/glslang_tab.cpp" break; - case 667: /* attribute_list: single_attribute */ -#line 4374 "MachineIndependent/glslang.y" + case 674: /* attribute_list: single_attribute */ +#line 4422 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 12522 "MachineIndependent/glslang_tab.cpp" +#line 12920 "MachineIndependent/glslang_tab.cpp" break; - case 668: /* attribute_list: attribute_list COMMA single_attribute */ -#line 4377 "MachineIndependent/glslang.y" + case 675: /* attribute_list: attribute_list COMMA single_attribute */ +#line 4425 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 12530 "MachineIndependent/glslang_tab.cpp" +#line 12928 "MachineIndependent/glslang_tab.cpp" break; - case 669: /* single_attribute: IDENTIFIER */ -#line 4382 "MachineIndependent/glslang.y" + case 676: /* single_attribute: IDENTIFIER */ +#line 4430 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 12538 "MachineIndependent/glslang_tab.cpp" +#line 12936 "MachineIndependent/glslang_tab.cpp" break; - case 670: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ -#line 4385 "MachineIndependent/glslang.y" + case 677: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ +#line 4433 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 12546 "MachineIndependent/glslang_tab.cpp" +#line 12944 "MachineIndependent/glslang_tab.cpp" break; - case 671: /* spirv_requirements_list: spirv_requirements_parameter */ -#line 4390 "MachineIndependent/glslang.y" + case 678: /* spirv_requirements_list: spirv_requirements_parameter */ +#line 4438 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq); } -#line 12554 "MachineIndependent/glslang_tab.cpp" +#line 12952 "MachineIndependent/glslang_tab.cpp" break; - case 672: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ -#line 4393 "MachineIndependent/glslang.y" + case 679: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ +#line 4441 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq)); } -#line 12562 "MachineIndependent/glslang_tab.cpp" +#line 12960 "MachineIndependent/glslang_tab.cpp" break; - case 673: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ -#line 4398 "MachineIndependent/glslang.y" + case 680: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ +#line 4446 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr); } -#line 12570 "MachineIndependent/glslang_tab.cpp" +#line 12968 "MachineIndependent/glslang_tab.cpp" break; - case 674: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ -#line 4401 "MachineIndependent/glslang.y" + case 681: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ +#line 4449 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12578 "MachineIndependent/glslang_tab.cpp" +#line 12976 "MachineIndependent/glslang_tab.cpp" break; - case 675: /* spirv_extension_list: STRING_LITERAL */ -#line 4406 "MachineIndependent/glslang.y" + case 682: /* spirv_extension_list: STRING_LITERAL */ +#line 4454 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12586 "MachineIndependent/glslang_tab.cpp" +#line 12984 "MachineIndependent/glslang_tab.cpp" break; - case 676: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ -#line 4409 "MachineIndependent/glslang.y" + case 683: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ +#line 4457 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12594 "MachineIndependent/glslang_tab.cpp" +#line 12992 "MachineIndependent/glslang_tab.cpp" break; - case 677: /* spirv_capability_list: INTCONSTANT */ -#line 4414 "MachineIndependent/glslang.y" + case 684: /* spirv_capability_list: INTCONSTANT */ +#line 4462 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12602 "MachineIndependent/glslang_tab.cpp" +#line 13000 "MachineIndependent/glslang_tab.cpp" break; - case 678: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ -#line 4417 "MachineIndependent/glslang.y" + case 685: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ +#line 4465 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12610 "MachineIndependent/glslang_tab.cpp" +#line 13008 "MachineIndependent/glslang_tab.cpp" break; - case 679: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4422 "MachineIndependent/glslang.y" + case 686: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4470 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12619 "MachineIndependent/glslang_tab.cpp" +#line 13017 "MachineIndependent/glslang_tab.cpp" break; - case 680: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4426 "MachineIndependent/glslang.y" + case 687: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4474 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12629 "MachineIndependent/glslang_tab.cpp" +#line 13027 "MachineIndependent/glslang_tab.cpp" break; - case 681: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4431 "MachineIndependent/glslang.y" + case 688: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4479 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12638 "MachineIndependent/glslang_tab.cpp" +#line 13036 "MachineIndependent/glslang_tab.cpp" break; - case 682: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4435 "MachineIndependent/glslang.y" + case 689: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4483 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12648 "MachineIndependent/glslang_tab.cpp" +#line 13046 "MachineIndependent/glslang_tab.cpp" break; - case 683: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4440 "MachineIndependent/glslang.y" + case 690: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4488 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12657 "MachineIndependent/glslang_tab.cpp" +#line 13055 "MachineIndependent/glslang_tab.cpp" break; - case 684: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4444 "MachineIndependent/glslang.y" + case 691: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4492 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12667 "MachineIndependent/glslang_tab.cpp" +#line 13065 "MachineIndependent/glslang_tab.cpp" break; - case 685: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ -#line 4451 "MachineIndependent/glslang.y" + case 692: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ +#line 4499 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12675 "MachineIndependent/glslang_tab.cpp" +#line 13073 "MachineIndependent/glslang_tab.cpp" break; - case 686: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ -#line 4454 "MachineIndependent/glslang.y" + case 693: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ +#line 4502 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12683 "MachineIndependent/glslang_tab.cpp" +#line 13081 "MachineIndependent/glslang_tab.cpp" break; - case 687: /* spirv_execution_mode_parameter: FLOATCONSTANT */ -#line 4459 "MachineIndependent/glslang.y" + case 694: /* spirv_execution_mode_parameter: FLOATCONSTANT */ +#line 4507 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12691 "MachineIndependent/glslang_tab.cpp" +#line 13089 "MachineIndependent/glslang_tab.cpp" break; - case 688: /* spirv_execution_mode_parameter: INTCONSTANT */ -#line 4462 "MachineIndependent/glslang.y" + case 695: /* spirv_execution_mode_parameter: INTCONSTANT */ +#line 4510 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12699 "MachineIndependent/glslang_tab.cpp" +#line 13097 "MachineIndependent/glslang_tab.cpp" break; - case 689: /* spirv_execution_mode_parameter: UINTCONSTANT */ -#line 4465 "MachineIndependent/glslang.y" + case 696: /* spirv_execution_mode_parameter: UINTCONSTANT */ +#line 4513 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12707 "MachineIndependent/glslang_tab.cpp" +#line 13105 "MachineIndependent/glslang_tab.cpp" break; - case 690: /* spirv_execution_mode_parameter: BOOLCONSTANT */ -#line 4468 "MachineIndependent/glslang.y" + case 697: /* spirv_execution_mode_parameter: BOOLCONSTANT */ +#line 4516 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12715 "MachineIndependent/glslang_tab.cpp" +#line 13113 "MachineIndependent/glslang_tab.cpp" break; - case 691: /* spirv_execution_mode_parameter: STRING_LITERAL */ -#line 4471 "MachineIndependent/glslang.y" + case 698: /* spirv_execution_mode_parameter: STRING_LITERAL */ +#line 4519 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 12723 "MachineIndependent/glslang_tab.cpp" +#line 13121 "MachineIndependent/glslang_tab.cpp" break; - case 692: /* spirv_execution_mode_id_parameter_list: constant_expression */ -#line 4476 "MachineIndependent/glslang.y" + case 699: /* spirv_execution_mode_id_parameter_list: constant_expression */ +#line 4524 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12733,11 +13131,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode)); } -#line 12737 "MachineIndependent/glslang_tab.cpp" +#line 13135 "MachineIndependent/glslang_tab.cpp" break; - case 693: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ -#line 4485 "MachineIndependent/glslang.y" + case 700: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ +#line 4533 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12747,351 +13145,351 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode)); } -#line 12751 "MachineIndependent/glslang_tab.cpp" +#line 13149 "MachineIndependent/glslang_tab.cpp" break; - case 694: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4496 "MachineIndependent/glslang.y" + case 701: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4544 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12761 "MachineIndependent/glslang_tab.cpp" +#line 13159 "MachineIndependent/glslang_tab.cpp" break; - case 695: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4501 "MachineIndependent/glslang.y" + case 702: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4549 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12772 "MachineIndependent/glslang_tab.cpp" +#line 13170 "MachineIndependent/glslang_tab.cpp" break; - case 696: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4509 "MachineIndependent/glslang.y" + case 703: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4557 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12781 "MachineIndependent/glslang_tab.cpp" +#line 13179 "MachineIndependent/glslang_tab.cpp" break; - case 697: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4513 "MachineIndependent/glslang.y" + case 704: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4561 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12791 "MachineIndependent/glslang_tab.cpp" +#line 13189 "MachineIndependent/glslang_tab.cpp" break; - case 698: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4518 "MachineIndependent/glslang.y" + case 705: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4566 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12800 "MachineIndependent/glslang_tab.cpp" +#line 13198 "MachineIndependent/glslang_tab.cpp" break; - case 699: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4522 "MachineIndependent/glslang.y" + case 706: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4570 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12810 "MachineIndependent/glslang_tab.cpp" +#line 13208 "MachineIndependent/glslang_tab.cpp" break; - case 700: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4527 "MachineIndependent/glslang.y" + case 707: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4575 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12819 "MachineIndependent/glslang_tab.cpp" +#line 13217 "MachineIndependent/glslang_tab.cpp" break; - case 701: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4531 "MachineIndependent/glslang.y" + case 708: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4579 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12829 "MachineIndependent/glslang_tab.cpp" +#line 13227 "MachineIndependent/glslang_tab.cpp" break; - case 702: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4536 "MachineIndependent/glslang.y" + case 709: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4584 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12838 "MachineIndependent/glslang_tab.cpp" +#line 13236 "MachineIndependent/glslang_tab.cpp" break; - case 703: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4540 "MachineIndependent/glslang.y" + case 710: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4588 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12848 "MachineIndependent/glslang_tab.cpp" +#line 13246 "MachineIndependent/glslang_tab.cpp" break; - case 704: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ -#line 4547 "MachineIndependent/glslang.y" + case 711: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ +#line 4595 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12856 "MachineIndependent/glslang_tab.cpp" +#line 13254 "MachineIndependent/glslang_tab.cpp" break; - case 705: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ -#line 4550 "MachineIndependent/glslang.y" + case 712: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ +#line 4598 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12864 "MachineIndependent/glslang_tab.cpp" +#line 13262 "MachineIndependent/glslang_tab.cpp" break; - case 706: /* spirv_decorate_parameter: FLOATCONSTANT */ -#line 4555 "MachineIndependent/glslang.y" + case 713: /* spirv_decorate_parameter: FLOATCONSTANT */ +#line 4603 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12872 "MachineIndependent/glslang_tab.cpp" +#line 13270 "MachineIndependent/glslang_tab.cpp" break; - case 707: /* spirv_decorate_parameter: INTCONSTANT */ -#line 4558 "MachineIndependent/glslang.y" + case 714: /* spirv_decorate_parameter: INTCONSTANT */ +#line 4606 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12880 "MachineIndependent/glslang_tab.cpp" +#line 13278 "MachineIndependent/glslang_tab.cpp" break; - case 708: /* spirv_decorate_parameter: UINTCONSTANT */ -#line 4561 "MachineIndependent/glslang.y" + case 715: /* spirv_decorate_parameter: UINTCONSTANT */ +#line 4609 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12888 "MachineIndependent/glslang_tab.cpp" +#line 13286 "MachineIndependent/glslang_tab.cpp" break; - case 709: /* spirv_decorate_parameter: BOOLCONSTANT */ -#line 4564 "MachineIndependent/glslang.y" + case 716: /* spirv_decorate_parameter: BOOLCONSTANT */ +#line 4612 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12896 "MachineIndependent/glslang_tab.cpp" +#line 13294 "MachineIndependent/glslang_tab.cpp" break; - case 710: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ -#line 4569 "MachineIndependent/glslang.y" + case 717: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ +#line 4617 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12904 "MachineIndependent/glslang_tab.cpp" +#line 13302 "MachineIndependent/glslang_tab.cpp" break; - case 711: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ -#line 4572 "MachineIndependent/glslang.y" + case 718: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ +#line 4620 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12912 "MachineIndependent/glslang_tab.cpp" +#line 13310 "MachineIndependent/glslang_tab.cpp" break; - case 712: /* spirv_decorate_id_parameter: variable_identifier */ -#line 4577 "MachineIndependent/glslang.y" + case 719: /* spirv_decorate_id_parameter: variable_identifier */ +#line 4625 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getAsConstantUnion() || (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode()) (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode); else parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "only allow constants or variables which are not elements of a composite", "", ""); } -#line 12923 "MachineIndependent/glslang_tab.cpp" +#line 13321 "MachineIndependent/glslang_tab.cpp" break; - case 713: /* spirv_decorate_id_parameter: FLOATCONSTANT */ -#line 4583 "MachineIndependent/glslang.y" + case 720: /* spirv_decorate_id_parameter: FLOATCONSTANT */ +#line 4631 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12931 "MachineIndependent/glslang_tab.cpp" +#line 13329 "MachineIndependent/glslang_tab.cpp" break; - case 714: /* spirv_decorate_id_parameter: INTCONSTANT */ -#line 4586 "MachineIndependent/glslang.y" + case 721: /* spirv_decorate_id_parameter: INTCONSTANT */ +#line 4634 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12939 "MachineIndependent/glslang_tab.cpp" +#line 13337 "MachineIndependent/glslang_tab.cpp" break; - case 715: /* spirv_decorate_id_parameter: UINTCONSTANT */ -#line 4589 "MachineIndependent/glslang.y" + case 722: /* spirv_decorate_id_parameter: UINTCONSTANT */ +#line 4637 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12947 "MachineIndependent/glslang_tab.cpp" +#line 13345 "MachineIndependent/glslang_tab.cpp" break; - case 716: /* spirv_decorate_id_parameter: BOOLCONSTANT */ -#line 4592 "MachineIndependent/glslang.y" + case 723: /* spirv_decorate_id_parameter: BOOLCONSTANT */ +#line 4640 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12955 "MachineIndependent/glslang_tab.cpp" +#line 13353 "MachineIndependent/glslang_tab.cpp" break; - case 717: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ -#line 4597 "MachineIndependent/glslang.y" + case 724: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ +#line 4645 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate( parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12964 "MachineIndependent/glslang_tab.cpp" +#line 13362 "MachineIndependent/glslang_tab.cpp" break; - case 718: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ -#line 4601 "MachineIndependent/glslang.y" + case 725: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ +#line 4649 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12972 "MachineIndependent/glslang_tab.cpp" +#line 13370 "MachineIndependent/glslang_tab.cpp" break; - case 719: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4606 "MachineIndependent/glslang.y" + case 726: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4654 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12981 "MachineIndependent/glslang_tab.cpp" +#line 13379 "MachineIndependent/glslang_tab.cpp" break; - case 720: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4610 "MachineIndependent/glslang.y" + case 727: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4658 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12991 "MachineIndependent/glslang_tab.cpp" +#line 13389 "MachineIndependent/glslang_tab.cpp" break; - case 721: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4615 "MachineIndependent/glslang.y" + case 728: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4663 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 13000 "MachineIndependent/glslang_tab.cpp" +#line 13398 "MachineIndependent/glslang_tab.cpp" break; - case 722: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4619 "MachineIndependent/glslang.y" + case 729: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4667 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 13010 "MachineIndependent/glslang_tab.cpp" +#line 13408 "MachineIndependent/glslang_tab.cpp" break; - case 723: /* spirv_type_parameter_list: spirv_type_parameter */ -#line 4626 "MachineIndependent/glslang.y" + case 730: /* spirv_type_parameter_list: spirv_type_parameter */ +#line 4674 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams); } -#line 13018 "MachineIndependent/glslang_tab.cpp" +#line 13416 "MachineIndependent/glslang_tab.cpp" break; - case 724: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ -#line 4629 "MachineIndependent/glslang.y" + case 731: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ +#line 4677 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams)); } -#line 13026 "MachineIndependent/glslang_tab.cpp" +#line 13424 "MachineIndependent/glslang_tab.cpp" break; - case 725: /* spirv_type_parameter: constant_expression */ -#line 4634 "MachineIndependent/glslang.y" + case 732: /* spirv_type_parameter: constant_expression */ +#line 4682 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion()); } -#line 13034 "MachineIndependent/glslang_tab.cpp" +#line 13432 "MachineIndependent/glslang_tab.cpp" break; - case 726: /* spirv_type_parameter: type_specifier_nonarray */ -#line 4637 "MachineIndependent/glslang.y" + case 733: /* spirv_type_parameter: type_specifier_nonarray */ +#line 4685 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 13042 "MachineIndependent/glslang_tab.cpp" +#line 13440 "MachineIndependent/glslang_tab.cpp" break; - case 727: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4642 "MachineIndependent/glslang.y" + case 734: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4690 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 13050 "MachineIndependent/glslang_tab.cpp" +#line 13448 "MachineIndependent/glslang_tab.cpp" break; - case 728: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4645 "MachineIndependent/glslang.y" + case 735: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4693 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 13059 "MachineIndependent/glslang_tab.cpp" +#line 13457 "MachineIndependent/glslang_tab.cpp" break; - case 729: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ -#line 4651 "MachineIndependent/glslang.y" + case 736: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ +#line 4699 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst); } -#line 13067 "MachineIndependent/glslang_tab.cpp" +#line 13465 "MachineIndependent/glslang_tab.cpp" break; - case 730: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ -#line 4654 "MachineIndependent/glslang.y" + case 737: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ +#line 4702 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst)); } -#line 13075 "MachineIndependent/glslang_tab.cpp" +#line 13473 "MachineIndependent/glslang_tab.cpp" break; - case 731: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ -#line 4659 "MachineIndependent/glslang.y" + case 738: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ +#line 4707 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string); } -#line 13083 "MachineIndependent/glslang_tab.cpp" +#line 13481 "MachineIndependent/glslang_tab.cpp" break; - case 732: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ -#line 4662 "MachineIndependent/glslang.y" + case 739: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ +#line 4710 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i); } -#line 13091 "MachineIndependent/glslang_tab.cpp" +#line 13489 "MachineIndependent/glslang_tab.cpp" break; -#line 13095 "MachineIndependent/glslang_tab.cpp" +#line 13493 "MachineIndependent/glslang_tab.cpp" default: break; } @@ -13315,5 +13713,5 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); return yyresult; } -#line 4666 "MachineIndependent/glslang.y" +#line 4714 "MachineIndependent/glslang.y" diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h index 11932ead0d..2caa60502c 100644 --- a/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/glslang/MachineIndependent/glslang_tab.cpp.h @@ -400,145 +400,147 @@ extern int yydebug; SPIRV_STORAGE_CLASS = 601, /* SPIRV_STORAGE_CLASS */ SPIRV_BY_REFERENCE = 602, /* SPIRV_BY_REFERENCE */ SPIRV_LITERAL = 603, /* SPIRV_LITERAL */ - ATTACHMENTEXT = 604, /* ATTACHMENTEXT */ - IATTACHMENTEXT = 605, /* IATTACHMENTEXT */ - UATTACHMENTEXT = 606, /* UATTACHMENTEXT */ - LEFT_OP = 607, /* LEFT_OP */ - RIGHT_OP = 608, /* RIGHT_OP */ - INC_OP = 609, /* INC_OP */ - DEC_OP = 610, /* DEC_OP */ - LE_OP = 611, /* LE_OP */ - GE_OP = 612, /* GE_OP */ - EQ_OP = 613, /* EQ_OP */ - NE_OP = 614, /* NE_OP */ - AND_OP = 615, /* AND_OP */ - OR_OP = 616, /* OR_OP */ - XOR_OP = 617, /* XOR_OP */ - MUL_ASSIGN = 618, /* MUL_ASSIGN */ - DIV_ASSIGN = 619, /* DIV_ASSIGN */ - ADD_ASSIGN = 620, /* ADD_ASSIGN */ - MOD_ASSIGN = 621, /* MOD_ASSIGN */ - LEFT_ASSIGN = 622, /* LEFT_ASSIGN */ - RIGHT_ASSIGN = 623, /* RIGHT_ASSIGN */ - AND_ASSIGN = 624, /* AND_ASSIGN */ - XOR_ASSIGN = 625, /* XOR_ASSIGN */ - OR_ASSIGN = 626, /* OR_ASSIGN */ - SUB_ASSIGN = 627, /* SUB_ASSIGN */ - STRING_LITERAL = 628, /* STRING_LITERAL */ - LEFT_PAREN = 629, /* LEFT_PAREN */ - RIGHT_PAREN = 630, /* RIGHT_PAREN */ - LEFT_BRACKET = 631, /* LEFT_BRACKET */ - RIGHT_BRACKET = 632, /* RIGHT_BRACKET */ - LEFT_BRACE = 633, /* LEFT_BRACE */ - RIGHT_BRACE = 634, /* RIGHT_BRACE */ - DOT = 635, /* DOT */ - COMMA = 636, /* COMMA */ - COLON = 637, /* COLON */ - EQUAL = 638, /* EQUAL */ - SEMICOLON = 639, /* SEMICOLON */ - BANG = 640, /* BANG */ - DASH = 641, /* DASH */ - TILDE = 642, /* TILDE */ - PLUS = 643, /* PLUS */ - STAR = 644, /* STAR */ - SLASH = 645, /* SLASH */ - PERCENT = 646, /* PERCENT */ - LEFT_ANGLE = 647, /* LEFT_ANGLE */ - RIGHT_ANGLE = 648, /* RIGHT_ANGLE */ - VERTICAL_BAR = 649, /* VERTICAL_BAR */ - CARET = 650, /* CARET */ - AMPERSAND = 651, /* AMPERSAND */ - QUESTION = 652, /* QUESTION */ - INVARIANT = 653, /* INVARIANT */ - HIGH_PRECISION = 654, /* HIGH_PRECISION */ - MEDIUM_PRECISION = 655, /* MEDIUM_PRECISION */ - LOW_PRECISION = 656, /* LOW_PRECISION */ - PRECISION = 657, /* PRECISION */ - PACKED = 658, /* PACKED */ - RESOURCE = 659, /* RESOURCE */ - SUPERP = 660, /* SUPERP */ - FLOATCONSTANT = 661, /* FLOATCONSTANT */ - INTCONSTANT = 662, /* INTCONSTANT */ - UINTCONSTANT = 663, /* UINTCONSTANT */ - BOOLCONSTANT = 664, /* BOOLCONSTANT */ - IDENTIFIER = 665, /* IDENTIFIER */ - TYPE_NAME = 666, /* TYPE_NAME */ - CENTROID = 667, /* CENTROID */ - IN = 668, /* IN */ - OUT = 669, /* OUT */ - INOUT = 670, /* INOUT */ - STRUCT = 671, /* STRUCT */ - VOID = 672, /* VOID */ - WHILE = 673, /* WHILE */ - BREAK = 674, /* BREAK */ - CONTINUE = 675, /* CONTINUE */ - DO = 676, /* DO */ - ELSE = 677, /* ELSE */ - FOR = 678, /* FOR */ - IF = 679, /* IF */ - DISCARD = 680, /* DISCARD */ - RETURN = 681, /* RETURN */ - SWITCH = 682, /* SWITCH */ - CASE = 683, /* CASE */ - DEFAULT = 684, /* DEFAULT */ - TERMINATE_INVOCATION = 685, /* TERMINATE_INVOCATION */ - TERMINATE_RAY = 686, /* TERMINATE_RAY */ - IGNORE_INTERSECTION = 687, /* IGNORE_INTERSECTION */ - UNIFORM = 688, /* UNIFORM */ - SHARED = 689, /* SHARED */ - BUFFER = 690, /* BUFFER */ - TILEIMAGEEXT = 691, /* TILEIMAGEEXT */ - FLAT = 692, /* FLAT */ - SMOOTH = 693, /* SMOOTH */ - LAYOUT = 694, /* LAYOUT */ - DOUBLECONSTANT = 695, /* DOUBLECONSTANT */ - INT16CONSTANT = 696, /* INT16CONSTANT */ - UINT16CONSTANT = 697, /* UINT16CONSTANT */ - FLOAT16CONSTANT = 698, /* FLOAT16CONSTANT */ - INT32CONSTANT = 699, /* INT32CONSTANT */ - UINT32CONSTANT = 700, /* UINT32CONSTANT */ - INT64CONSTANT = 701, /* INT64CONSTANT */ - UINT64CONSTANT = 702, /* UINT64CONSTANT */ - SUBROUTINE = 703, /* SUBROUTINE */ - DEMOTE = 704, /* DEMOTE */ - FUNCTION = 705, /* FUNCTION */ - PAYLOADNV = 706, /* PAYLOADNV */ - PAYLOADINNV = 707, /* PAYLOADINNV */ - HITATTRNV = 708, /* HITATTRNV */ - CALLDATANV = 709, /* CALLDATANV */ - CALLDATAINNV = 710, /* CALLDATAINNV */ - PAYLOADEXT = 711, /* PAYLOADEXT */ - PAYLOADINEXT = 712, /* PAYLOADINEXT */ - HITATTREXT = 713, /* HITATTREXT */ - CALLDATAEXT = 714, /* CALLDATAEXT */ - CALLDATAINEXT = 715, /* CALLDATAINEXT */ - PATCH = 716, /* PATCH */ - SAMPLE = 717, /* SAMPLE */ - NONUNIFORM = 718, /* NONUNIFORM */ - RESOURCEHEAP = 719, /* RESOURCEHEAP */ - SAMPLERHEAP = 720, /* SAMPLERHEAP */ - COHERENT = 721, /* COHERENT */ - VOLATILE = 722, /* VOLATILE */ - RESTRICT = 723, /* RESTRICT */ - READONLY = 724, /* READONLY */ - WRITEONLY = 725, /* WRITEONLY */ - NONTEMPORAL = 726, /* NONTEMPORAL */ - DEVICECOHERENT = 727, /* DEVICECOHERENT */ - QUEUEFAMILYCOHERENT = 728, /* QUEUEFAMILYCOHERENT */ - WORKGROUPCOHERENT = 729, /* WORKGROUPCOHERENT */ - SUBGROUPCOHERENT = 730, /* SUBGROUPCOHERENT */ - NONPRIVATE = 731, /* NONPRIVATE */ - SHADERCALLCOHERENT = 732, /* SHADERCALLCOHERENT */ - NOPERSPECTIVE = 733, /* NOPERSPECTIVE */ - EXPLICITINTERPAMD = 734, /* EXPLICITINTERPAMD */ - PERVERTEXEXT = 735, /* PERVERTEXEXT */ - PERVERTEXNV = 736, /* PERVERTEXNV */ - PERPRIMITIVENV = 737, /* PERPRIMITIVENV */ - PERVIEWNV = 738, /* PERVIEWNV */ - PERTASKNV = 739, /* PERTASKNV */ - PERPRIMITIVEEXT = 740, /* PERPRIMITIVEEXT */ - TASKPAYLOADWORKGROUPEXT = 741, /* TASKPAYLOADWORKGROUPEXT */ - PRECISE = 742 /* PRECISE */ + SPIRV_STRING = 604, /* SPIRV_STRING */ + ATTACHMENTEXT = 605, /* ATTACHMENTEXT */ + IATTACHMENTEXT = 606, /* IATTACHMENTEXT */ + UATTACHMENTEXT = 607, /* UATTACHMENTEXT */ + LEFT_OP = 608, /* LEFT_OP */ + RIGHT_OP = 609, /* RIGHT_OP */ + INC_OP = 610, /* INC_OP */ + DEC_OP = 611, /* DEC_OP */ + LE_OP = 612, /* LE_OP */ + GE_OP = 613, /* GE_OP */ + EQ_OP = 614, /* EQ_OP */ + NE_OP = 615, /* NE_OP */ + AND_OP = 616, /* AND_OP */ + OR_OP = 617, /* OR_OP */ + XOR_OP = 618, /* XOR_OP */ + MUL_ASSIGN = 619, /* MUL_ASSIGN */ + DIV_ASSIGN = 620, /* DIV_ASSIGN */ + ADD_ASSIGN = 621, /* ADD_ASSIGN */ + MOD_ASSIGN = 622, /* MOD_ASSIGN */ + LEFT_ASSIGN = 623, /* LEFT_ASSIGN */ + RIGHT_ASSIGN = 624, /* RIGHT_ASSIGN */ + AND_ASSIGN = 625, /* AND_ASSIGN */ + XOR_ASSIGN = 626, /* XOR_ASSIGN */ + OR_ASSIGN = 627, /* OR_ASSIGN */ + SUB_ASSIGN = 628, /* SUB_ASSIGN */ + STRING_LITERAL = 629, /* STRING_LITERAL */ + LEFT_PAREN = 630, /* LEFT_PAREN */ + RIGHT_PAREN = 631, /* RIGHT_PAREN */ + LEFT_BRACKET = 632, /* LEFT_BRACKET */ + RIGHT_BRACKET = 633, /* RIGHT_BRACKET */ + LEFT_BRACE = 634, /* LEFT_BRACE */ + RIGHT_BRACE = 635, /* RIGHT_BRACE */ + DOT = 636, /* DOT */ + ELLIPSIS = 637, /* ELLIPSIS */ + COMMA = 638, /* COMMA */ + COLON = 639, /* COLON */ + EQUAL = 640, /* EQUAL */ + SEMICOLON = 641, /* SEMICOLON */ + BANG = 642, /* BANG */ + DASH = 643, /* DASH */ + TILDE = 644, /* TILDE */ + PLUS = 645, /* PLUS */ + STAR = 646, /* STAR */ + SLASH = 647, /* SLASH */ + PERCENT = 648, /* PERCENT */ + LEFT_ANGLE = 649, /* LEFT_ANGLE */ + RIGHT_ANGLE = 650, /* RIGHT_ANGLE */ + VERTICAL_BAR = 651, /* VERTICAL_BAR */ + CARET = 652, /* CARET */ + AMPERSAND = 653, /* AMPERSAND */ + QUESTION = 654, /* QUESTION */ + INVARIANT = 655, /* INVARIANT */ + HIGH_PRECISION = 656, /* HIGH_PRECISION */ + MEDIUM_PRECISION = 657, /* MEDIUM_PRECISION */ + LOW_PRECISION = 658, /* LOW_PRECISION */ + PRECISION = 659, /* PRECISION */ + PACKED = 660, /* PACKED */ + RESOURCE = 661, /* RESOURCE */ + SUPERP = 662, /* SUPERP */ + FLOATCONSTANT = 663, /* FLOATCONSTANT */ + INTCONSTANT = 664, /* INTCONSTANT */ + UINTCONSTANT = 665, /* UINTCONSTANT */ + BOOLCONSTANT = 666, /* BOOLCONSTANT */ + IDENTIFIER = 667, /* IDENTIFIER */ + TYPE_NAME = 668, /* TYPE_NAME */ + CENTROID = 669, /* CENTROID */ + IN = 670, /* IN */ + OUT = 671, /* OUT */ + INOUT = 672, /* INOUT */ + STRUCT = 673, /* STRUCT */ + VOID = 674, /* VOID */ + WHILE = 675, /* WHILE */ + BREAK = 676, /* BREAK */ + CONTINUE = 677, /* CONTINUE */ + DO = 678, /* DO */ + ELSE = 679, /* ELSE */ + FOR = 680, /* FOR */ + IF = 681, /* IF */ + DISCARD = 682, /* DISCARD */ + RETURN = 683, /* RETURN */ + SWITCH = 684, /* SWITCH */ + CASE = 685, /* CASE */ + DEFAULT = 686, /* DEFAULT */ + TERMINATE_INVOCATION = 687, /* TERMINATE_INVOCATION */ + TERMINATE_RAY = 688, /* TERMINATE_RAY */ + IGNORE_INTERSECTION = 689, /* IGNORE_INTERSECTION */ + UNIFORM = 690, /* UNIFORM */ + SHARED = 691, /* SHARED */ + BUFFER = 692, /* BUFFER */ + TILEIMAGEEXT = 693, /* TILEIMAGEEXT */ + FLAT = 694, /* FLAT */ + SMOOTH = 695, /* SMOOTH */ + LAYOUT = 696, /* LAYOUT */ + DOUBLECONSTANT = 697, /* DOUBLECONSTANT */ + INT16CONSTANT = 698, /* INT16CONSTANT */ + UINT16CONSTANT = 699, /* UINT16CONSTANT */ + FLOAT16CONSTANT = 700, /* FLOAT16CONSTANT */ + INT32CONSTANT = 701, /* INT32CONSTANT */ + UINT32CONSTANT = 702, /* UINT32CONSTANT */ + INT64CONSTANT = 703, /* INT64CONSTANT */ + UINT64CONSTANT = 704, /* UINT64CONSTANT */ + SUBROUTINE = 705, /* SUBROUTINE */ + DEMOTE = 706, /* DEMOTE */ + FUNCTION = 707, /* FUNCTION */ + PAYLOADNV = 708, /* PAYLOADNV */ + PAYLOADINNV = 709, /* PAYLOADINNV */ + HITATTRNV = 710, /* HITATTRNV */ + CALLDATANV = 711, /* CALLDATANV */ + CALLDATAINNV = 712, /* CALLDATAINNV */ + PAYLOADEXT = 713, /* PAYLOADEXT */ + PAYLOADINEXT = 714, /* PAYLOADINEXT */ + HITATTREXT = 715, /* HITATTREXT */ + CALLDATAEXT = 716, /* CALLDATAEXT */ + CALLDATAINEXT = 717, /* CALLDATAINEXT */ + PATCH = 718, /* PATCH */ + SAMPLE = 719, /* SAMPLE */ + NONUNIFORM = 720, /* NONUNIFORM */ + RESOURCEHEAP = 721, /* RESOURCEHEAP */ + SAMPLERHEAP = 722, /* SAMPLERHEAP */ + COHERENT = 723, /* COHERENT */ + VOLATILE = 724, /* VOLATILE */ + RESTRICT = 725, /* RESTRICT */ + READONLY = 726, /* READONLY */ + WRITEONLY = 727, /* WRITEONLY */ + NONTEMPORAL = 728, /* NONTEMPORAL */ + DEVICECOHERENT = 729, /* DEVICECOHERENT */ + QUEUEFAMILYCOHERENT = 730, /* QUEUEFAMILYCOHERENT */ + WORKGROUPCOHERENT = 731, /* WORKGROUPCOHERENT */ + SUBGROUPCOHERENT = 732, /* SUBGROUPCOHERENT */ + NONPRIVATE = 733, /* NONPRIVATE */ + SHADERCALLCOHERENT = 734, /* SHADERCALLCOHERENT */ + NOPERSPECTIVE = 735, /* NOPERSPECTIVE */ + EXPLICITINTERPAMD = 736, /* EXPLICITINTERPAMD */ + PERVERTEXEXT = 737, /* PERVERTEXEXT */ + PERVERTEXNV = 738, /* PERVERTEXNV */ + PERPRIMITIVENV = 739, /* PERPRIMITIVENV */ + PERVIEWNV = 740, /* PERVIEWNV */ + PERTASKNV = 741, /* PERTASKNV */ + PERPRIMITIVEEXT = 742, /* PERPRIMITIVEEXT */ + TASKPAYLOADWORKGROUPEXT = 743, /* TASKPAYLOADWORKGROUPEXT */ + PRECISE = 744 /* PRECISE */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -586,7 +588,7 @@ union YYSTYPE glslang::TTypeParameters* typeParameters; } interm; -#line 590 "MachineIndependent/glslang_tab.cpp.h" +#line 592 "MachineIndependent/glslang_tab.cpp.h" }; typedef union YYSTYPE YYSTYPE; diff --git a/glslang/MachineIndependent/preprocessor/PpAtom.cpp b/glslang/MachineIndependent/preprocessor/PpAtom.cpp index 06c2333ef1..38c7692a61 100644 --- a/glslang/MachineIndependent/preprocessor/PpAtom.cpp +++ b/glslang/MachineIndependent/preprocessor/PpAtom.cpp @@ -123,6 +123,7 @@ const struct { { PpAtomIncrement, "++" }, { PpAtomColonColon, "::" }, + { PpAtomEllipsis, "..." }, { PpAtomDefine, "define" }, { PpAtomUndef, "undef" }, diff --git a/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/glslang/MachineIndependent/preprocessor/PpScanner.cpp index 61b75b7457..37ab157531 100644 --- a/glslang/MachineIndependent/preprocessor/PpScanner.cpp +++ b/glslang/MachineIndependent/preprocessor/PpScanner.cpp @@ -1072,7 +1072,14 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } case '.': ch = getch(); - if (ch >= '0' && ch <= '9') { + if (ch == '.') { + ch = getch(); + if (ch == '.') + return PpAtomEllipsis; + ungetch(); + ungetch(); + return '.'; + } else if (ch >= '0' && ch <= '9') { ungetch(); return pp->lFloatConst(0, '.', ppToken); } else { @@ -1123,6 +1130,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ch = getch(); while (ch != '"' && ch != '\n' && ch != EndOfInput) { if (len < MaxTokenLength) { + bool escapeError = false; if (ch == '\\' && !pp->disableEscapeSequences) { int nextCh = getch(); switch (nextCh) { @@ -1160,6 +1168,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } if (numDigits == 0) { pp->parseContext.ppError(ppToken->loc, "Expected hex value in escape sequence", "string", ""); + escapeError = true; } break; } @@ -1190,9 +1199,13 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } default: pp->parseContext.ppError(ppToken->loc, "Invalid escape sequence", "string", ""); + escapeError = true; break; } } + if (ch == 0 && !escapeError) + pp->parseContext.ppError(ppToken->loc, + "embedded NUL character not allowed in string literal", "string", ""); ppToken->name[len] = (char)ch; len++; ch = getch(); diff --git a/glslang/MachineIndependent/preprocessor/PpTokens.h b/glslang/MachineIndependent/preprocessor/PpTokens.h index 7b0f815500..04d42a6967 100644 --- a/glslang/MachineIndependent/preprocessor/PpTokens.h +++ b/glslang/MachineIndependent/preprocessor/PpTokens.h @@ -118,6 +118,7 @@ enum EFixedAtoms { PpAtomIncrement, PpAtomColonColon, + PpAtomEllipsis, PpAtomPaste, diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp index 0d50b025b7..dd3f342df4 100644 --- a/gtests/Spv.FromFile.cpp +++ b/gtests/Spv.FromFile.cpp @@ -467,6 +467,15 @@ INSTANTIATE_TEST_SUITE_P( "spv.intrinsicsSpirvDecorateString.comp", "spv.intrinsicsSpirvExecutionMode.frag", "spv.intrinsicsSpirvInstruction.vert", + "spv.intrinsicsSpirvInstructionVariadic.vert", + "spv.intrinsicsSpirvInstructionVariadic.error.vert", + "spv.intrinsicsSpirvInstructionVariadicOverload.vert", + "spv.intrinsicsSpirvInstructionVariadic330.vert", + "spv.intrinsicsSpirvInstructionVariadic.syntaxBadTail.vert", + "spv.intrinsicsSpirvInstructionVariadic.syntaxSpacedDots.vert", + "spv.intrinsicsSpirvInstructionString.vert", + "spv.intrinsicsSpirvInstructionString.error.vert", + "spv.intrinsicsSpirvInstructionStringVariadic.vert", "spv.intrinsicsSpirvLiteral.vert", "spv.intrinsicsSpirvStorageClass.rchit", "spv.intrinsicsSpirvType.rgen",