Add 2D MS array sampler support to compiler

include/GLSLANG/ShaderLang.h

@@ -71,13 +71,13 @@ enum ShShaderOutput
 // The Compile options type is defined in ShaderVars.h, to allow ANGLE to import the ShaderVars
 // header without needing the ShaderLang header. This avoids some conflicts with glslang.
 
-const ShCompileOptions SH_VALIDATE                           = 0;
-const ShCompileOptions SH_VALIDATE_LOOP_INDEXING             = UINT64_C(1) << 0;
-const ShCompileOptions SH_INTERMEDIATE_TREE                  = UINT64_C(1) << 1;
-const ShCompileOptions SH_OBJECT_CODE                        = UINT64_C(1) << 2;
-const ShCompileOptions SH_VARIABLES                          = UINT64_C(1) << 3;
-const ShCompileOptions SH_LINE_DIRECTIVES                    = UINT64_C(1) << 4;
-const ShCompileOptions SH_SOURCE_PATH                        = UINT64_C(1) << 5;
+const ShCompileOptions SH_VALIDATE               = 0;
+const ShCompileOptions SH_VALIDATE_LOOP_INDEXING = UINT64_C(1) << 0;
+const ShCompileOptions SH_INTERMEDIATE_TREE      = UINT64_C(1) << 1;
+const ShCompileOptions SH_OBJECT_CODE            = UINT64_C(1) << 2;
+const ShCompileOptions SH_VARIABLES              = UINT64_C(1) << 3;
+const ShCompileOptions SH_LINE_DIRECTIVES        = UINT64_C(1) << 4;
+const ShCompileOptions SH_SOURCE_PATH            = UINT64_C(1) << 5;
 
 // This flag will keep invariant declaration for input in fragment shader for GLSL >=4.20 on AMD.
 // From GLSL >= 4.20, it's optional to add invariant for fragment input, but GPU vendors have
@@ -313,6 +313,7 @@ struct ShBuiltInResources
     int OVR_multiview;
     int EXT_YUV_target;
     int EXT_geometry_shader;
+    int ANGLE_texture_multisample_array;
 
     // Set to 1 to enable replacing GL_EXT_draw_buffers #extension directives
     // with GL_NV_draw_buffers in ESSL output. This flag can be used to emulate
@@ -616,4 +617,4 @@ int GetGeometryShaderMaxVertices(const ShHandle handle);
 
 }  // namespace sh
 
-#endif // GLSLANG_SHADERLANG_H_
+#endif  // GLSLANG_SHADERLANG_H_

scripts/run_code_generation_hashes.json

@@ -32,11 +32,11 @@
   "DXGI format:src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py":
     "2932a5e1c3c846be0169e29a4f9c72e8",
   "ESSL static builtins:src/compiler/translator/builtin_function_declarations.txt":
-    "39b92f5a4d982873d3595b70049d5160",
+    "36f9636dbfbcd6508a4b76143c5e4540",
   "ESSL static builtins:src/compiler/translator/builtin_variables.json":
     "2c0e86ff9f92f79ada03f04206e63fba",
   "ESSL static builtins:src/compiler/translator/gen_builtin_symbols.py":
-    "51afaa8fc47b537aa4e62552de9cc7c0",
+    "9a5226ee6573650897bdc21e1bb0bfd0",
   "Emulated HLSL functions:src/compiler/translator/emulated_builtin_function_data_hlsl.json":
     "002ad46d144c51fe98d73478aa554ba7",
   "Emulated HLSL functions:src/compiler/translator/gen_emulated_builtin_function_tables.py":
@@ -46,7 +46,7 @@
   "GL copy conversion table:src/libANGLE/gen_copy_conversion_table.py":
     "ac1afe23d9578bd1d2ef74f4a7aa927a",
   "GL entry point:scripts/entry_point_packed_gl_enums.json":
-    "154df93d8af5156b1f434a7a1a84b671",
+    "803930a62d35ed9b83faba037f34e293",
   "GL entry point:scripts/generate_entry_points.py":
     "c502f05207c8a2eb27ae67e48b5d02c2",
   "GL entry point:scripts/gl.xml":

src/compiler/translator/BaseTypes.h

@@ -70,16 +70,19 @@ enum TBasicType
     EbtSamplerExternal2DY2YEXT,  // Only valid if GL_EXT_YUV_target exists.
     EbtSampler2DRect,            // Only valid if GL_ARB_texture_rectangle exists.
     EbtSampler2DMS,
+    EbtSampler2DMSArray,
     EbtISampler2D,
     EbtISampler3D,
     EbtISamplerCube,
     EbtISampler2DArray,
     EbtISampler2DMS,
+    EbtISampler2DMSArray,
     EbtUSampler2D,
     EbtUSampler3D,
     EbtUSamplerCube,
     EbtUSampler2DArray,
     EbtUSampler2DMS,
+    EbtUSampler2DMSArray,
     EbtSampler2DShadow,
     EbtSamplerCubeShadow,
     EbtSampler2DArrayShadow,

src/compiler/translator/ExtensionBehavior.cpp

@@ -13,6 +13,7 @@
 #include <string.h>
 
 #define LIST_EXTENSIONS(OP)             \
+    OP(ANGLE_texture_multisample_array) \
     OP(ARB_texture_rectangle)           \
     OP(ARM_shader_framebuffer_fetch)    \
     OP(EXT_blend_func_extended)         \

src/compiler/translator/ExtensionBehavior.h

@@ -18,6 +18,7 @@ enum class TExtension
 {
     UNDEFINED,  // Special value used to indicate no extension.
 
+    ANGLE_texture_multisample_array,
     ARB_texture_rectangle,
     ARM_shader_framebuffer_fetch,
     EXT_blend_func_extended,

src/compiler/translator/Initialize.cpp

@@ -73,6 +73,10 @@ void InitExtensionBehavior(const ShBuiltInResources &resources, TExtensionBehavi
     {
         extBehavior[TExtension::EXT_geometry_shader] = EBhUndefined;
     }
+    if (resources.ANGLE_texture_multisample_array)
+    {
+        extBehavior[TExtension::ANGLE_texture_multisample_array] = EBhUndefined;
+    }
 }
 
 void ResetExtensionBehavior(TExtensionBehavior &extBehavior)

src/compiler/translator/ParseContext_autogen.h

@@ -21,42 +21,42 @@ namespace BuiltInGroup
 bool isTextureOffsetNoBias(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 662 && id <= 731;
+    return id >= 668 && id <= 737;
 }
 bool isTextureOffsetBias(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 732 && id <= 751;
+    return id >= 738 && id <= 757;
 }
 bool isTextureGatherOffset(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 823 && id <= 836;
+    return id >= 832 && id <= 845;
 }
 bool isTextureGather(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 799 && id <= 836;
+    return id >= 808 && id <= 845;
 }
 bool isAtomicMemory(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 853 && id <= 870;
+    return id >= 862 && id <= 879;
 }
 bool isImageLoad(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 895 && id <= 906;
+    return id >= 904 && id <= 915;
 }
 bool isImageStore(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 907 && id <= 918;
+    return id >= 916 && id <= 927;
 }
 bool isImage(const TFunction *func)
 {
     int id = func->uniqueId().get();
-    return id >= 871 && id <= 918;
+    return id >= 880 && id <= 927;
 }
 
 }  // namespace BuiltInGroup

src/compiler/translator/ShaderLang.cpp

@@ -17,8 +17,8 @@
 #ifdef ANGLE_ENABLE_HLSL
 #include "compiler/translator/TranslatorHLSL.h"
 #endif  // ANGLE_ENABLE_HLSL
-#include "compiler/translator/VariablePacker.h"
 #include "angle_gl.h"
+#include "compiler/translator/VariablePacker.h"
 
 namespace sh
 {
@@ -202,6 +202,7 @@ void InitBuiltInResources(ShBuiltInResources *resources)
     resources->OVR_multiview                   = 0;
     resources->EXT_YUV_target                  = 0;
     resources->EXT_geometry_shader             = 0;
+    resources->ANGLE_texture_multisample_array = 0;
 
     resources->NV_draw_buffers = 0;
 
@@ -269,7 +270,7 @@ void InitBuiltInResources(ShBuiltInResources *resources)
     resources->MaxCombinedAtomicCounterBuffers = 1;
     resources->MaxAtomicCounterBufferSize      = 32;
 
-    resources->MaxUniformBufferBindings = 32;
+    resources->MaxUniformBufferBindings       = 32;
     resources->MaxShaderStorageBufferBindings = 4;
 
     resources->MaxGeometryUniformComponents     = 1024;

src/compiler/translator/Types.cpp

@@ -52,6 +52,8 @@ const char *getBasicString(TBasicType t)
             return "sampler2DArray";
         case EbtSampler2DMS:
             return "sampler2DMS";
+        case EbtSampler2DMSArray:
+            return "sampler2DMSArray";
         case EbtISampler2D:
             return "isampler2D";
         case EbtISampler3D:
@@ -62,6 +64,8 @@ const char *getBasicString(TBasicType t)
             return "isampler2DArray";
         case EbtISampler2DMS:
             return "isampler2DMS";
+        case EbtISampler2DMSArray:
+            return "isampler2DMSArray";
         case EbtUSampler2D:
             return "usampler2D";
         case EbtUSampler3D:
@@ -72,6 +76,8 @@ const char *getBasicString(TBasicType t)
             return "usampler2DArray";
         case EbtUSampler2DMS:
             return "usampler2DMS";
+        case EbtUSampler2DMSArray:
+            return "usampler2DMSArray";
         case EbtSampler2DShadow:
             return "sampler2DShadow";
         case EbtSamplerCubeShadow:

src/compiler/translator/builtin_function_declarations.txt

@@ -356,7 +356,6 @@ GROUP BEGIN TextureESSL300
     ivec2 textureSize(sampler2DShadow, int);
     ivec2 textureSize(samplerCubeShadow, int);
     ivec3 textureSize(sampler2DArrayShadow, int);
-    ivec2 textureSize(gsampler2DMS);
     gvec4 textureProjLod(gsampler2D, vec3, float);
     gvec4 textureProjLod(gsampler2D, vec4, float);
     gvec4 textureProjLod(gsampler3D, vec4, float);
@@ -377,6 +376,16 @@ GROUP BEGIN TextureESSL300
     float textureProjGrad(sampler2DShadow, vec4, vec2, vec2);
 GROUP END TextureESSL300
 
+GROUP BEGIN TextureSizeMS
+  DEFAULT METADATA {"level": "ESSL3_1_BUILTINS", "op": "CallBuiltInFunction"}
+    ivec2 textureSize(gsampler2DMS);
+GROUP END TextureSizeMS
+
+GROUP BEGIN TextureSizeMSArray
+  DEFAULT METADATA {"level": "ESSL3_1_BUILTINS", "op": "CallBuiltInFunction", "extension": "ANGLE_texture_multisample_array"}
+    ivec3 textureSize(gsampler2DMSArray);
+GROUP END TextureSizeMSArray
+
 GROUP BEGIN TextureOffsetNoBias {"queryFunction": true}
   DEFAULT METADATA {"level": "ESSL3_BUILTINS", "op": "CallBuiltInFunction"}
     gvec4 textureOffset(gsampler2D, vec2, ivec2);
@@ -468,6 +477,11 @@ GROUP BEGIN TexelFetchMS
     gvec4 texelFetch(gsampler2DMS, ivec2, int);
 GROUP END TexelFetchMS
 
+GROUP BEGIN TexelFetchMSArray
+  DEFAULT METADATA {"level": "ESSL3_1_BUILTINS", "op": "CallBuiltInFunction", "extension": "ANGLE_texture_multisample_array"}
+    gvec4 texelFetch(gsampler2DMSArray, ivec3, int);
+GROUP END TexelFetchMSArray
+
 GROUP BEGIN TextureGather {"queryFunction": true}
   DEFAULT METADATA {"level": "ESSL3_1_BUILTINS", "op": "CallBuiltInFunction"}
     gvec4 textureGather(gsampler2D, vec2);

src/compiler/translator/builtin_symbols_hash_autogen.txt

-fe7f387068b72dc71759198547902721
+981c1d80d682250a98834c8c1297e616
\ No newline at end of file

src/compiler/translator/gen_builtin_symbols.py

@@ -298,16 +298,19 @@ basic_types_enumeration = [
     'SamplerExternal2DY2YEXT',
     'Sampler2DRect',
     'Sampler2DMS',
+    'Sampler2DMSArray',
     'ISampler2D',
     'ISampler3D',
     'ISamplerCube',
     'ISampler2DArray',
     'ISampler2DMS',
+    'ISampler2DMSArray',
     'USampler2D',
     'USampler3D',
     'USamplerCube',
     'USampler2DArray',
     'USampler2DMS',
+    'USampler2DMSArray',
     'Sampler2DShadow',
     'SamplerCubeShadow',
     'Sampler2DArrayShadow',

src/compiler/translator/glslang.l

@@ -85,6 +85,7 @@ static int ES2_ident_ES3_reserved_ES3_1_keyword(TParseContext *context, int toke
 static int ES2_and_ES3_reserved_ES3_1_keyword(TParseContext *context, int token);
 static int ES2_and_ES3_ident_ES3_1_keyword(TParseContext *context, int token);
 static int ES3_extension_keyword_else_ident(TParseContext *context, TExtension extension, int token);
+static int ES2_ident_ES3_reserved_ES3_1_extension_keyword(TParseContext *context, TExtension extension, int token);
 static int uint_constant(TParseContext *context);
 static int int_constant(TParseContext *context);
 static int float_constant(yyscan_t yyscanner);
@@ -203,6 +204,9 @@ O           [0-7]
 "samplerCubeShadow"    { return ES2_ident_ES3_keyword(context, SAMPLERCUBESHADOW); }
 "sampler2DArrayShadow" { return ES2_ident_ES3_keyword(context, SAMPLER2DARRAYSHADOW); }
 "__samplerExternal2DY2YEXT"   { return ES3_extension_keyword_else_ident(context, TExtension::EXT_YUV_target, SAMPLEREXTERNAL2DY2YEXT); }
+"sampler2DMSArray"     { return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, SAMPLER2DMSARRAY); }
+"isampler2DMSArray"    { return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, ISAMPLER2DMSARRAY); }
+"usampler2DMSArray"    { return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, USAMPLER2DMSARRAY); }
 
 "struct"       { return STRUCT; }
 
@@ -267,10 +271,7 @@ O           [0-7]
 "usampler2DRect"    |
 "samplerBuffer"     |
 "isamplerBuffer"    |
-"usamplerBuffer"    |
-"sampler2DMSArray"  |
-"isampler2DMSArray" |
-"usampler2DMSArray" { 
+"usamplerBuffer"    {
     if (context->getShaderVersion() < 300) {
         yylval->lex.string = AllocatePoolCharArray(yytext, yyleng);
         return check_type(yyscanner);
@@ -577,6 +578,27 @@ int ES3_extension_keyword_else_ident(TParseContext *context, TExtension extensio
     return check_type(yyscanner);
 }
 
+int ES2_ident_ES3_reserved_ES3_1_extension_keyword(TParseContext *context, TExtension extension, int token)
+{
+    struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();
+    yyscan_t yyscanner = (yyscan_t) context->getScanner();
+
+    // a keyword in GLSL ES 3.10 with enabled extension
+    if (context->getShaderVersion() >= 310 && context->isExtensionEnabled(extension))
+    {
+        return token;
+    }
+    // a reserved word in GLSL ES 3.00+
+    if (context->getShaderVersion() >= 300)
+    {
+        return reserved_word(yyscanner);
+    }
+
+    // Otherwise can be used as an identifier/type name
+    yylval->lex.string = AllocatePoolCharArray(yytext, yyleng);
+    return check_type(yyscanner);
+}
+
 int uint_constant(TParseContext *context)
 {
     struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();

src/compiler/translator/glslang.y

@@ -173,6 +173,7 @@ extern void yyerror(YYLTYPE* yylloc, TParseContext* context, void *scanner, cons
 %token <lex> ISAMPLER2D ISAMPLER3D ISAMPLERCUBE ISAMPLER2DARRAY
 %token <lex> USAMPLER2D USAMPLER3D USAMPLERCUBE USAMPLER2DARRAY
 %token <lex> SAMPLER2DMS ISAMPLER2DMS USAMPLER2DMS
+%token <lex> SAMPLER2DMSARRAY ISAMPLER2DMSARRAY USAMPLER2DMSARRAY
 %token <lex> SAMPLER3D SAMPLER3DRECT SAMPLER2DSHADOW SAMPLERCUBESHADOW SAMPLER2DARRAYSHADOW
 %token <lex> SAMPLEREXTERNAL2DY2YEXT
 %token <lex> IMAGE2D IIMAGE2D UIMAGE2D IMAGE3D IIMAGE3D UIMAGE3D IMAGE2DARRAY IIMAGE2DARRAY UIMAGE2DARRAY
@@ -1084,6 +1085,9 @@ type_specifier_nonarray
     | SAMPLER2DMS {
         $$.initialize(EbtSampler2DMS, @1);
     }
+    | SAMPLER2DMSARRAY {
+        $$.initialize(EbtSampler2DMSArray, @1);
+    }
     | ISAMPLER2D {
         $$.initialize(EbtISampler2D, @1);
     }
@@ -1099,6 +1103,9 @@ type_specifier_nonarray
     | ISAMPLER2DMS {
         $$.initialize(EbtISampler2DMS, @1);
     }
+    | ISAMPLER2DMSARRAY {
+        $$.initialize(EbtISampler2DMSArray, @1);
+    }
     | USAMPLER2D {
         $$.initialize(EbtUSampler2D, @1);
     }
@@ -1114,6 +1121,9 @@ type_specifier_nonarray
     | USAMPLER2DMS {
         $$.initialize(EbtUSampler2DMS, @1);
     }
+    | USAMPLER2DMSARRAY {
+        $$.initialize(EbtUSampler2DMSArray, @1);
+    }
     | SAMPLER2DSHADOW {
         $$.initialize(EbtSampler2DShadow, @1);
     }

src/compiler/translator/glslang_lex.cpp

@@ -110,10 +110,10 @@
 /* First, we deal with  platform-specific or compiler-specific issues. */
 
 /* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
 #include <errno.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* end standard C headers. */
 
@@ -573,58 +573,58 @@ static const flex_int16_t yy_accept[891] =
       169,  170,  184,  184,  184,   26,  166,  184,  184,  184,
 
       184,  184,   52,   53,   54,  184,  184,  184,  184,  184,
-      184,  184,  184,  184,  184,  184,  109,  184,  184,  184,
+      184,  184,  184,  184,  184,  184,  112,  184,  184,  184,
       184,  184,  184,  184,  184,  160,  184,  184,  184,  184,
       184,  184,  184,  184,  184,  184,  184,  146,  184,  184,
       183,   58,   59,   60,  184,  184,   15,  184,  184,  184,
-      114,  184,  184,    9,  184,  184,  112,  184,  184,  184,
-      161,  156,  115,  184,  184,  184,  184,  184,  184,  152,
-      184,  184,  184,  184,  184,   84,   40,   43,   45,   44,
+      117,  184,  184,    9,  184,  184,  115,  184,  184,  184,
+      161,  156,  118,  184,  184,  184,  184,  184,  184,  152,
+      184,  184,  184,  184,  184,   87,   40,   43,   45,   44,
        41,   47,   46,   48,   42,  184,  184,  184,  184,  167,
-      143,  184,  184,  154,  184,  184,  184,   36,  110,   27,
+      143,  184,  184,  154,  184,  184,  184,   36,  113,   27,
 
-      180,   23,  155,   83,  184,  165,   18,  184,  184,  184,
+      180,   23,  155,   86,  184,  165,   18,  184,  184,  184,
       184,  184,  184,  184,  184,  184,  184,  184,  184,  184,
       184,  184,  184,   20,   35,  184,  184,  184,  184,  184,
-      184,  116,   89,   95,  184,  184,  184,  184,  184,   86,
-       88,    3,  184,  184,  184,  184,  184,  184,  184,  184,
+      184,  119,   92,   98,  184,  184,  184,  184,  184,   89,
+       91,    3,  184,  184,  184,  184,  184,  184,  184,  184,
       184,  184,  184,  148,  184,  184,  184,  184,  184,    8,
       184,  184,   10,  184,  184,  184,  184,  184,  184,   21,
-      103,   12,  157,  117,   90,   97,  184,  184,  184,  184,
+      106,   12,  157,  120,   93,  100,  184,  184,  184,  184,
       184,  184,  184,  184,  184,  184,  184,  184,  184,  153,
-      184,  184,  184,  101,  107,  104,  184,  184,  184,  184,
+      184,  184,  184,  104,  110,  107,  184,  184,  184,  184,
 
-      184,  184,  184,  149,  118,   91,   96,  184,  184,  164,
-      184,  105,  184,  184,  184,  184,    6,  184,  184,  184,
-      184,  184,  184,  184,  184,  184,  100,  158,    1,  184,
-      184,  184,  184,  184,  184,  182,  184,  113,    5,  177,
+      184,  184,  184,  149,  121,   94,   99,  184,  184,  164,
+      184,  108,  184,  184,  184,  184,    6,  184,  184,  184,
+      184,  184,  184,  184,  184,  184,  103,  158,    1,  184,
+      184,  184,  184,  184,  184,  182,  184,  116,    5,  177,
        61,   64,  184,  184,  184,  184,  184,  184,  184,  184,
-      184,  184,  184,  184,  184,  102,  184,  184,  184,  184,
-      184,  184,   98,  184,  184,  184,  184,  184,  131,   69,
+      184,  184,  184,  184,  184,  105,  184,  184,  184,  184,
+      184,  184,  101,  184,  184,  184,  184,  184,  134,   69,
        70,  184,  184,  184,  184,  184,  184,  184,  184,  184,
-      184,  184,  184,  184,  184,  111,  184,  184,  184,   99,
-      133,   74,   75,  184,  184,  184,  184,  106,  184,  184,
+      184,  184,  184,  184,  184,  114,  184,  184,  184,  102,
+      136,   74,   75,  184,  184,  184,  184,  109,  184,  184,
 
-      184,  184,  184,  184,  184,  126,  184,  184,  184,  184,
+      184,  184,  184,  184,  184,  129,  184,  184,  184,  184,
       184,  184,  184,  184,  184,  184,  184,   68,  184,  184,
       184,  184,   62,  184,  184,  184,  184,  184,  184,  184,
-      184,  184,  184,  184,  184,  184,  184,  127,  119,  184,
-       92,  184,  184,  184,   73,  184,  184,   71,  184,  184,
+      184,  184,  184,  184,  184,  184,  184,  130,  122,  184,
+       95,  184,  184,  184,   73,  184,  184,   71,  184,  184,
       184,  184,  184,  184,  184,  184,  184,  184,  184,  184,
-      184,  184,  128,  184,  184,   78,  184,  184,   76,  184,
-      184,  120,   93,  184,  122,  184,  123,  184,  184,  184,
-      184,  184,  184,  108,  184,  184,  184,  184,   66,  184,
-       65,  137,  184,  184,  121,   94,  184,  184,  184,  184,
-
-      184,  184,  184,  184,  184,  184,  184,  184,  135,  138,
-      184,  129,  184,   67,  184,  184,  184,  184,  184,  184,
-      184,  184,  136,  139,  184,  184,  184,  184,  132,   72,
+      184,  184,  131,  184,  184,   78,  184,  184,   76,  184,
+      184,  123,   96,  184,  125,  184,  126,  184,  184,  184,
+      184,  184,  184,  111,  184,  184,  184,  184,   66,  184,
+       65,  140,  184,  184,  124,   97,  184,  184,  184,  184,
+
+      184,  184,  184,  184,  184,  184,  184,  184,  138,  141,
+      184,  132,  184,   67,  184,  184,  184,  184,  184,  184,
+      184,  184,  139,  142,  184,  184,  184,  184,  135,   72,
       184,  184,  184,  178,  184,  184,  184,   79,  184,  184,
-      134,   77,  184,  184,  184,  184,  184,  184,  184,  184,
-      184,  140,  184,  184,  184,  184,  184,  184,  184,  184,
-      141,  184,  184,  184,  184,   80,  184,  142,   85,  184,
-      124,  125,   87,  184,  184,  184,   63,  184,  184,  184,
-      179,  184,  130,   81,  184,  184,  184,  184,   82,    0
+      137,   77,  184,  184,  184,  184,  184,  184,  184,  184,
+      184,   83,  184,  184,  184,  184,  184,  184,  184,  184,
+       84,  184,  184,  184,  184,   80,  184,   85,   88,  184,
+      127,  128,   90,  184,  184,  184,   63,  184,  184,  184,
+      179,  184,  133,   81,  184,  184,  184,  184,   82,    0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -1183,11 +1183,11 @@ IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
 WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
 */
 
-#include "compiler/translator/glslang.h"
-#include "compiler/translator/ParseContext.h"
 #include "compiler/preprocessor/Token.h"
-#include "compiler/translator/util.h"
+#include "compiler/translator/ParseContext.h"
+#include "compiler/translator/glslang.h"
 #include "compiler/translator/length_limits.h"
+#include "compiler/translator/util.h"
 
 using namespace sh;
 
@@ -1224,6 +1224,7 @@ static int ES2_ident_ES3_reserved_ES3_1_keyword(TParseContext *context, int toke
 static int ES2_and_ES3_reserved_ES3_1_keyword(TParseContext *context, int token);
 static int ES2_and_ES3_ident_ES3_1_keyword(TParseContext *context, int token);
 static int ES3_extension_keyword_else_ident(TParseContext *context, TExtension extension, int token);
+static int ES2_ident_ES3_reserved_ES3_1_extension_keyword(TParseContext *context, TExtension extension, int token);
 static int uint_constant(TParseContext *context);
 static int int_constant(TParseContext *context);
 static int float_constant(yyscan_t yyscanner);
@@ -2027,104 +2028,113 @@ YY_RULE_SETUP
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-{ return STRUCT; }
+{ return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, SAMPLER2DMSARRAY); }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_keyword_multiview_keyword(context, LAYOUT); }
+{ return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, ISAMPLER2DMSARRAY); }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-{ return ES3_extension_keyword_else_ident(context, TExtension::EXT_YUV_target, YUVCSCSTANDARDEXT); }
+{ return ES2_ident_ES3_reserved_ES3_1_extension_keyword(context, TExtension::ANGLE_texture_multisample_array, USAMPLER2DMSARRAY); }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-{ return yuvcscstandardext_constant(context); }
+{ return STRUCT; }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-{ return yuvcscstandardext_constant(context); }
+{ return ES2_ident_ES3_keyword_multiview_keyword(context, LAYOUT); }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-{ return yuvcscstandardext_constant(context); }
+{ return ES3_extension_keyword_else_ident(context, TExtension::EXT_YUV_target, YUVCSCSTANDARDEXT); }
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2D); }
+{ return yuvcscstandardext_constant(context); }
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2D); }
+{ return yuvcscstandardext_constant(context); }
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2D); }
+{ return yuvcscstandardext_constant(context); }
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2DARRAY); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2D); }
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2DARRAY); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2D); }
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2DARRAY); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2D); }
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE3D); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE2DARRAY); }
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE3D); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE2DARRAY); }
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE3D); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE2DARRAY); }
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGECUBE); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGE3D); }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGECUBE); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGE3D); }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGECUBE); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGE3D); }
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, READONLY); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IIMAGECUBE); }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, WRITEONLY); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, UIMAGECUBE); }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, COHERENT); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, IMAGECUBE); }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, RESTRICT); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, READONLY); }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-{ return ES2_and_ES3_reserved_ES3_1_keyword(context, VOLATILE); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, WRITEONLY); }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, ATOMICUINT); }
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, COHERENT); }
 	YY_BREAK
-/* Reserved keywords for GLSL ES 3.00 that are not reserved for GLSL ES 1.00 */
 case 107:
+YY_RULE_SETUP
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, RESTRICT); }
+	YY_BREAK
 case 108:
+YY_RULE_SETUP
+{ return ES2_and_ES3_reserved_ES3_1_keyword(context, VOLATILE); }
+	YY_BREAK
 case 109:
+YY_RULE_SETUP
+{ return ES2_ident_ES3_reserved_ES3_1_keyword(context, ATOMICUINT); }
+	YY_BREAK
+/* Reserved keywords for GLSL ES 3.00 that are not reserved for GLSL ES 1.00 */
 case 110:
 case 111:
 case 112:
@@ -2159,7 +2169,7 @@ case 140:
 case 141:
 case 142:
 YY_RULE_SETUP
-{ 
+{
     if (context->getShaderVersion() < 300) {
         yylval->lex.string = AllocatePoolCharArray(yytext, yyleng);
         return check_type(yyscanner);
@@ -3933,6 +3943,27 @@ int ES3_extension_keyword_else_ident(TParseContext *context, TExtension extensio
     return check_type(yyscanner);
 }
 
+int ES2_ident_ES3_reserved_ES3_1_extension_keyword(TParseContext *context, TExtension extension, int token)
+{
+    struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();
+    yyscan_t yyscanner = (yyscan_t) context->getScanner();
+
+    // a keyword in GLSL ES 3.10 with enabled extension
+    if (context->getShaderVersion() >= 310 && context->isExtensionEnabled(extension))
+    {
+        return token;
+    }
+    // a reserved word in GLSL ES 3.00+
+    if (context->getShaderVersion() >= 300)
+    {
+        return reserved_word(yyscanner);
+    }
+
+    // Otherwise can be used as an identifier/type name
+    yylval->lex.string = AllocatePoolCharArray(yytext, yyleng);
+    return check_type(yyscanner);
+}
+
 int uint_constant(TParseContext *context)
 {
     struct yyguts_t* yyg = (struct yyguts_t*) context->getScanner();

src/compiler/translator/glslang_tab.h

@@ -31,25 +31,22 @@
    version 2.2 of Bison.  */
 
 #ifndef YY_YY_GLSLANG_TAB_H_INCLUDED
-# define YY_YY_GLSLANG_TAB_H_INCLUDED
+#define YY_YY_GLSLANG_TAB_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
-# define YYDEBUG 0
+#define YYDEBUG 0
 #endif
 #if YYDEBUG
 extern int yydebug;
 #endif
 /* "%code requires" blocks.  */
 
-
 #define YYLTYPE TSourceLoc
 #define YYLTYPE_IS_DECLARED 1
 
-
-
 /* Token type.  */
 #ifndef YYTOKENTYPE
-# define YYTOKENTYPE
+#define YYTOKENTYPE
 enum yytokentype
 {
     INVARIANT                 = 258,
@@ -129,91 +126,93 @@ enum yytokentype
     SAMPLER2DMS               = 332,
     ISAMPLER2DMS              = 333,
     USAMPLER2DMS              = 334,
-    SAMPLER3D                 = 335,
-    SAMPLER3DRECT             = 336,
-    SAMPLER2DSHADOW           = 337,
-    SAMPLERCUBESHADOW         = 338,
-    SAMPLER2DARRAYSHADOW      = 339,
-    SAMPLEREXTERNAL2DY2YEXT   = 340,
-    IMAGE2D                   = 341,
-    IIMAGE2D                  = 342,
-    UIMAGE2D                  = 343,
-    IMAGE3D                   = 344,
-    IIMAGE3D                  = 345,
-    UIMAGE3D                  = 346,
-    IMAGE2DARRAY              = 347,
-    IIMAGE2DARRAY             = 348,
-    UIMAGE2DARRAY             = 349,
-    IMAGECUBE                 = 350,
-    IIMAGECUBE                = 351,
-    UIMAGECUBE                = 352,
-    ATOMICUINT                = 353,
-    LAYOUT                    = 354,
-    YUVCSCSTANDARDEXT         = 355,
-    YUVCSCSTANDARDEXTCONSTANT = 356,
-    IDENTIFIER                = 357,
-    TYPE_NAME                 = 358,
-    FLOATCONSTANT             = 359,
-    INTCONSTANT               = 360,
-    UINTCONSTANT              = 361,
-    BOOLCONSTANT              = 362,
-    FIELD_SELECTION           = 363,
-    LEFT_OP                   = 364,
-    RIGHT_OP                  = 365,
-    INC_OP                    = 366,
-    DEC_OP                    = 367,
-    LE_OP                     = 368,
-    GE_OP                     = 369,
-    EQ_OP                     = 370,
-    NE_OP                     = 371,
-    AND_OP                    = 372,
-    OR_OP                     = 373,
-    XOR_OP                    = 374,
-    MUL_ASSIGN                = 375,
-    DIV_ASSIGN                = 376,
-    ADD_ASSIGN                = 377,
-    MOD_ASSIGN                = 378,
-    LEFT_ASSIGN               = 379,
-    RIGHT_ASSIGN              = 380,
-    AND_ASSIGN                = 381,
-    XOR_ASSIGN                = 382,
-    OR_ASSIGN                 = 383,
-    SUB_ASSIGN                = 384,
-    LEFT_PAREN                = 385,
-    RIGHT_PAREN               = 386,
-    LEFT_BRACKET              = 387,
-    RIGHT_BRACKET             = 388,
-    LEFT_BRACE                = 389,
-    RIGHT_BRACE               = 390,
-    DOT                       = 391,
-    COMMA                     = 392,
-    COLON                     = 393,
-    EQUAL                     = 394,
-    SEMICOLON                 = 395,
-    BANG                      = 396,
-    DASH                      = 397,
-    TILDE                     = 398,
-    PLUS                      = 399,
-    STAR                      = 400,
-    SLASH                     = 401,
-    PERCENT                   = 402,
-    LEFT_ANGLE                = 403,
-    RIGHT_ANGLE               = 404,
-    VERTICAL_BAR              = 405,
-    CARET                     = 406,
-    AMPERSAND                 = 407,
-    QUESTION                  = 408
+    SAMPLER2DMSARRAY          = 335,
+    ISAMPLER2DMSARRAY         = 336,
+    USAMPLER2DMSARRAY         = 337,
+    SAMPLER3D                 = 338,
+    SAMPLER3DRECT             = 339,
+    SAMPLER2DSHADOW           = 340,
+    SAMPLERCUBESHADOW         = 341,
+    SAMPLER2DARRAYSHADOW      = 342,
+    SAMPLEREXTERNAL2DY2YEXT   = 343,
+    IMAGE2D                   = 344,
+    IIMAGE2D                  = 345,
+    UIMAGE2D                  = 346,
+    IMAGE3D                   = 347,
+    IIMAGE3D                  = 348,
+    UIMAGE3D                  = 349,
+    IMAGE2DARRAY              = 350,
+    IIMAGE2DARRAY             = 351,
+    UIMAGE2DARRAY             = 352,
+    IMAGECUBE                 = 353,
+    IIMAGECUBE                = 354,
+    UIMAGECUBE                = 355,
+    ATOMICUINT                = 356,
+    LAYOUT                    = 357,
+    YUVCSCSTANDARDEXT         = 358,
+    YUVCSCSTANDARDEXTCONSTANT = 359,
+    IDENTIFIER                = 360,
+    TYPE_NAME                 = 361,
+    FLOATCONSTANT             = 362,
+    INTCONSTANT               = 363,
+    UINTCONSTANT              = 364,
+    BOOLCONSTANT              = 365,
+    FIELD_SELECTION           = 366,
+    LEFT_OP                   = 367,
+    RIGHT_OP                  = 368,
+    INC_OP                    = 369,
+    DEC_OP                    = 370,
+    LE_OP                     = 371,
+    GE_OP                     = 372,
+    EQ_OP                     = 373,
+    NE_OP                     = 374,
+    AND_OP                    = 375,
+    OR_OP                     = 376,
+    XOR_OP                    = 377,
+    MUL_ASSIGN                = 378,
+    DIV_ASSIGN                = 379,
+    ADD_ASSIGN                = 380,
+    MOD_ASSIGN                = 381,
+    LEFT_ASSIGN               = 382,
+    RIGHT_ASSIGN              = 383,
+    AND_ASSIGN                = 384,
+    XOR_ASSIGN                = 385,
+    OR_ASSIGN                 = 386,
+    SUB_ASSIGN                = 387,
+    LEFT_PAREN                = 388,
+    RIGHT_PAREN               = 389,
+    LEFT_BRACKET              = 390,
+    RIGHT_BRACKET             = 391,
+    LEFT_BRACE                = 392,
+    RIGHT_BRACE               = 393,
+    DOT                       = 394,
+    COMMA                     = 395,
+    COLON                     = 396,
+    EQUAL                     = 397,
+    SEMICOLON                 = 398,
+    BANG                      = 399,
+    DASH                      = 400,
+    TILDE                     = 401,
+    PLUS                      = 402,
+    STAR                      = 403,
+    SLASH                     = 404,
+    PERCENT                   = 405,
+    LEFT_ANGLE                = 406,
+    RIGHT_ANGLE               = 407,
+    VERTICAL_BAR              = 408,
+    CARET                     = 409,
+    AMPERSAND                 = 410,
+    QUESTION                  = 411
 };
 #endif
 
 /* Value type.  */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-
-union YYSTYPE
-{
+#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED
 
+union YYSTYPE {
 
-    struct {
+    struct
+    {
         union {
             const char *string;  // pool allocated.
             float f;
@@ -223,7 +222,8 @@ union YYSTYPE
         };
         const TSymbol *symbol;
     } lex;
-    struct {
+    struct
+    {
         TOperator op;
         union {
             TIntermNode *intermNode;
@@ -253,31 +253,27 @@ union YYSTYPE
             TTypeQualifierBuilder *typeQualifierBuilder;
         };
     } interm;
-
-
 };
 
 typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
+#define YYSTYPE_IS_TRIVIAL 1
+#define YYSTYPE_IS_DECLARED 1
 #endif
 
 /* Location type.  */
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+#if !defined YYLTYPE && !defined YYLTYPE_IS_DECLARED
 typedef struct YYLTYPE YYLTYPE;
 struct YYLTYPE
 {
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
+    int first_line;
+    int first_column;
+    int last_line;
+    int last_column;
 };
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
+#define YYLTYPE_IS_DECLARED 1
+#define YYLTYPE_IS_TRIVIAL 1
 #endif
 
-
-
-int yyparse (TParseContext* context, void *scanner);
+int yyparse(TParseContext *context, void *scanner);
 
 #endif /* !YY_YY_GLSLANG_TAB_H_INCLUDED  */

src/compiler/translator/tree_util/BuiltIn_autogen.h

@@ -604,26 +604,26 @@ class BuiltInId
         TSymbolUniqueId(545);
     static constexpr const TSymbolUniqueId texture_Sampler2D1_Float2       = TSymbolUniqueId(546);
     static constexpr const TSymbolUniqueId texture_ISampler2D1_Float2      = TSymbolUniqueId(547);
-    static constexpr const TSymbolUniqueId pt0P                            = TSymbolUniqueId(548);
+    static constexpr const TSymbolUniqueId pt0Q                            = TSymbolUniqueId(548);
     static constexpr const TSymbolUniqueId texture_USampler2D1_Float2      = TSymbolUniqueId(549);
-    static constexpr const TSymbolUniqueId pt0U                            = TSymbolUniqueId(550);
+    static constexpr const TSymbolUniqueId pt0W                            = TSymbolUniqueId(550);
     static constexpr const TSymbolUniqueId texture_Sampler3D1_Float3       = TSymbolUniqueId(551);
     static constexpr const TSymbolUniqueId pt0I                            = TSymbolUniqueId(552);
     static constexpr const TSymbolUniqueId texture_ISampler3D1_Float3      = TSymbolUniqueId(553);
-    static constexpr const TSymbolUniqueId pt0Q                            = TSymbolUniqueId(554);
+    static constexpr const TSymbolUniqueId pt0R                            = TSymbolUniqueId(554);
     static constexpr const TSymbolUniqueId texture_USampler3D1_Float3      = TSymbolUniqueId(555);
-    static constexpr const TSymbolUniqueId pt0V                            = TSymbolUniqueId(556);
+    static constexpr const TSymbolUniqueId pt0X                            = TSymbolUniqueId(556);
     static constexpr const TSymbolUniqueId texture_SamplerCube1_Float3     = TSymbolUniqueId(557);
     static constexpr const TSymbolUniqueId texture_ISamplerCube1_Float3    = TSymbolUniqueId(558);
-    static constexpr const TSymbolUniqueId pt0R                            = TSymbolUniqueId(559);
+    static constexpr const TSymbolUniqueId pt0S                            = TSymbolUniqueId(559);
     static constexpr const TSymbolUniqueId texture_USamplerCube1_Float3    = TSymbolUniqueId(560);
-    static constexpr const TSymbolUniqueId pt0W                            = TSymbolUniqueId(561);
+    static constexpr const TSymbolUniqueId pt0Y                            = TSymbolUniqueId(561);
     static constexpr const TSymbolUniqueId texture_Sampler2DArray1_Float3  = TSymbolUniqueId(562);
     static constexpr const TSymbolUniqueId pt0K                            = TSymbolUniqueId(563);
     static constexpr const TSymbolUniqueId texture_ISampler2DArray1_Float3 = TSymbolUniqueId(564);
-    static constexpr const TSymbolUniqueId pt0S                            = TSymbolUniqueId(565);
+    static constexpr const TSymbolUniqueId pt0T                            = TSymbolUniqueId(565);
     static constexpr const TSymbolUniqueId texture_USampler2DArray1_Float3 = TSymbolUniqueId(566);
-    static constexpr const TSymbolUniqueId pt0X                            = TSymbolUniqueId(567);
+    static constexpr const TSymbolUniqueId pt0Z                            = TSymbolUniqueId(567);
     static constexpr const TSymbolUniqueId textureProj_Sampler2D1_Float3   = TSymbolUniqueId(568);
     static constexpr const TSymbolUniqueId textureProj_ISampler2D1_Float3  = TSymbolUniqueId(569);
     static constexpr const TSymbolUniqueId textureProj_USampler2D1_Float3  = TSymbolUniqueId(570);
@@ -658,12 +658,12 @@ class BuiltInId
     static constexpr const TSymbolUniqueId textureLod_USampler2DArray1_Float3_Float1 =
         TSymbolUniqueId(588);
     static constexpr const TSymbolUniqueId texture_Sampler2DShadow1_Float3   = TSymbolUniqueId(589);
-    static constexpr const TSymbolUniqueId pt0Z                              = TSymbolUniqueId(590);
+    static constexpr const TSymbolUniqueId pt0c                              = TSymbolUniqueId(590);
     static constexpr const TSymbolUniqueId texture_SamplerCubeShadow1_Float4 = TSymbolUniqueId(591);
-    static constexpr const TSymbolUniqueId pt0a                              = TSymbolUniqueId(592);
+    static constexpr const TSymbolUniqueId pt0d                              = TSymbolUniqueId(592);
     static constexpr const TSymbolUniqueId texture_Sampler2DArrayShadow1_Float4 =
         TSymbolUniqueId(593);
-    static constexpr const TSymbolUniqueId pt0b = TSymbolUniqueId(594);
+    static constexpr const TSymbolUniqueId pt0e = TSymbolUniqueId(594);
     static constexpr const TSymbolUniqueId textureProj_Sampler2DShadow1_Float4 =
         TSymbolUniqueId(595);
     static constexpr const TSymbolUniqueId textureLod_Sampler2DShadow1_Float3_Float1 =
@@ -685,613 +685,625 @@ class BuiltInId
         TSymbolUniqueId(610);
     static constexpr const TSymbolUniqueId textureSize_Sampler2DArrayShadow1_Int1 =
         TSymbolUniqueId(611);
-    static constexpr const TSymbolUniqueId textureSize_Sampler2DMS1  = TSymbolUniqueId(612);
-    static constexpr const TSymbolUniqueId pt0O                      = TSymbolUniqueId(613);
-    static constexpr const TSymbolUniqueId textureSize_ISampler2DMS1 = TSymbolUniqueId(614);
-    static constexpr const TSymbolUniqueId pt0T                      = TSymbolUniqueId(615);
-    static constexpr const TSymbolUniqueId textureSize_USampler2DMS1 = TSymbolUniqueId(616);
-    static constexpr const TSymbolUniqueId pt0Y                      = TSymbolUniqueId(617);
     static constexpr const TSymbolUniqueId textureProjLod_Sampler2D1_Float3_Float1 =
-        TSymbolUniqueId(618);
+        TSymbolUniqueId(612);
     static constexpr const TSymbolUniqueId textureProjLod_ISampler2D1_Float3_Float1 =
-        TSymbolUniqueId(619);
+        TSymbolUniqueId(613);
     static constexpr const TSymbolUniqueId textureProjLod_USampler2D1_Float3_Float1 =
-        TSymbolUniqueId(620);
+        TSymbolUniqueId(614);
     static constexpr const TSymbolUniqueId textureProjLod_Sampler2D1_Float4_Float1 =
-        TSymbolUniqueId(621);
+        TSymbolUniqueId(615);
     static constexpr const TSymbolUniqueId textureProjLod_ISampler2D1_Float4_Float1 =
-        TSymbolUniqueId(622);
+        TSymbolUniqueId(616);
     static constexpr const TSymbolUniqueId textureProjLod_USampler2D1_Float4_Float1 =
-        TSymbolUniqueId(623);
+        TSymbolUniqueId(617);
     static constexpr const TSymbolUniqueId textureProjLod_Sampler3D1_Float4_Float1 =
-        TSymbolUniqueId(624);
+        TSymbolUniqueId(618);
     static constexpr const TSymbolUniqueId textureProjLod_ISampler3D1_Float4_Float1 =
-        TSymbolUniqueId(625);
+        TSymbolUniqueId(619);
     static constexpr const TSymbolUniqueId textureProjLod_USampler3D1_Float4_Float1 =
-        TSymbolUniqueId(626);
+        TSymbolUniqueId(620);
     static constexpr const TSymbolUniqueId textureProjLod_Sampler2DShadow1_Float4_Float1 =
-        TSymbolUniqueId(627);
-    static constexpr const TSymbolUniqueId texelFetch_Sampler2D1_Int2_Int1  = TSymbolUniqueId(628);
-    static constexpr const TSymbolUniqueId texelFetch_ISampler2D1_Int2_Int1 = TSymbolUniqueId(629);
-    static constexpr const TSymbolUniqueId texelFetch_USampler2D1_Int2_Int1 = TSymbolUniqueId(630);
-    static constexpr const TSymbolUniqueId texelFetch_Sampler3D1_Int3_Int1  = TSymbolUniqueId(631);
-    static constexpr const TSymbolUniqueId texelFetch_ISampler3D1_Int3_Int1 = TSymbolUniqueId(632);
-    static constexpr const TSymbolUniqueId texelFetch_USampler3D1_Int3_Int1 = TSymbolUniqueId(633);
+        TSymbolUniqueId(621);
+    static constexpr const TSymbolUniqueId texelFetch_Sampler2D1_Int2_Int1  = TSymbolUniqueId(622);
+    static constexpr const TSymbolUniqueId texelFetch_ISampler2D1_Int2_Int1 = TSymbolUniqueId(623);
+    static constexpr const TSymbolUniqueId texelFetch_USampler2D1_Int2_Int1 = TSymbolUniqueId(624);
+    static constexpr const TSymbolUniqueId texelFetch_Sampler3D1_Int3_Int1  = TSymbolUniqueId(625);
+    static constexpr const TSymbolUniqueId texelFetch_ISampler3D1_Int3_Int1 = TSymbolUniqueId(626);
+    static constexpr const TSymbolUniqueId texelFetch_USampler3D1_Int3_Int1 = TSymbolUniqueId(627);
     static constexpr const TSymbolUniqueId texelFetch_Sampler2DArray1_Int3_Int1 =
-        TSymbolUniqueId(634);
+        TSymbolUniqueId(628);
     static constexpr const TSymbolUniqueId texelFetch_ISampler2DArray1_Int3_Int1 =
-        TSymbolUniqueId(635);
+        TSymbolUniqueId(629);
     static constexpr const TSymbolUniqueId texelFetch_USampler2DArray1_Int3_Int1 =
-        TSymbolUniqueId(636);
+        TSymbolUniqueId(630);
     static constexpr const TSymbolUniqueId textureGrad_Sampler2D1_Float2_Float2_Float2 =
-        TSymbolUniqueId(637);
+        TSymbolUniqueId(631);
     static constexpr const TSymbolUniqueId textureGrad_ISampler2D1_Float2_Float2_Float2 =
-        TSymbolUniqueId(638);
+        TSymbolUniqueId(632);
     static constexpr const TSymbolUniqueId textureGrad_USampler2D1_Float2_Float2_Float2 =
-        TSymbolUniqueId(639);
+        TSymbolUniqueId(633);
     static constexpr const TSymbolUniqueId textureGrad_Sampler3D1_Float3_Float3_Float3 =
-        TSymbolUniqueId(640);
+        TSymbolUniqueId(634);
     static constexpr const TSymbolUniqueId textureGrad_ISampler3D1_Float3_Float3_Float3 =
-        TSymbolUniqueId(641);
+        TSymbolUniqueId(635);
     static constexpr const TSymbolUniqueId textureGrad_USampler3D1_Float3_Float3_Float3 =
-        TSymbolUniqueId(642);
+        TSymbolUniqueId(636);
     static constexpr const TSymbolUniqueId textureGrad_SamplerCube1_Float3_Float3_Float3 =
-        TSymbolUniqueId(643);
+        TSymbolUniqueId(637);
     static constexpr const TSymbolUniqueId textureGrad_ISamplerCube1_Float3_Float3_Float3 =
-        TSymbolUniqueId(644);
+        TSymbolUniqueId(638);
     static constexpr const TSymbolUniqueId textureGrad_USamplerCube1_Float3_Float3_Float3 =
-        TSymbolUniqueId(645);
+        TSymbolUniqueId(639);
     static constexpr const TSymbolUniqueId textureGrad_Sampler2DShadow1_Float3_Float2_Float2 =
-        TSymbolUniqueId(646);
+        TSymbolUniqueId(640);
     static constexpr const TSymbolUniqueId textureGrad_SamplerCubeShadow1_Float4_Float3_Float3 =
-        TSymbolUniqueId(647);
+        TSymbolUniqueId(641);
     static constexpr const TSymbolUniqueId textureGrad_Sampler2DArray1_Float3_Float2_Float2 =
-        TSymbolUniqueId(648);
+        TSymbolUniqueId(642);
     static constexpr const TSymbolUniqueId textureGrad_ISampler2DArray1_Float3_Float2_Float2 =
-        TSymbolUniqueId(649);
+        TSymbolUniqueId(643);
     static constexpr const TSymbolUniqueId textureGrad_USampler2DArray1_Float3_Float2_Float2 =
-        TSymbolUniqueId(650);
+        TSymbolUniqueId(644);
     static constexpr const TSymbolUniqueId textureGrad_Sampler2DArrayShadow1_Float4_Float2_Float2 =
-        TSymbolUniqueId(651);
+        TSymbolUniqueId(645);
     static constexpr const TSymbolUniqueId textureProjGrad_Sampler2D1_Float3_Float2_Float2 =
-        TSymbolUniqueId(652);
+        TSymbolUniqueId(646);
     static constexpr const TSymbolUniqueId textureProjGrad_ISampler2D1_Float3_Float2_Float2 =
-        TSymbolUniqueId(653);
+        TSymbolUniqueId(647);
     static constexpr const TSymbolUniqueId textureProjGrad_USampler2D1_Float3_Float2_Float2 =
-        TSymbolUniqueId(654);
+        TSymbolUniqueId(648);
     static constexpr const TSymbolUniqueId textureProjGrad_Sampler2D1_Float4_Float2_Float2 =
-        TSymbolUniqueId(655);
+        TSymbolUniqueId(649);
     static constexpr const TSymbolUniqueId textureProjGrad_ISampler2D1_Float4_Float2_Float2 =
-        TSymbolUniqueId(656);
+        TSymbolUniqueId(650);
     static constexpr const TSymbolUniqueId textureProjGrad_USampler2D1_Float4_Float2_Float2 =
-        TSymbolUniqueId(657);
+        TSymbolUniqueId(651);
     static constexpr const TSymbolUniqueId textureProjGrad_Sampler3D1_Float4_Float3_Float3 =
-        TSymbolUniqueId(658);
+        TSymbolUniqueId(652);
     static constexpr const TSymbolUniqueId textureProjGrad_ISampler3D1_Float4_Float3_Float3 =
-        TSymbolUniqueId(659);
+        TSymbolUniqueId(653);
     static constexpr const TSymbolUniqueId textureProjGrad_USampler3D1_Float4_Float3_Float3 =
-        TSymbolUniqueId(660);
+        TSymbolUniqueId(654);
     static constexpr const TSymbolUniqueId textureProjGrad_Sampler2DShadow1_Float4_Float2_Float2 =
-        TSymbolUniqueId(661);
+        TSymbolUniqueId(655);
+    static constexpr const TSymbolUniqueId textureSize_Sampler2DMS1       = TSymbolUniqueId(656);
+    static constexpr const TSymbolUniqueId pt0O                           = TSymbolUniqueId(657);
+    static constexpr const TSymbolUniqueId textureSize_ISampler2DMS1      = TSymbolUniqueId(658);
+    static constexpr const TSymbolUniqueId pt0U                           = TSymbolUniqueId(659);
+    static constexpr const TSymbolUniqueId textureSize_USampler2DMS1      = TSymbolUniqueId(660);
+    static constexpr const TSymbolUniqueId pt0a                           = TSymbolUniqueId(661);
+    static constexpr const TSymbolUniqueId textureSize_Sampler2DMSArray1  = TSymbolUniqueId(662);
+    static constexpr const TSymbolUniqueId pt0P                           = TSymbolUniqueId(663);
+    static constexpr const TSymbolUniqueId textureSize_ISampler2DMSArray1 = TSymbolUniqueId(664);
+    static constexpr const TSymbolUniqueId pt0V                           = TSymbolUniqueId(665);
+    static constexpr const TSymbolUniqueId textureSize_USampler2DMSArray1 = TSymbolUniqueId(666);
+    static constexpr const TSymbolUniqueId pt0b                           = TSymbolUniqueId(667);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2D1_Float2_Int2 =
-        TSymbolUniqueId(662);
+        TSymbolUniqueId(668);
     static constexpr const TSymbolUniqueId textureOffset_ISampler2D1_Float2_Int2 =
-        TSymbolUniqueId(663);
+        TSymbolUniqueId(669);
     static constexpr const TSymbolUniqueId textureOffset_USampler2D1_Float2_Int2 =
-        TSymbolUniqueId(664);
+        TSymbolUniqueId(670);
     static constexpr const TSymbolUniqueId textureOffset_Sampler3D1_Float3_Int3 =
-        TSymbolUniqueId(665);
+        TSymbolUniqueId(671);
     static constexpr const TSymbolUniqueId textureOffset_ISampler3D1_Float3_Int3 =
-        TSymbolUniqueId(666);
+        TSymbolUniqueId(672);
     static constexpr const TSymbolUniqueId textureOffset_USampler3D1_Float3_Int3 =
-        TSymbolUniqueId(667);
+        TSymbolUniqueId(673);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2DShadow1_Float3_Int2 =
-        TSymbolUniqueId(668);
+        TSymbolUniqueId(674);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(669);
+        TSymbolUniqueId(675);
     static constexpr const TSymbolUniqueId textureOffset_ISampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(670);
+        TSymbolUniqueId(676);
     static constexpr const TSymbolUniqueId textureOffset_USampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(671);
+        TSymbolUniqueId(677);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2D1_Float3_Int2 =
-        TSymbolUniqueId(672);
+        TSymbolUniqueId(678);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler2D1_Float3_Int2 =
-        TSymbolUniqueId(673);
+        TSymbolUniqueId(679);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler2D1_Float3_Int2 =
-        TSymbolUniqueId(674);
+        TSymbolUniqueId(680);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2D1_Float4_Int2 =
-        TSymbolUniqueId(675);
+        TSymbolUniqueId(681);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler2D1_Float4_Int2 =
-        TSymbolUniqueId(676);
+        TSymbolUniqueId(682);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler2D1_Float4_Int2 =
-        TSymbolUniqueId(677);
+        TSymbolUniqueId(683);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler3D1_Float4_Int3 =
-        TSymbolUniqueId(678);
+        TSymbolUniqueId(684);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler3D1_Float4_Int3 =
-        TSymbolUniqueId(679);
+        TSymbolUniqueId(685);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler3D1_Float4_Int3 =
-        TSymbolUniqueId(680);
+        TSymbolUniqueId(686);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2DShadow1_Float4_Int2 =
-        TSymbolUniqueId(681);
+        TSymbolUniqueId(687);
     static constexpr const TSymbolUniqueId textureLodOffset_Sampler2D1_Float2_Float1_Int2 =
-        TSymbolUniqueId(682);
+        TSymbolUniqueId(688);
     static constexpr const TSymbolUniqueId textureLodOffset_ISampler2D1_Float2_Float1_Int2 =
-        TSymbolUniqueId(683);
+        TSymbolUniqueId(689);
     static constexpr const TSymbolUniqueId textureLodOffset_USampler2D1_Float2_Float1_Int2 =
-        TSymbolUniqueId(684);
+        TSymbolUniqueId(690);
     static constexpr const TSymbolUniqueId textureLodOffset_Sampler3D1_Float3_Float1_Int3 =
-        TSymbolUniqueId(685);
+        TSymbolUniqueId(691);
     static constexpr const TSymbolUniqueId textureLodOffset_ISampler3D1_Float3_Float1_Int3 =
-        TSymbolUniqueId(686);
+        TSymbolUniqueId(692);
     static constexpr const TSymbolUniqueId textureLodOffset_USampler3D1_Float3_Float1_Int3 =
-        TSymbolUniqueId(687);
+        TSymbolUniqueId(693);
     static constexpr const TSymbolUniqueId textureLodOffset_Sampler2DShadow1_Float3_Float1_Int2 =
-        TSymbolUniqueId(688);
+        TSymbolUniqueId(694);
     static constexpr const TSymbolUniqueId textureLodOffset_Sampler2DArray1_Float3_Float1_Int2 =
-        TSymbolUniqueId(689);
+        TSymbolUniqueId(695);
     static constexpr const TSymbolUniqueId textureLodOffset_ISampler2DArray1_Float3_Float1_Int2 =
-        TSymbolUniqueId(690);
+        TSymbolUniqueId(696);
     static constexpr const TSymbolUniqueId textureLodOffset_USampler2DArray1_Float3_Float1_Int2 =
-        TSymbolUniqueId(691);
+        TSymbolUniqueId(697);
     static constexpr const TSymbolUniqueId textureProjLodOffset_Sampler2D1_Float3_Float1_Int2 =
-        TSymbolUniqueId(692);
+        TSymbolUniqueId(698);
     static constexpr const TSymbolUniqueId textureProjLodOffset_ISampler2D1_Float3_Float1_Int2 =
-        TSymbolUniqueId(693);
+        TSymbolUniqueId(699);
     static constexpr const TSymbolUniqueId textureProjLodOffset_USampler2D1_Float3_Float1_Int2 =
-        TSymbolUniqueId(694);
+        TSymbolUniqueId(700);
     static constexpr const TSymbolUniqueId textureProjLodOffset_Sampler2D1_Float4_Float1_Int2 =
-        TSymbolUniqueId(695);
+        TSymbolUniqueId(701);
     static constexpr const TSymbolUniqueId textureProjLodOffset_ISampler2D1_Float4_Float1_Int2 =
-        TSymbolUniqueId(696);
+        TSymbolUniqueId(702);
     static constexpr const TSymbolUniqueId textureProjLodOffset_USampler2D1_Float4_Float1_Int2 =
-        TSymbolUniqueId(697);
+        TSymbolUniqueId(703);
     static constexpr const TSymbolUniqueId textureProjLodOffset_Sampler3D1_Float4_Float1_Int3 =
-        TSymbolUniqueId(698);
+        TSymbolUniqueId(704);
     static constexpr const TSymbolUniqueId textureProjLodOffset_ISampler3D1_Float4_Float1_Int3 =
-        TSymbolUniqueId(699);
+        TSymbolUniqueId(705);
     static constexpr const TSymbolUniqueId textureProjLodOffset_USampler3D1_Float4_Float1_Int3 =
-        TSymbolUniqueId(700);
+        TSymbolUniqueId(706);
     static constexpr const TSymbolUniqueId
-        textureProjLodOffset_Sampler2DShadow1_Float4_Float1_Int2 = TSymbolUniqueId(701);
+        textureProjLodOffset_Sampler2DShadow1_Float4_Float1_Int2 = TSymbolUniqueId(707);
     static constexpr const TSymbolUniqueId texelFetchOffset_Sampler2D1_Int2_Int1_Int2 =
-        TSymbolUniqueId(702);
+        TSymbolUniqueId(708);
     static constexpr const TSymbolUniqueId texelFetchOffset_ISampler2D1_Int2_Int1_Int2 =
-        TSymbolUniqueId(703);
+        TSymbolUniqueId(709);
     static constexpr const TSymbolUniqueId texelFetchOffset_USampler2D1_Int2_Int1_Int2 =
-        TSymbolUniqueId(704);
+        TSymbolUniqueId(710);
     static constexpr const TSymbolUniqueId texelFetchOffset_Sampler3D1_Int3_Int1_Int3 =
-        TSymbolUniqueId(705);
+        TSymbolUniqueId(711);
     static constexpr const TSymbolUniqueId texelFetchOffset_ISampler3D1_Int3_Int1_Int3 =
-        TSymbolUniqueId(706);
+        TSymbolUniqueId(712);
     static constexpr const TSymbolUniqueId texelFetchOffset_USampler3D1_Int3_Int1_Int3 =
-        TSymbolUniqueId(707);
+        TSymbolUniqueId(713);
     static constexpr const TSymbolUniqueId texelFetchOffset_Sampler2DArray1_Int3_Int1_Int2 =
-        TSymbolUniqueId(708);
+        TSymbolUniqueId(714);
     static constexpr const TSymbolUniqueId texelFetchOffset_ISampler2DArray1_Int3_Int1_Int2 =
-        TSymbolUniqueId(709);
+        TSymbolUniqueId(715);
     static constexpr const TSymbolUniqueId texelFetchOffset_USampler2DArray1_Int3_Int1_Int2 =
-        TSymbolUniqueId(710);
+        TSymbolUniqueId(716);
     static constexpr const TSymbolUniqueId textureGradOffset_Sampler2D1_Float2_Float2_Float2_Int2 =
-        TSymbolUniqueId(711);
+        TSymbolUniqueId(717);
     static constexpr const TSymbolUniqueId textureGradOffset_ISampler2D1_Float2_Float2_Float2_Int2 =
-        TSymbolUniqueId(712);
+        TSymbolUniqueId(718);
     static constexpr const TSymbolUniqueId textureGradOffset_USampler2D1_Float2_Float2_Float2_Int2 =
-        TSymbolUniqueId(713);
+        TSymbolUniqueId(719);
     static constexpr const TSymbolUniqueId textureGradOffset_Sampler3D1_Float3_Float3_Float3_Int3 =
-        TSymbolUniqueId(714);
+        TSymbolUniqueId(720);
     static constexpr const TSymbolUniqueId textureGradOffset_ISampler3D1_Float3_Float3_Float3_Int3 =
-        TSymbolUniqueId(715);
+        TSymbolUniqueId(721);
     static constexpr const TSymbolUniqueId textureGradOffset_USampler3D1_Float3_Float3_Float3_Int3 =
-        TSymbolUniqueId(716);
+        TSymbolUniqueId(722);
     static constexpr const TSymbolUniqueId
-        textureGradOffset_Sampler2DShadow1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(717);
+        textureGradOffset_Sampler2DShadow1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(723);
     static constexpr const TSymbolUniqueId
-        textureGradOffset_Sampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(718);
+        textureGradOffset_Sampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(724);
     static constexpr const TSymbolUniqueId
-        textureGradOffset_ISampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(719);
+        textureGradOffset_ISampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(725);
     static constexpr const TSymbolUniqueId
-        textureGradOffset_USampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(720);
+        textureGradOffset_USampler2DArray1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(726);
     static constexpr const TSymbolUniqueId
-        textureGradOffset_Sampler2DArrayShadow1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(721);
+        textureGradOffset_Sampler2DArrayShadow1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(727);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_Sampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(722);
+        textureProjGradOffset_Sampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(728);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_ISampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(723);
+        textureProjGradOffset_ISampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(729);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_USampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(724);
+        textureProjGradOffset_USampler2D1_Float3_Float2_Float2_Int2 = TSymbolUniqueId(730);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_Sampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(725);
+        textureProjGradOffset_Sampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(731);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_ISampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(726);
+        textureProjGradOffset_ISampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(732);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_USampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(727);
+        textureProjGradOffset_USampler2D1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(733);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_Sampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(728);
+        textureProjGradOffset_Sampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(734);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_ISampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(729);
+        textureProjGradOffset_ISampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(735);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_USampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(730);
+        textureProjGradOffset_USampler3D1_Float4_Float3_Float3_Int3 = TSymbolUniqueId(736);
     static constexpr const TSymbolUniqueId
-        textureProjGradOffset_Sampler2DShadow1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(731);
+        textureProjGradOffset_Sampler2DShadow1_Float4_Float2_Float2_Int2 = TSymbolUniqueId(737);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2D1_Float2_Int2_Float1 =
-        TSymbolUniqueId(732);
+        TSymbolUniqueId(738);
     static constexpr const TSymbolUniqueId textureOffset_ISampler2D1_Float2_Int2_Float1 =
-        TSymbolUniqueId(733);
+        TSymbolUniqueId(739);
     static constexpr const TSymbolUniqueId textureOffset_USampler2D1_Float2_Int2_Float1 =
-        TSymbolUniqueId(734);
+        TSymbolUniqueId(740);
     static constexpr const TSymbolUniqueId textureOffset_Sampler3D1_Float3_Int3_Float1 =
-        TSymbolUniqueId(735);
+        TSymbolUniqueId(741);
     static constexpr const TSymbolUniqueId textureOffset_ISampler3D1_Float3_Int3_Float1 =
-        TSymbolUniqueId(736);
+        TSymbolUniqueId(742);
     static constexpr const TSymbolUniqueId textureOffset_USampler3D1_Float3_Int3_Float1 =
-        TSymbolUniqueId(737);
+        TSymbolUniqueId(743);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2DShadow1_Float3_Int2_Float1 =
-        TSymbolUniqueId(738);
+        TSymbolUniqueId(744);
     static constexpr const TSymbolUniqueId textureOffset_Sampler2DArray1_Float3_Int2_Float1 =
-        TSymbolUniqueId(739);
+        TSymbolUniqueId(745);
     static constexpr const TSymbolUniqueId textureOffset_ISampler2DArray1_Float3_Int2_Float1 =
-        TSymbolUniqueId(740);
+        TSymbolUniqueId(746);
     static constexpr const TSymbolUniqueId textureOffset_USampler2DArray1_Float3_Int2_Float1 =
-        TSymbolUniqueId(741);
+        TSymbolUniqueId(747);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2D1_Float3_Int2_Float1 =
-        TSymbolUniqueId(742);
+        TSymbolUniqueId(748);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler2D1_Float3_Int2_Float1 =
-        TSymbolUniqueId(743);
+        TSymbolUniqueId(749);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler2D1_Float3_Int2_Float1 =
-        TSymbolUniqueId(744);
+        TSymbolUniqueId(750);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2D1_Float4_Int2_Float1 =
-        TSymbolUniqueId(745);
+        TSymbolUniqueId(751);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler2D1_Float4_Int2_Float1 =
-        TSymbolUniqueId(746);
+        TSymbolUniqueId(752);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler2D1_Float4_Int2_Float1 =
-        TSymbolUniqueId(747);
+        TSymbolUniqueId(753);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler3D1_Float4_Int3_Float1 =
-        TSymbolUniqueId(748);
+        TSymbolUniqueId(754);
     static constexpr const TSymbolUniqueId textureProjOffset_ISampler3D1_Float4_Int3_Float1 =
-        TSymbolUniqueId(749);
+        TSymbolUniqueId(755);
     static constexpr const TSymbolUniqueId textureProjOffset_USampler3D1_Float4_Int3_Float1 =
-        TSymbolUniqueId(750);
+        TSymbolUniqueId(756);
     static constexpr const TSymbolUniqueId textureProjOffset_Sampler2DShadow1_Float4_Int2_Float1 =
-        TSymbolUniqueId(751);
+        TSymbolUniqueId(757);
     static constexpr const TSymbolUniqueId texture_SamplerExternalOES1_Float2 =
-        TSymbolUniqueId(752);
+        TSymbolUniqueId(758);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternalOES1_Float3 =
-        TSymbolUniqueId(753);
+        TSymbolUniqueId(759);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternalOES1_Float4 =
-        TSymbolUniqueId(754);
+        TSymbolUniqueId(760);
     static constexpr const TSymbolUniqueId textureSize_SamplerExternalOES1_Int1 =
-        TSymbolUniqueId(755);
+        TSymbolUniqueId(761);
     static constexpr const TSymbolUniqueId texelFetch_SamplerExternalOES1_Int2_Int1 =
-        TSymbolUniqueId(756);
+        TSymbolUniqueId(762);
     static constexpr const TSymbolUniqueId texture_SamplerExternal2DY2YEXT1_Float2 =
-        TSymbolUniqueId(757);
-    static constexpr const TSymbolUniqueId pt0M = TSymbolUniqueId(758);
+        TSymbolUniqueId(763);
+    static constexpr const TSymbolUniqueId pt0M = TSymbolUniqueId(764);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternal2DY2YEXT1_Float3 =
-        TSymbolUniqueId(759);
+        TSymbolUniqueId(765);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternal2DY2YEXT1_Float4 =
-        TSymbolUniqueId(760);
+        TSymbolUniqueId(766);
     static constexpr const TSymbolUniqueId rgb_2_yuv_Float3_YuvCscStandardEXT1 =
-        TSymbolUniqueId(761);
-    static constexpr const TSymbolUniqueId pt0G = TSymbolUniqueId(762);
+        TSymbolUniqueId(767);
+    static constexpr const TSymbolUniqueId pt0G = TSymbolUniqueId(768);
     static constexpr const TSymbolUniqueId yuv_2_rgb_Float3_YuvCscStandardEXT1 =
-        TSymbolUniqueId(763);
+        TSymbolUniqueId(769);
     static constexpr const TSymbolUniqueId textureSize_SamplerExternal2DY2YEXT1_Int1 =
-        TSymbolUniqueId(764);
+        TSymbolUniqueId(770);
     static constexpr const TSymbolUniqueId texelFetch_SamplerExternal2DY2YEXT1_Int2_Int1 =
-        TSymbolUniqueId(765);
-    static constexpr const TSymbolUniqueId texture_Sampler2D1_Float2_Float1  = TSymbolUniqueId(766);
-    static constexpr const TSymbolUniqueId texture_ISampler2D1_Float2_Float1 = TSymbolUniqueId(767);
-    static constexpr const TSymbolUniqueId texture_USampler2D1_Float2_Float1 = TSymbolUniqueId(768);
-    static constexpr const TSymbolUniqueId texture_Sampler3D1_Float3_Float1  = TSymbolUniqueId(769);
-    static constexpr const TSymbolUniqueId texture_ISampler3D1_Float3_Float1 = TSymbolUniqueId(770);
-    static constexpr const TSymbolUniqueId texture_USampler3D1_Float3_Float1 = TSymbolUniqueId(771);
+        TSymbolUniqueId(771);
+    static constexpr const TSymbolUniqueId texture_Sampler2D1_Float2_Float1  = TSymbolUniqueId(772);
+    static constexpr const TSymbolUniqueId texture_ISampler2D1_Float2_Float1 = TSymbolUniqueId(773);
+    static constexpr const TSymbolUniqueId texture_USampler2D1_Float2_Float1 = TSymbolUniqueId(774);
+    static constexpr const TSymbolUniqueId texture_Sampler3D1_Float3_Float1  = TSymbolUniqueId(775);
+    static constexpr const TSymbolUniqueId texture_ISampler3D1_Float3_Float1 = TSymbolUniqueId(776);
+    static constexpr const TSymbolUniqueId texture_USampler3D1_Float3_Float1 = TSymbolUniqueId(777);
     static constexpr const TSymbolUniqueId texture_SamplerCube1_Float3_Float1 =
-        TSymbolUniqueId(772);
+        TSymbolUniqueId(778);
     static constexpr const TSymbolUniqueId texture_ISamplerCube1_Float3_Float1 =
-        TSymbolUniqueId(773);
+        TSymbolUniqueId(779);
     static constexpr const TSymbolUniqueId texture_USamplerCube1_Float3_Float1 =
-        TSymbolUniqueId(774);
+        TSymbolUniqueId(780);
     static constexpr const TSymbolUniqueId texture_Sampler2DArray1_Float3_Float1 =
-        TSymbolUniqueId(775);
+        TSymbolUniqueId(781);
     static constexpr const TSymbolUniqueId texture_ISampler2DArray1_Float3_Float1 =
-        TSymbolUniqueId(776);
+        TSymbolUniqueId(782);
     static constexpr const TSymbolUniqueId texture_USampler2DArray1_Float3_Float1 =
-        TSymbolUniqueId(777);
+        TSymbolUniqueId(783);
     static constexpr const TSymbolUniqueId textureProj_Sampler2D1_Float3_Float1 =
-        TSymbolUniqueId(778);
+        TSymbolUniqueId(784);
     static constexpr const TSymbolUniqueId textureProj_ISampler2D1_Float3_Float1 =
-        TSymbolUniqueId(779);
+        TSymbolUniqueId(785);
     static constexpr const TSymbolUniqueId textureProj_USampler2D1_Float3_Float1 =
-        TSymbolUniqueId(780);
+        TSymbolUniqueId(786);
     static constexpr const TSymbolUniqueId textureProj_Sampler2D1_Float4_Float1 =
-        TSymbolUniqueId(781);
+        TSymbolUniqueId(787);
     static constexpr const TSymbolUniqueId textureProj_ISampler2D1_Float4_Float1 =
-        TSymbolUniqueId(782);
+        TSymbolUniqueId(788);
     static constexpr const TSymbolUniqueId textureProj_USampler2D1_Float4_Float1 =
-        TSymbolUniqueId(783);
+        TSymbolUniqueId(789);
     static constexpr const TSymbolUniqueId textureProj_Sampler3D1_Float4_Float1 =
-        TSymbolUniqueId(784);
+        TSymbolUniqueId(790);
     static constexpr const TSymbolUniqueId textureProj_ISampler3D1_Float4_Float1 =
-        TSymbolUniqueId(785);
+        TSymbolUniqueId(791);
     static constexpr const TSymbolUniqueId textureProj_USampler3D1_Float4_Float1 =
-        TSymbolUniqueId(786);
+        TSymbolUniqueId(792);
     static constexpr const TSymbolUniqueId texture_Sampler2DShadow1_Float3_Float1 =
-        TSymbolUniqueId(787);
+        TSymbolUniqueId(793);
     static constexpr const TSymbolUniqueId texture_SamplerCubeShadow1_Float4_Float1 =
-        TSymbolUniqueId(788);
+        TSymbolUniqueId(794);
     static constexpr const TSymbolUniqueId textureProj_Sampler2DShadow1_Float4_Float1 =
-        TSymbolUniqueId(789);
+        TSymbolUniqueId(795);
     static constexpr const TSymbolUniqueId texture_SamplerExternalOES1_Float2_Float1 =
-        TSymbolUniqueId(790);
+        TSymbolUniqueId(796);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternalOES1_Float3_Float1 =
-        TSymbolUniqueId(791);
+        TSymbolUniqueId(797);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternalOES1_Float4_Float1 =
-        TSymbolUniqueId(792);
+        TSymbolUniqueId(798);
     static constexpr const TSymbolUniqueId texture_SamplerExternal2DY2YEXT1_Float2_Float1 =
-        TSymbolUniqueId(793);
+        TSymbolUniqueId(799);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternal2DY2YEXT1_Float3_Float1 =
-        TSymbolUniqueId(794);
+        TSymbolUniqueId(800);
     static constexpr const TSymbolUniqueId textureProj_SamplerExternal2DY2YEXT1_Float4_Float1 =
-        TSymbolUniqueId(795);
-    static constexpr const TSymbolUniqueId texelFetch_Sampler2DMS1_Int2_Int1 = TSymbolUniqueId(796);
+        TSymbolUniqueId(801);
+    static constexpr const TSymbolUniqueId texelFetch_Sampler2DMS1_Int2_Int1 = TSymbolUniqueId(802);
     static constexpr const TSymbolUniqueId texelFetch_ISampler2DMS1_Int2_Int1 =
-        TSymbolUniqueId(797);
+        TSymbolUniqueId(803);
     static constexpr const TSymbolUniqueId texelFetch_USampler2DMS1_Int2_Int1 =
-        TSymbolUniqueId(798);
-    static constexpr const TSymbolUniqueId textureGather_Sampler2D1_Float2  = TSymbolUniqueId(799);
-    static constexpr const TSymbolUniqueId textureGather_ISampler2D1_Float2 = TSymbolUniqueId(800);
-    static constexpr const TSymbolUniqueId textureGather_USampler2D1_Float2 = TSymbolUniqueId(801);
+        TSymbolUniqueId(804);
+    static constexpr const TSymbolUniqueId texelFetch_Sampler2DMSArray1_Int3_Int1 =
+        TSymbolUniqueId(805);
+    static constexpr const TSymbolUniqueId texelFetch_ISampler2DMSArray1_Int3_Int1 =
+        TSymbolUniqueId(806);
+    static constexpr const TSymbolUniqueId texelFetch_USampler2DMSArray1_Int3_Int1 =
+        TSymbolUniqueId(807);
+    static constexpr const TSymbolUniqueId textureGather_Sampler2D1_Float2  = TSymbolUniqueId(808);
+    static constexpr const TSymbolUniqueId textureGather_ISampler2D1_Float2 = TSymbolUniqueId(809);
+    static constexpr const TSymbolUniqueId textureGather_USampler2D1_Float2 = TSymbolUniqueId(810);
     static constexpr const TSymbolUniqueId textureGather_Sampler2D1_Float2_Int1 =
-        TSymbolUniqueId(802);
+        TSymbolUniqueId(811);
     static constexpr const TSymbolUniqueId textureGather_ISampler2D1_Float2_Int1 =
-        TSymbolUniqueId(803);
+        TSymbolUniqueId(812);
     static constexpr const TSymbolUniqueId textureGather_USampler2D1_Float2_Int1 =
-        TSymbolUniqueId(804);
+        TSymbolUniqueId(813);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DArray1_Float3 =
-        TSymbolUniqueId(805);
+        TSymbolUniqueId(814);
     static constexpr const TSymbolUniqueId textureGather_ISampler2DArray1_Float3 =
-        TSymbolUniqueId(806);
+        TSymbolUniqueId(815);
     static constexpr const TSymbolUniqueId textureGather_USampler2DArray1_Float3 =
-        TSymbolUniqueId(807);
+        TSymbolUniqueId(816);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DArray1_Float3_Int1 =
-        TSymbolUniqueId(808);
+        TSymbolUniqueId(817);
     static constexpr const TSymbolUniqueId textureGather_ISampler2DArray1_Float3_Int1 =
-        TSymbolUniqueId(809);
+        TSymbolUniqueId(818);
     static constexpr const TSymbolUniqueId textureGather_USampler2DArray1_Float3_Int1 =
-        TSymbolUniqueId(810);
-    static constexpr const TSymbolUniqueId textureGather_SamplerCube1_Float3 = TSymbolUniqueId(811);
+        TSymbolUniqueId(819);
+    static constexpr const TSymbolUniqueId textureGather_SamplerCube1_Float3 = TSymbolUniqueId(820);
     static constexpr const TSymbolUniqueId textureGather_ISamplerCube1_Float3 =
-        TSymbolUniqueId(812);
+        TSymbolUniqueId(821);
     static constexpr const TSymbolUniqueId textureGather_USamplerCube1_Float3 =
-        TSymbolUniqueId(813);
+        TSymbolUniqueId(822);
     static constexpr const TSymbolUniqueId textureGather_SamplerCube1_Float3_Int1 =
-        TSymbolUniqueId(814);
+        TSymbolUniqueId(823);
     static constexpr const TSymbolUniqueId textureGather_ISamplerCube1_Float3_Int1 =
-        TSymbolUniqueId(815);
+        TSymbolUniqueId(824);
     static constexpr const TSymbolUniqueId textureGather_USamplerCube1_Float3_Int1 =
-        TSymbolUniqueId(816);
+        TSymbolUniqueId(825);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DShadow1_Float2 =
-        TSymbolUniqueId(817);
+        TSymbolUniqueId(826);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DShadow1_Float2_Float1 =
-        TSymbolUniqueId(818);
+        TSymbolUniqueId(827);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DArrayShadow1_Float3 =
-        TSymbolUniqueId(819);
+        TSymbolUniqueId(828);
     static constexpr const TSymbolUniqueId textureGather_Sampler2DArrayShadow1_Float3_Float1 =
-        TSymbolUniqueId(820);
+        TSymbolUniqueId(829);
     static constexpr const TSymbolUniqueId textureGather_SamplerCubeShadow1_Float3 =
-        TSymbolUniqueId(821);
+        TSymbolUniqueId(830);
     static constexpr const TSymbolUniqueId textureGather_SamplerCubeShadow1_Float3_Float1 =
-        TSymbolUniqueId(822);
+        TSymbolUniqueId(831);
     static constexpr const TSymbolUniqueId textureGatherOffset_Sampler2D1_Float2_Int2 =
-        TSymbolUniqueId(823);
+        TSymbolUniqueId(832);
     static constexpr const TSymbolUniqueId textureGatherOffset_ISampler2D1_Float2_Int2 =
-        TSymbolUniqueId(824);
+        TSymbolUniqueId(833);
     static constexpr const TSymbolUniqueId textureGatherOffset_USampler2D1_Float2_Int2 =
-        TSymbolUniqueId(825);
+        TSymbolUniqueId(834);
     static constexpr const TSymbolUniqueId textureGatherOffset_Sampler2D1_Float2_Int2_Int1 =
-        TSymbolUniqueId(826);
+        TSymbolUniqueId(835);
     static constexpr const TSymbolUniqueId textureGatherOffset_ISampler2D1_Float2_Int2_Int1 =
-        TSymbolUniqueId(827);
+        TSymbolUniqueId(836);
     static constexpr const TSymbolUniqueId textureGatherOffset_USampler2D1_Float2_Int2_Int1 =
-        TSymbolUniqueId(828);
+        TSymbolUniqueId(837);
     static constexpr const TSymbolUniqueId textureGatherOffset_Sampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(829);
+        TSymbolUniqueId(838);
     static constexpr const TSymbolUniqueId textureGatherOffset_ISampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(830);
+        TSymbolUniqueId(839);
     static constexpr const TSymbolUniqueId textureGatherOffset_USampler2DArray1_Float3_Int2 =
-        TSymbolUniqueId(831);
+        TSymbolUniqueId(840);
     static constexpr const TSymbolUniqueId textureGatherOffset_Sampler2DArray1_Float3_Int2_Int1 =
-        TSymbolUniqueId(832);
+        TSymbolUniqueId(841);
     static constexpr const TSymbolUniqueId textureGatherOffset_ISampler2DArray1_Float3_Int2_Int1 =
-        TSymbolUniqueId(833);
+        TSymbolUniqueId(842);
     static constexpr const TSymbolUniqueId textureGatherOffset_USampler2DArray1_Float3_Int2_Int1 =
-        TSymbolUniqueId(834);
+        TSymbolUniqueId(843);
     static constexpr const TSymbolUniqueId textureGatherOffset_Sampler2DShadow1_Float2_Float1_Int2 =
-        TSymbolUniqueId(835);
+        TSymbolUniqueId(844);
     static constexpr const TSymbolUniqueId
-        textureGatherOffset_Sampler2DArrayShadow1_Float3_Float1_Int2    = TSymbolUniqueId(836);
-    static constexpr const TSymbolUniqueId dFdx_Float1                  = TSymbolUniqueId(837);
-    static constexpr const TSymbolUniqueId dFdx_Float2                  = TSymbolUniqueId(838);
-    static constexpr const TSymbolUniqueId dFdx_Float3                  = TSymbolUniqueId(839);
-    static constexpr const TSymbolUniqueId dFdx_Float4                  = TSymbolUniqueId(840);
-    static constexpr const TSymbolUniqueId dFdy_Float1                  = TSymbolUniqueId(841);
-    static constexpr const TSymbolUniqueId dFdy_Float2                  = TSymbolUniqueId(842);
-    static constexpr const TSymbolUniqueId dFdy_Float3                  = TSymbolUniqueId(843);
-    static constexpr const TSymbolUniqueId dFdy_Float4                  = TSymbolUniqueId(844);
-    static constexpr const TSymbolUniqueId fwidth_Float1                = TSymbolUniqueId(845);
-    static constexpr const TSymbolUniqueId fwidth_Float2                = TSymbolUniqueId(846);
-    static constexpr const TSymbolUniqueId fwidth_Float3                = TSymbolUniqueId(847);
-    static constexpr const TSymbolUniqueId fwidth_Float4                = TSymbolUniqueId(848);
-    static constexpr const TSymbolUniqueId atomicCounter_AtomicCounter1 = TSymbolUniqueId(849);
-    static constexpr const TSymbolUniqueId pt0F                         = TSymbolUniqueId(850);
+        textureGatherOffset_Sampler2DArrayShadow1_Float3_Float1_Int2    = TSymbolUniqueId(845);
+    static constexpr const TSymbolUniqueId dFdx_Float1                  = TSymbolUniqueId(846);
+    static constexpr const TSymbolUniqueId dFdx_Float2                  = TSymbolUniqueId(847);
+    static constexpr const TSymbolUniqueId dFdx_Float3                  = TSymbolUniqueId(848);
+    static constexpr const TSymbolUniqueId dFdx_Float4                  = TSymbolUniqueId(849);
+    static constexpr const TSymbolUniqueId dFdy_Float1                  = TSymbolUniqueId(850);
+    static constexpr const TSymbolUniqueId dFdy_Float2                  = TSymbolUniqueId(851);
+    static constexpr const TSymbolUniqueId dFdy_Float3                  = TSymbolUniqueId(852);
+    static constexpr const TSymbolUniqueId dFdy_Float4                  = TSymbolUniqueId(853);
+    static constexpr const TSymbolUniqueId fwidth_Float1                = TSymbolUniqueId(854);
+    static constexpr const TSymbolUniqueId fwidth_Float2                = TSymbolUniqueId(855);
+    static constexpr const TSymbolUniqueId fwidth_Float3                = TSymbolUniqueId(856);
+    static constexpr const TSymbolUniqueId fwidth_Float4                = TSymbolUniqueId(857);
+    static constexpr const TSymbolUniqueId atomicCounter_AtomicCounter1 = TSymbolUniqueId(858);
+    static constexpr const TSymbolUniqueId pt0F                         = TSymbolUniqueId(859);
     static constexpr const TSymbolUniqueId atomicCounterIncrement_AtomicCounter1 =
-        TSymbolUniqueId(851);
+        TSymbolUniqueId(860);
     static constexpr const TSymbolUniqueId atomicCounterDecrement_AtomicCounter1 =
-        TSymbolUniqueId(852);
-    static constexpr const TSymbolUniqueId atomicAdd_UInt1_UInt1            = TSymbolUniqueId(853);
-    static constexpr const TSymbolUniqueId pt_io_0D                         = TSymbolUniqueId(854);
-    static constexpr const TSymbolUniqueId atomicAdd_Int1_Int1              = TSymbolUniqueId(855);
-    static constexpr const TSymbolUniqueId pt_io_0C                         = TSymbolUniqueId(856);
-    static constexpr const TSymbolUniqueId atomicMin_UInt1_UInt1            = TSymbolUniqueId(857);
-    static constexpr const TSymbolUniqueId atomicMin_Int1_Int1              = TSymbolUniqueId(858);
-    static constexpr const TSymbolUniqueId atomicMax_UInt1_UInt1            = TSymbolUniqueId(859);
-    static constexpr const TSymbolUniqueId atomicMax_Int1_Int1              = TSymbolUniqueId(860);
-    static constexpr const TSymbolUniqueId atomicAnd_UInt1_UInt1            = TSymbolUniqueId(861);
-    static constexpr const TSymbolUniqueId atomicAnd_Int1_Int1              = TSymbolUniqueId(862);
-    static constexpr const TSymbolUniqueId atomicOr_UInt1_UInt1             = TSymbolUniqueId(863);
-    static constexpr const TSymbolUniqueId atomicOr_Int1_Int1               = TSymbolUniqueId(864);
-    static constexpr const TSymbolUniqueId atomicXor_UInt1_UInt1            = TSymbolUniqueId(865);
-    static constexpr const TSymbolUniqueId atomicXor_Int1_Int1              = TSymbolUniqueId(866);
-    static constexpr const TSymbolUniqueId atomicExchange_UInt1_UInt1       = TSymbolUniqueId(867);
-    static constexpr const TSymbolUniqueId atomicExchange_Int1_Int1         = TSymbolUniqueId(868);
-    static constexpr const TSymbolUniqueId atomicCompSwap_UInt1_UInt1_UInt1 = TSymbolUniqueId(869);
-    static constexpr const TSymbolUniqueId atomicCompSwap_Int1_Int1_Int1    = TSymbolUniqueId(870);
-    static constexpr const TSymbolUniqueId imageSize_Image2D1               = TSymbolUniqueId(871);
-    static constexpr const TSymbolUniqueId pt0c                             = TSymbolUniqueId(872);
-    static constexpr const TSymbolUniqueId imageSize_IImage2D1              = TSymbolUniqueId(873);
-    static constexpr const TSymbolUniqueId pt0d                             = TSymbolUniqueId(874);
-    static constexpr const TSymbolUniqueId imageSize_UImage2D1              = TSymbolUniqueId(875);
-    static constexpr const TSymbolUniqueId pt0e                             = TSymbolUniqueId(876);
-    static constexpr const TSymbolUniqueId imageSize_Image3D1               = TSymbolUniqueId(877);
-    static constexpr const TSymbolUniqueId pt0f                             = TSymbolUniqueId(878);
-    static constexpr const TSymbolUniqueId imageSize_IImage3D1              = TSymbolUniqueId(879);
-    static constexpr const TSymbolUniqueId pt0g                             = TSymbolUniqueId(880);
-    static constexpr const TSymbolUniqueId imageSize_UImage3D1              = TSymbolUniqueId(881);
-    static constexpr const TSymbolUniqueId pt0h                             = TSymbolUniqueId(882);
-    static constexpr const TSymbolUniqueId imageSize_Image2DArray1          = TSymbolUniqueId(883);
-    static constexpr const TSymbolUniqueId pt0i                             = TSymbolUniqueId(884);
-    static constexpr const TSymbolUniqueId imageSize_IImage2DArray1         = TSymbolUniqueId(885);
-    static constexpr const TSymbolUniqueId pt0j                             = TSymbolUniqueId(886);
-    static constexpr const TSymbolUniqueId imageSize_UImage2DArray1         = TSymbolUniqueId(887);
-    static constexpr const TSymbolUniqueId pt0k                             = TSymbolUniqueId(888);
-    static constexpr const TSymbolUniqueId imageSize_ImageCube1             = TSymbolUniqueId(889);
-    static constexpr const TSymbolUniqueId pt0l                             = TSymbolUniqueId(890);
-    static constexpr const TSymbolUniqueId imageSize_IImageCube1            = TSymbolUniqueId(891);
-    static constexpr const TSymbolUniqueId pt0m                             = TSymbolUniqueId(892);
-    static constexpr const TSymbolUniqueId imageSize_UImageCube1            = TSymbolUniqueId(893);
-    static constexpr const TSymbolUniqueId pt0n                             = TSymbolUniqueId(894);
-    static constexpr const TSymbolUniqueId imageLoad_Image2D1_Int2          = TSymbolUniqueId(895);
-    static constexpr const TSymbolUniqueId imageLoad_IImage2D1_Int2         = TSymbolUniqueId(896);
-    static constexpr const TSymbolUniqueId imageLoad_UImage2D1_Int2         = TSymbolUniqueId(897);
-    static constexpr const TSymbolUniqueId imageLoad_Image3D1_Int3          = TSymbolUniqueId(898);
-    static constexpr const TSymbolUniqueId imageLoad_IImage3D1_Int3         = TSymbolUniqueId(899);
-    static constexpr const TSymbolUniqueId imageLoad_UImage3D1_Int3         = TSymbolUniqueId(900);
-    static constexpr const TSymbolUniqueId imageLoad_Image2DArray1_Int3     = TSymbolUniqueId(901);
-    static constexpr const TSymbolUniqueId imageLoad_IImage2DArray1_Int3    = TSymbolUniqueId(902);
-    static constexpr const TSymbolUniqueId imageLoad_UImage2DArray1_Int3    = TSymbolUniqueId(903);
-    static constexpr const TSymbolUniqueId imageLoad_ImageCube1_Int3        = TSymbolUniqueId(904);
-    static constexpr const TSymbolUniqueId imageLoad_IImageCube1_Int3       = TSymbolUniqueId(905);
-    static constexpr const TSymbolUniqueId imageLoad_UImageCube1_Int3       = TSymbolUniqueId(906);
-    static constexpr const TSymbolUniqueId imageStore_Image2D1_Int2_Float4  = TSymbolUniqueId(907);
-    static constexpr const TSymbolUniqueId imageStore_IImage2D1_Int2_Int4   = TSymbolUniqueId(908);
-    static constexpr const TSymbolUniqueId imageStore_UImage2D1_Int2_UInt4  = TSymbolUniqueId(909);
-    static constexpr const TSymbolUniqueId imageStore_Image3D1_Int3_Float4  = TSymbolUniqueId(910);
-    static constexpr const TSymbolUniqueId imageStore_IImage3D1_Int3_Int4   = TSymbolUniqueId(911);
-    static constexpr const TSymbolUniqueId imageStore_UImage3D1_Int3_UInt4  = TSymbolUniqueId(912);
+        TSymbolUniqueId(861);
+    static constexpr const TSymbolUniqueId atomicAdd_UInt1_UInt1            = TSymbolUniqueId(862);
+    static constexpr const TSymbolUniqueId pt_io_0D                         = TSymbolUniqueId(863);
+    static constexpr const TSymbolUniqueId atomicAdd_Int1_Int1              = TSymbolUniqueId(864);
+    static constexpr const TSymbolUniqueId pt_io_0C                         = TSymbolUniqueId(865);
+    static constexpr const TSymbolUniqueId atomicMin_UInt1_UInt1            = TSymbolUniqueId(866);
+    static constexpr const TSymbolUniqueId atomicMin_Int1_Int1              = TSymbolUniqueId(867);
+    static constexpr const TSymbolUniqueId atomicMax_UInt1_UInt1            = TSymbolUniqueId(868);
+    static constexpr const TSymbolUniqueId atomicMax_Int1_Int1              = TSymbolUniqueId(869);
+    static constexpr const TSymbolUniqueId atomicAnd_UInt1_UInt1            = TSymbolUniqueId(870);
+    static constexpr const TSymbolUniqueId atomicAnd_Int1_Int1              = TSymbolUniqueId(871);
+    static constexpr const TSymbolUniqueId atomicOr_UInt1_UInt1             = TSymbolUniqueId(872);
+    static constexpr const TSymbolUniqueId atomicOr_Int1_Int1               = TSymbolUniqueId(873);
+    static constexpr const TSymbolUniqueId atomicXor_UInt1_UInt1            = TSymbolUniqueId(874);
+    static constexpr const TSymbolUniqueId atomicXor_Int1_Int1              = TSymbolUniqueId(875);
+    static constexpr const TSymbolUniqueId atomicExchange_UInt1_UInt1       = TSymbolUniqueId(876);
+    static constexpr const TSymbolUniqueId atomicExchange_Int1_Int1         = TSymbolUniqueId(877);
+    static constexpr const TSymbolUniqueId atomicCompSwap_UInt1_UInt1_UInt1 = TSymbolUniqueId(878);
+    static constexpr const TSymbolUniqueId atomicCompSwap_Int1_Int1_Int1    = TSymbolUniqueId(879);
+    static constexpr const TSymbolUniqueId imageSize_Image2D1               = TSymbolUniqueId(880);
+    static constexpr const TSymbolUniqueId pt0f                             = TSymbolUniqueId(881);
+    static constexpr const TSymbolUniqueId imageSize_IImage2D1              = TSymbolUniqueId(882);
+    static constexpr const TSymbolUniqueId pt0g                             = TSymbolUniqueId(883);
+    static constexpr const TSymbolUniqueId imageSize_UImage2D1              = TSymbolUniqueId(884);
+    static constexpr const TSymbolUniqueId pt0h                             = TSymbolUniqueId(885);
+    static constexpr const TSymbolUniqueId imageSize_Image3D1               = TSymbolUniqueId(886);
+    static constexpr const TSymbolUniqueId pt0i                             = TSymbolUniqueId(887);
+    static constexpr const TSymbolUniqueId imageSize_IImage3D1              = TSymbolUniqueId(888);
+    static constexpr const TSymbolUniqueId pt0j                             = TSymbolUniqueId(889);
+    static constexpr const TSymbolUniqueId imageSize_UImage3D1              = TSymbolUniqueId(890);
+    static constexpr const TSymbolUniqueId pt0k                             = TSymbolUniqueId(891);
+    static constexpr const TSymbolUniqueId imageSize_Image2DArray1          = TSymbolUniqueId(892);
+    static constexpr const TSymbolUniqueId pt0l                             = TSymbolUniqueId(893);
+    static constexpr const TSymbolUniqueId imageSize_IImage2DArray1         = TSymbolUniqueId(894);
+    static constexpr const TSymbolUniqueId pt0m                             = TSymbolUniqueId(895);
+    static constexpr const TSymbolUniqueId imageSize_UImage2DArray1         = TSymbolUniqueId(896);
+    static constexpr const TSymbolUniqueId pt0n                             = TSymbolUniqueId(897);
+    static constexpr const TSymbolUniqueId imageSize_ImageCube1             = TSymbolUniqueId(898);
+    static constexpr const TSymbolUniqueId pt0o                             = TSymbolUniqueId(899);
+    static constexpr const TSymbolUniqueId imageSize_IImageCube1            = TSymbolUniqueId(900);
+    static constexpr const TSymbolUniqueId pt0p                             = TSymbolUniqueId(901);
+    static constexpr const TSymbolUniqueId imageSize_UImageCube1            = TSymbolUniqueId(902);
+    static constexpr const TSymbolUniqueId pt0q                             = TSymbolUniqueId(903);
+    static constexpr const TSymbolUniqueId imageLoad_Image2D1_Int2          = TSymbolUniqueId(904);
+    static constexpr const TSymbolUniqueId imageLoad_IImage2D1_Int2         = TSymbolUniqueId(905);
+    static constexpr const TSymbolUniqueId imageLoad_UImage2D1_Int2         = TSymbolUniqueId(906);
+    static constexpr const TSymbolUniqueId imageLoad_Image3D1_Int3          = TSymbolUniqueId(907);
+    static constexpr const TSymbolUniqueId imageLoad_IImage3D1_Int3         = TSymbolUniqueId(908);
+    static constexpr const TSymbolUniqueId imageLoad_UImage3D1_Int3         = TSymbolUniqueId(909);
+    static constexpr const TSymbolUniqueId imageLoad_Image2DArray1_Int3     = TSymbolUniqueId(910);
+    static constexpr const TSymbolUniqueId imageLoad_IImage2DArray1_Int3    = TSymbolUniqueId(911);
+    static constexpr const TSymbolUniqueId imageLoad_UImage2DArray1_Int3    = TSymbolUniqueId(912);
+    static constexpr const TSymbolUniqueId imageLoad_ImageCube1_Int3        = TSymbolUniqueId(913);
+    static constexpr const TSymbolUniqueId imageLoad_IImageCube1_Int3       = TSymbolUniqueId(914);
+    static constexpr const TSymbolUniqueId imageLoad_UImageCube1_Int3       = TSymbolUniqueId(915);
+    static constexpr const TSymbolUniqueId imageStore_Image2D1_Int2_Float4  = TSymbolUniqueId(916);
+    static constexpr const TSymbolUniqueId imageStore_IImage2D1_Int2_Int4   = TSymbolUniqueId(917);
+    static constexpr const TSymbolUniqueId imageStore_UImage2D1_Int2_UInt4  = TSymbolUniqueId(918);
+    static constexpr const TSymbolUniqueId imageStore_Image3D1_Int3_Float4  = TSymbolUniqueId(919);
+    static constexpr const TSymbolUniqueId imageStore_IImage3D1_Int3_Int4   = TSymbolUniqueId(920);
+    static constexpr const TSymbolUniqueId imageStore_UImage3D1_Int3_UInt4  = TSymbolUniqueId(921);
     static constexpr const TSymbolUniqueId imageStore_Image2DArray1_Int3_Float4 =
-        TSymbolUniqueId(913);
+        TSymbolUniqueId(922);
     static constexpr const TSymbolUniqueId imageStore_IImage2DArray1_Int3_Int4 =
-        TSymbolUniqueId(914);
+        TSymbolUniqueId(923);
     static constexpr const TSymbolUniqueId imageStore_UImage2DArray1_Int3_UInt4 =
-        TSymbolUniqueId(915);
-    static constexpr const TSymbolUniqueId imageStore_ImageCube1_Int3_Float4 = TSymbolUniqueId(916);
-    static constexpr const TSymbolUniqueId imageStore_IImageCube1_Int3_Int4  = TSymbolUniqueId(917);
-    static constexpr const TSymbolUniqueId imageStore_UImageCube1_Int3_UInt4 = TSymbolUniqueId(918);
-    static constexpr const TSymbolUniqueId memoryBarrier                     = TSymbolUniqueId(919);
-    static constexpr const TSymbolUniqueId memoryBarrierAtomicCounter        = TSymbolUniqueId(920);
-    static constexpr const TSymbolUniqueId memoryBarrierBuffer               = TSymbolUniqueId(921);
-    static constexpr const TSymbolUniqueId memoryBarrierImage                = TSymbolUniqueId(922);
-    static constexpr const TSymbolUniqueId barrier                           = TSymbolUniqueId(923);
-    static constexpr const TSymbolUniqueId memoryBarrierShared               = TSymbolUniqueId(924);
-    static constexpr const TSymbolUniqueId groupMemoryBarrier                = TSymbolUniqueId(925);
-    static constexpr const TSymbolUniqueId EmitVertex                        = TSymbolUniqueId(926);
-    static constexpr const TSymbolUniqueId EndPrimitive                      = TSymbolUniqueId(927);
-    static constexpr const TSymbolUniqueId gl_DepthRangeParameters           = TSymbolUniqueId(928);
-    static constexpr const TSymbolUniqueId gl_DepthRange                     = TSymbolUniqueId(929);
-    static constexpr const TSymbolUniqueId gl_MaxVertexAttribs               = TSymbolUniqueId(930);
-    static constexpr const TSymbolUniqueId gl_MaxVertexUniformVectors        = TSymbolUniqueId(931);
-    static constexpr const TSymbolUniqueId gl_MaxVertexTextureImageUnits     = TSymbolUniqueId(932);
-    static constexpr const TSymbolUniqueId gl_MaxCombinedTextureImageUnits   = TSymbolUniqueId(933);
-    static constexpr const TSymbolUniqueId gl_MaxTextureImageUnits           = TSymbolUniqueId(934);
-    static constexpr const TSymbolUniqueId gl_MaxFragmentUniformVectors      = TSymbolUniqueId(935);
-    static constexpr const TSymbolUniqueId gl_MaxVaryingVectors              = TSymbolUniqueId(936);
-    static constexpr const TSymbolUniqueId gl_MaxDrawBuffers                 = TSymbolUniqueId(937);
-    static constexpr const TSymbolUniqueId gl_MaxDualSourceDrawBuffersEXT    = TSymbolUniqueId(938);
-    static constexpr const TSymbolUniqueId gl_MaxVertexOutputVectors         = TSymbolUniqueId(939);
-    static constexpr const TSymbolUniqueId gl_MaxFragmentInputVectors        = TSymbolUniqueId(940);
-    static constexpr const TSymbolUniqueId gl_MinProgramTexelOffset          = TSymbolUniqueId(941);
-    static constexpr const TSymbolUniqueId gl_MaxProgramTexelOffset          = TSymbolUniqueId(942);
-    static constexpr const TSymbolUniqueId gl_MaxImageUnits                  = TSymbolUniqueId(943);
-    static constexpr const TSymbolUniqueId gl_MaxVertexImageUniforms         = TSymbolUniqueId(944);
-    static constexpr const TSymbolUniqueId gl_MaxFragmentImageUniforms       = TSymbolUniqueId(945);
-    static constexpr const TSymbolUniqueId gl_MaxComputeImageUniforms        = TSymbolUniqueId(946);
-    static constexpr const TSymbolUniqueId gl_MaxCombinedImageUniforms       = TSymbolUniqueId(947);
+        TSymbolUniqueId(924);
+    static constexpr const TSymbolUniqueId imageStore_ImageCube1_Int3_Float4 = TSymbolUniqueId(925);
+    static constexpr const TSymbolUniqueId imageStore_IImageCube1_Int3_Int4  = TSymbolUniqueId(926);
+    static constexpr const TSymbolUniqueId imageStore_UImageCube1_Int3_UInt4 = TSymbolUniqueId(927);
+    static constexpr const TSymbolUniqueId memoryBarrier                     = TSymbolUniqueId(928);
+    static constexpr const TSymbolUniqueId memoryBarrierAtomicCounter        = TSymbolUniqueId(929);
+    static constexpr const TSymbolUniqueId memoryBarrierBuffer               = TSymbolUniqueId(930);
+    static constexpr const TSymbolUniqueId memoryBarrierImage                = TSymbolUniqueId(931);
+    static constexpr const TSymbolUniqueId barrier                           = TSymbolUniqueId(932);
+    static constexpr const TSymbolUniqueId memoryBarrierShared               = TSymbolUniqueId(933);
+    static constexpr const TSymbolUniqueId groupMemoryBarrier                = TSymbolUniqueId(934);
+    static constexpr const TSymbolUniqueId EmitVertex                        = TSymbolUniqueId(935);
+    static constexpr const TSymbolUniqueId EndPrimitive                      = TSymbolUniqueId(936);
+    static constexpr const TSymbolUniqueId gl_DepthRangeParameters           = TSymbolUniqueId(937);
+    static constexpr const TSymbolUniqueId gl_DepthRange                     = TSymbolUniqueId(938);
+    static constexpr const TSymbolUniqueId gl_MaxVertexAttribs               = TSymbolUniqueId(939);
+    static constexpr const TSymbolUniqueId gl_MaxVertexUniformVectors        = TSymbolUniqueId(940);
+    static constexpr const TSymbolUniqueId gl_MaxVertexTextureImageUnits     = TSymbolUniqueId(941);
+    static constexpr const TSymbolUniqueId gl_MaxCombinedTextureImageUnits   = TSymbolUniqueId(942);
+    static constexpr const TSymbolUniqueId gl_MaxTextureImageUnits           = TSymbolUniqueId(943);
+    static constexpr const TSymbolUniqueId gl_MaxFragmentUniformVectors      = TSymbolUniqueId(944);
+    static constexpr const TSymbolUniqueId gl_MaxVaryingVectors              = TSymbolUniqueId(945);
+    static constexpr const TSymbolUniqueId gl_MaxDrawBuffers                 = TSymbolUniqueId(946);
+    static constexpr const TSymbolUniqueId gl_MaxDualSourceDrawBuffersEXT    = TSymbolUniqueId(947);
+    static constexpr const TSymbolUniqueId gl_MaxVertexOutputVectors         = TSymbolUniqueId(948);
+    static constexpr const TSymbolUniqueId gl_MaxFragmentInputVectors        = TSymbolUniqueId(949);
+    static constexpr const TSymbolUniqueId gl_MinProgramTexelOffset          = TSymbolUniqueId(950);
+    static constexpr const TSymbolUniqueId gl_MaxProgramTexelOffset          = TSymbolUniqueId(951);
+    static constexpr const TSymbolUniqueId gl_MaxImageUnits                  = TSymbolUniqueId(952);
+    static constexpr const TSymbolUniqueId gl_MaxVertexImageUniforms         = TSymbolUniqueId(953);
+    static constexpr const TSymbolUniqueId gl_MaxFragmentImageUniforms       = TSymbolUniqueId(954);
+    static constexpr const TSymbolUniqueId gl_MaxComputeImageUniforms        = TSymbolUniqueId(955);
+    static constexpr const TSymbolUniqueId gl_MaxCombinedImageUniforms       = TSymbolUniqueId(956);
     static constexpr const TSymbolUniqueId gl_MaxCombinedShaderOutputResources =
-        TSymbolUniqueId(948);
-    static constexpr const TSymbolUniqueId gl_MaxComputeWorkGroupCount       = TSymbolUniqueId(949);
-    static constexpr const TSymbolUniqueId gl_MaxComputeWorkGroupSize        = TSymbolUniqueId(950);
-    static constexpr const TSymbolUniqueId gl_MaxComputeUniformComponents    = TSymbolUniqueId(951);
-    static constexpr const TSymbolUniqueId gl_MaxComputeTextureImageUnits    = TSymbolUniqueId(952);
-    static constexpr const TSymbolUniqueId gl_MaxComputeAtomicCounters       = TSymbolUniqueId(953);
-    static constexpr const TSymbolUniqueId gl_MaxComputeAtomicCounterBuffers = TSymbolUniqueId(954);
-    static constexpr const TSymbolUniqueId gl_MaxVertexAtomicCounters        = TSymbolUniqueId(955);
-    static constexpr const TSymbolUniqueId gl_MaxFragmentAtomicCounters      = TSymbolUniqueId(956);
-    static constexpr const TSymbolUniqueId gl_MaxCombinedAtomicCounters      = TSymbolUniqueId(957);
-    static constexpr const TSymbolUniqueId gl_MaxAtomicCounterBindings       = TSymbolUniqueId(958);
-    static constexpr const TSymbolUniqueId gl_MaxVertexAtomicCounterBuffers  = TSymbolUniqueId(959);
+        TSymbolUniqueId(957);
+    static constexpr const TSymbolUniqueId gl_MaxComputeWorkGroupCount       = TSymbolUniqueId(958);
+    static constexpr const TSymbolUniqueId gl_MaxComputeWorkGroupSize        = TSymbolUniqueId(959);
+    static constexpr const TSymbolUniqueId gl_MaxComputeUniformComponents    = TSymbolUniqueId(960);
+    static constexpr const TSymbolUniqueId gl_MaxComputeTextureImageUnits    = TSymbolUniqueId(961);
+    static constexpr const TSymbolUniqueId gl_MaxComputeAtomicCounters       = TSymbolUniqueId(962);
+    static constexpr const TSymbolUniqueId gl_MaxComputeAtomicCounterBuffers = TSymbolUniqueId(963);
+    static constexpr const TSymbolUniqueId gl_MaxVertexAtomicCounters        = TSymbolUniqueId(964);
+    static constexpr const TSymbolUniqueId gl_MaxFragmentAtomicCounters      = TSymbolUniqueId(965);
+    static constexpr const TSymbolUniqueId gl_MaxCombinedAtomicCounters      = TSymbolUniqueId(966);
+    static constexpr const TSymbolUniqueId gl_MaxAtomicCounterBindings       = TSymbolUniqueId(967);
+    static constexpr const TSymbolUniqueId gl_MaxVertexAtomicCounterBuffers  = TSymbolUniqueId(968);
     static constexpr const TSymbolUniqueId gl_MaxFragmentAtomicCounterBuffers =
-        TSymbolUniqueId(960);
+        TSymbolUniqueId(969);
     static constexpr const TSymbolUniqueId gl_MaxCombinedAtomicCounterBuffers =
-        TSymbolUniqueId(961);
-    static constexpr const TSymbolUniqueId gl_MaxAtomicCounterBufferSize   = TSymbolUniqueId(962);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryInputComponents   = TSymbolUniqueId(963);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryOutputComponents  = TSymbolUniqueId(964);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryImageUniforms     = TSymbolUniqueId(965);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryTextureImageUnits = TSymbolUniqueId(966);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryOutputVertices    = TSymbolUniqueId(967);
+        TSymbolUniqueId(970);
+    static constexpr const TSymbolUniqueId gl_MaxAtomicCounterBufferSize   = TSymbolUniqueId(971);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryInputComponents   = TSymbolUniqueId(972);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryOutputComponents  = TSymbolUniqueId(973);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryImageUniforms     = TSymbolUniqueId(974);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryTextureImageUnits = TSymbolUniqueId(975);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryOutputVertices    = TSymbolUniqueId(976);
     static constexpr const TSymbolUniqueId gl_MaxGeometryTotalOutputComponents =
-        TSymbolUniqueId(968);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryUniformComponents = TSymbolUniqueId(969);
-    static constexpr const TSymbolUniqueId gl_MaxGeometryAtomicCounters    = TSymbolUniqueId(970);
+        TSymbolUniqueId(977);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryUniformComponents = TSymbolUniqueId(978);
+    static constexpr const TSymbolUniqueId gl_MaxGeometryAtomicCounters    = TSymbolUniqueId(979);
     static constexpr const TSymbolUniqueId gl_MaxGeometryAtomicCounterBuffers =
-        TSymbolUniqueId(971);
-    static constexpr const TSymbolUniqueId gl_FragCoord             = TSymbolUniqueId(972);
-    static constexpr const TSymbolUniqueId gl_FrontFacing           = TSymbolUniqueId(973);
-    static constexpr const TSymbolUniqueId gl_PointCoord            = TSymbolUniqueId(974);
-    static constexpr const TSymbolUniqueId gl_FragColor             = TSymbolUniqueId(975);
-    static constexpr const TSymbolUniqueId gl_FragData              = TSymbolUniqueId(976);
-    static constexpr const TSymbolUniqueId gl_FragDepth             = TSymbolUniqueId(977);
-    static constexpr const TSymbolUniqueId gl_SecondaryFragColorEXT = TSymbolUniqueId(978);
-    static constexpr const TSymbolUniqueId gl_SecondaryFragDataEXT  = TSymbolUniqueId(979);
-    static constexpr const TSymbolUniqueId gl_FragDepthEXT          = TSymbolUniqueId(980);
-    static constexpr const TSymbolUniqueId gl_LastFragData          = TSymbolUniqueId(981);
-    static constexpr const TSymbolUniqueId gl_LastFragColor         = TSymbolUniqueId(982);
-    static constexpr const TSymbolUniqueId gl_LastFragDataNV        = TSymbolUniqueId(983);
-    static constexpr const TSymbolUniqueId gl_LastFragColorARM      = TSymbolUniqueId(984);
-    static constexpr const TSymbolUniqueId gl_PrimitiveID           = TSymbolUniqueId(985);
-    static constexpr const TSymbolUniqueId gl_Layer                 = TSymbolUniqueId(986);
-    static constexpr const TSymbolUniqueId gl_Position              = TSymbolUniqueId(987);
-    static constexpr const TSymbolUniqueId gl_PointSize             = TSymbolUniqueId(988);
-    static constexpr const TSymbolUniqueId gl_InstanceID            = TSymbolUniqueId(989);
-    static constexpr const TSymbolUniqueId gl_VertexID              = TSymbolUniqueId(990);
-    static constexpr const TSymbolUniqueId gl_ViewportIndex         = TSymbolUniqueId(991);
-    static constexpr const TSymbolUniqueId gl_LayerVS               = TSymbolUniqueId(992);
-    static constexpr const TSymbolUniqueId gl_NumWorkGroups         = TSymbolUniqueId(993);
-    static constexpr const TSymbolUniqueId gl_WorkGroupSize         = TSymbolUniqueId(994);
-    static constexpr const TSymbolUniqueId gl_WorkGroupID           = TSymbolUniqueId(995);
-    static constexpr const TSymbolUniqueId gl_LocalInvocationID     = TSymbolUniqueId(996);
-    static constexpr const TSymbolUniqueId gl_GlobalInvocationID    = TSymbolUniqueId(997);
-    static constexpr const TSymbolUniqueId gl_LocalInvocationIndex  = TSymbolUniqueId(998);
-    static constexpr const TSymbolUniqueId gl_PrimitiveIDIn         = TSymbolUniqueId(999);
-    static constexpr const TSymbolUniqueId gl_InvocationID          = TSymbolUniqueId(1000);
-    static constexpr const TSymbolUniqueId gl_PrimitiveIDGS         = TSymbolUniqueId(1001);
-    static constexpr const TSymbolUniqueId gl_LayerGS               = TSymbolUniqueId(1002);
-    static constexpr const TSymbolUniqueId gl_PerVertex             = TSymbolUniqueId(1003);
-    static constexpr const TSymbolUniqueId gl_in                    = TSymbolUniqueId(1004);
-    static constexpr const TSymbolUniqueId gl_PerVertexOutBlock     = TSymbolUniqueId(1005);
-    static constexpr const TSymbolUniqueId gl_PositionGS            = TSymbolUniqueId(1006);
-    static constexpr const TSymbolUniqueId gl_ViewID_OVR            = TSymbolUniqueId(1007);
-    static constexpr const TSymbolUniqueId gl_ViewID_OVRESSL1       = TSymbolUniqueId(1008);
+        TSymbolUniqueId(980);
+    static constexpr const TSymbolUniqueId gl_FragCoord             = TSymbolUniqueId(981);
+    static constexpr const TSymbolUniqueId gl_FrontFacing           = TSymbolUniqueId(982);
+    static constexpr const TSymbolUniqueId gl_PointCoord            = TSymbolUniqueId(983);
+    static constexpr const TSymbolUniqueId gl_FragColor             = TSymbolUniqueId(984);
+    static constexpr const TSymbolUniqueId gl_FragData              = TSymbolUniqueId(985);
+    static constexpr const TSymbolUniqueId gl_FragDepth             = TSymbolUniqueId(986);
+    static constexpr const TSymbolUniqueId gl_SecondaryFragColorEXT = TSymbolUniqueId(987);
+    static constexpr const TSymbolUniqueId gl_SecondaryFragDataEXT  = TSymbolUniqueId(988);
+    static constexpr const TSymbolUniqueId gl_FragDepthEXT          = TSymbolUniqueId(989);
+    static constexpr const TSymbolUniqueId gl_LastFragData          = TSymbolUniqueId(990);
+    static constexpr const TSymbolUniqueId gl_LastFragColor         = TSymbolUniqueId(991);
+    static constexpr const TSymbolUniqueId gl_LastFragDataNV        = TSymbolUniqueId(992);
+    static constexpr const TSymbolUniqueId gl_LastFragColorARM      = TSymbolUniqueId(993);
+    static constexpr const TSymbolUniqueId gl_PrimitiveID           = TSymbolUniqueId(994);
+    static constexpr const TSymbolUniqueId gl_Layer                 = TSymbolUniqueId(995);
+    static constexpr const TSymbolUniqueId gl_Position              = TSymbolUniqueId(996);
+    static constexpr const TSymbolUniqueId gl_PointSize             = TSymbolUniqueId(997);
+    static constexpr const TSymbolUniqueId gl_InstanceID            = TSymbolUniqueId(998);
+    static constexpr const TSymbolUniqueId gl_VertexID              = TSymbolUniqueId(999);
+    static constexpr const TSymbolUniqueId gl_ViewportIndex         = TSymbolUniqueId(1000);
+    static constexpr const TSymbolUniqueId gl_LayerVS               = TSymbolUniqueId(1001);
+    static constexpr const TSymbolUniqueId gl_NumWorkGroups         = TSymbolUniqueId(1002);
+    static constexpr const TSymbolUniqueId gl_WorkGroupSize         = TSymbolUniqueId(1003);
+    static constexpr const TSymbolUniqueId gl_WorkGroupID           = TSymbolUniqueId(1004);
+    static constexpr const TSymbolUniqueId gl_LocalInvocationID     = TSymbolUniqueId(1005);
+    static constexpr const TSymbolUniqueId gl_GlobalInvocationID    = TSymbolUniqueId(1006);
+    static constexpr const TSymbolUniqueId gl_LocalInvocationIndex  = TSymbolUniqueId(1007);
+    static constexpr const TSymbolUniqueId gl_PrimitiveIDIn         = TSymbolUniqueId(1008);
+    static constexpr const TSymbolUniqueId gl_InvocationID          = TSymbolUniqueId(1009);
+    static constexpr const TSymbolUniqueId gl_PrimitiveIDGS         = TSymbolUniqueId(1010);
+    static constexpr const TSymbolUniqueId gl_LayerGS               = TSymbolUniqueId(1011);
+    static constexpr const TSymbolUniqueId gl_PerVertex             = TSymbolUniqueId(1012);
+    static constexpr const TSymbolUniqueId gl_in                    = TSymbolUniqueId(1013);
+    static constexpr const TSymbolUniqueId gl_PerVertexOutBlock     = TSymbolUniqueId(1014);
+    static constexpr const TSymbolUniqueId gl_PositionGS            = TSymbolUniqueId(1015);
+    static constexpr const TSymbolUniqueId gl_ViewID_OVR            = TSymbolUniqueId(1016);
+    static constexpr const TSymbolUniqueId gl_ViewID_OVRESSL1       = TSymbolUniqueId(1017);
 
 };  // class BuiltInId
 

src/tests/compiler_tests/ImmutableString_test_autogen.cpp

@@ -523,195 +523,198 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x20b8a0c3u, ImmutableString("texture2DProjLod(0H3B0B").mangledNameHash());
     ASSERT_EQ(0x1cac1f4du, ImmutableString("textureCubeLod(0J2B0B").mangledNameHash());
     ASSERT_EQ(0x0e65ea73u, ImmutableString("texture(0H1B").mangledNameHash());
-    ASSERT_EQ(0x0e673fffu, ImmutableString("texture(0P1B").mangledNameHash());
-    ASSERT_EQ(0x0e66cb64u, ImmutableString("texture(0U1B").mangledNameHash());
+    ASSERT_EQ(0x0e60bb56u, ImmutableString("texture(0Q1B").mangledNameHash());
+    ASSERT_EQ(0x0e64ec86u, ImmutableString("texture(0W1B").mangledNameHash());
     ASSERT_EQ(0x0e625169u, ImmutableString("texture(0I2B").mangledNameHash());
-    ASSERT_EQ(0x0e638fabu, ImmutableString("texture(0Q2B").mangledNameHash());
-    ASSERT_EQ(0x0e61df23u, ImmutableString("texture(0V2B").mangledNameHash());
-    ASSERT_EQ(0x0e6470f1u, ImmutableString("texture(0J2B").mangledNameHash());
     ASSERT_EQ(0x0e67a979u, ImmutableString("texture(0R2B").mangledNameHash());
-    ASSERT_EQ(0x0e646500u, ImmutableString("texture(0W2B").mangledNameHash());
-    ASSERT_EQ(0x0e61222eu, ImmutableString("texture(0K2B").mangledNameHash());
-    ASSERT_EQ(0x0e60445cu, ImmutableString("texture(0S2B").mangledNameHash());
     ASSERT_EQ(0x0e64854cu, ImmutableString("texture(0X2B").mangledNameHash());
+    ASSERT_EQ(0x0e6470f1u, ImmutableString("texture(0J2B").mangledNameHash());
+    ASSERT_EQ(0x0e60445cu, ImmutableString("texture(0S2B").mangledNameHash());
+    ASSERT_EQ(0x0e67dce5u, ImmutableString("texture(0Y2B").mangledNameHash());
+    ASSERT_EQ(0x0e61222eu, ImmutableString("texture(0K2B").mangledNameHash());
+    ASSERT_EQ(0x0e62790eu, ImmutableString("texture(0T2B").mangledNameHash());
+    ASSERT_EQ(0x0e61e49du, ImmutableString("texture(0Z2B").mangledNameHash());
     ASSERT_EQ(0x168178c7u, ImmutableString("textureProj(0H2B").mangledNameHash());
-    ASSERT_EQ(0x1681a77du, ImmutableString("textureProj(0P2B").mangledNameHash());
-    ASSERT_EQ(0x168705d2u, ImmutableString("textureProj(0U2B").mangledNameHash());
+    ASSERT_EQ(0x1685011eu, ImmutableString("textureProj(0Q2B").mangledNameHash());
+    ASSERT_EQ(0x1687d107u, ImmutableString("textureProj(0W2B").mangledNameHash());
     ASSERT_EQ(0x16840064u, ImmutableString("textureProj(0H3B").mangledNameHash());
-    ASSERT_EQ(0x16807544u, ImmutableString("textureProj(0P3B").mangledNameHash());
-    ASSERT_EQ(0x168021fbu, ImmutableString("textureProj(0U3B").mangledNameHash());
-    ASSERT_EQ(0x1685ca01u, ImmutableString("textureProj(0I3B").mangledNameHash());
     ASSERT_EQ(0x16860d28u, ImmutableString("textureProj(0Q3B").mangledNameHash());
-    ASSERT_EQ(0x1681e38fu, ImmutableString("textureProj(0V3B").mangledNameHash());
+    ASSERT_EQ(0x16812eeeu, ImmutableString("textureProj(0W3B").mangledNameHash());
+    ASSERT_EQ(0x1685ca01u, ImmutableString("textureProj(0I3B").mangledNameHash());
+    ASSERT_EQ(0x1687c54du, ImmutableString("textureProj(0R3B").mangledNameHash());
+    ASSERT_EQ(0x1682b6c4u, ImmutableString("textureProj(0X3B").mangledNameHash());
     ASSERT_EQ(0x148b33b6u, ImmutableString("textureLod(0H1B0B").mangledNameHash());
-    ASSERT_EQ(0x148fde6au, ImmutableString("textureLod(0P1B0B").mangledNameHash());
-    ASSERT_EQ(0x148f7fe8u, ImmutableString("textureLod(0U1B0B").mangledNameHash());
+    ASSERT_EQ(0x148fa8bbu, ImmutableString("textureLod(0Q1B0B").mangledNameHash());
+    ASSERT_EQ(0x1488a5bfu, ImmutableString("textureLod(0W1B0B").mangledNameHash());
     ASSERT_EQ(0x148d335cu, ImmutableString("textureLod(0I2B0B").mangledNameHash());
-    ASSERT_EQ(0x14888557u, ImmutableString("textureLod(0Q2B0B").mangledNameHash());
-    ASSERT_EQ(0x148999efu, ImmutableString("textureLod(0V2B0B").mangledNameHash());
-    ASSERT_EQ(0x148b00dbu, ImmutableString("textureLod(0J2B0B").mangledNameHash());
     ASSERT_EQ(0x148cccafu, ImmutableString("textureLod(0R2B0B").mangledNameHash());
-    ASSERT_EQ(0x148d3512u, ImmutableString("textureLod(0W2B0B").mangledNameHash());
-    ASSERT_EQ(0x148ed87fu, ImmutableString("textureLod(0K2B0B").mangledNameHash());
-    ASSERT_EQ(0x148a66beu, ImmutableString("textureLod(0S2B0B").mangledNameHash());
     ASSERT_EQ(0x14882ba7u, ImmutableString("textureLod(0X2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e61e49du, ImmutableString("texture(0Z2B").mangledNameHash());
-    ASSERT_EQ(0x0e660d38u, ImmutableString("texture(0a3B").mangledNameHash());
-    ASSERT_EQ(0x0e644545u, ImmutableString("texture(0b3B").mangledNameHash());
-    ASSERT_EQ(0x16842f7du, ImmutableString("textureProj(0Z3B").mangledNameHash());
+    ASSERT_EQ(0x148b00dbu, ImmutableString("textureLod(0J2B0B").mangledNameHash());
+    ASSERT_EQ(0x148a66beu, ImmutableString("textureLod(0S2B0B").mangledNameHash());
+    ASSERT_EQ(0x148e44d3u, ImmutableString("textureLod(0Y2B0B").mangledNameHash());
+    ASSERT_EQ(0x148ed87fu, ImmutableString("textureLod(0K2B0B").mangledNameHash());
+    ASSERT_EQ(0x1489e510u, ImmutableString("textureLod(0T2B0B").mangledNameHash());
     ASSERT_EQ(0x148fe911u, ImmutableString("textureLod(0Z2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e600d82u, ImmutableString("texture(0c2B").mangledNameHash());
+    ASSERT_EQ(0x0e67665bu, ImmutableString("texture(0d3B").mangledNameHash());
+    ASSERT_EQ(0x0e6044aeu, ImmutableString("texture(0e3B").mangledNameHash());
+    ASSERT_EQ(0x16875a59u, ImmutableString("textureProj(0c3B").mangledNameHash());
+    ASSERT_EQ(0x148a95e7u, ImmutableString("textureLod(0c2B0B").mangledNameHash());
     ASSERT_EQ(0x168434eeu, ImmutableString("textureSize(0H0C").mangledNameHash());
-    ASSERT_EQ(0x16866f5du, ImmutableString("textureSize(0P0C").mangledNameHash());
-    ASSERT_EQ(0x1680a979u, ImmutableString("textureSize(0U0C").mangledNameHash());
-    ASSERT_EQ(0x16803d05u, ImmutableString("textureSize(0I0C").mangledNameHash());
     ASSERT_EQ(0x16869d00u, ImmutableString("textureSize(0Q0C").mangledNameHash());
-    ASSERT_EQ(0x168255e2u, ImmutableString("textureSize(0V0C").mangledNameHash());
-    ASSERT_EQ(0x1681f153u, ImmutableString("textureSize(0J0C").mangledNameHash());
-    ASSERT_EQ(0x16863c73u, ImmutableString("textureSize(0R0C").mangledNameHash());
     ASSERT_EQ(0x16846c6cu, ImmutableString("textureSize(0W0C").mangledNameHash());
-    ASSERT_EQ(0x16861104u, ImmutableString("textureSize(0K0C").mangledNameHash());
-    ASSERT_EQ(0x168245a4u, ImmutableString("textureSize(0S0C").mangledNameHash());
+    ASSERT_EQ(0x16803d05u, ImmutableString("textureSize(0I0C").mangledNameHash());
+    ASSERT_EQ(0x16863c73u, ImmutableString("textureSize(0R0C").mangledNameHash());
     ASSERT_EQ(0x1686a82au, ImmutableString("textureSize(0X0C").mangledNameHash());
+    ASSERT_EQ(0x1681f153u, ImmutableString("textureSize(0J0C").mangledNameHash());
+    ASSERT_EQ(0x168245a4u, ImmutableString("textureSize(0S0C").mangledNameHash());
+    ASSERT_EQ(0x1682d660u, ImmutableString("textureSize(0Y0C").mangledNameHash());
+    ASSERT_EQ(0x16861104u, ImmutableString("textureSize(0K0C").mangledNameHash());
+    ASSERT_EQ(0x168093aau, ImmutableString("textureSize(0T0C").mangledNameHash());
     ASSERT_EQ(0x16849618u, ImmutableString("textureSize(0Z0C").mangledNameHash());
-    ASSERT_EQ(0x1686d6ddu, ImmutableString("textureSize(0a0C").mangledNameHash());
-    ASSERT_EQ(0x16829c77u, ImmutableString("textureSize(0b0C").mangledNameHash());
-    ASSERT_EQ(0x1673f496u, ImmutableString("textureSize(0O").mangledNameHash());
-    ASSERT_EQ(0x1673936bu, ImmutableString("textureSize(0T").mangledNameHash());
-    ASSERT_EQ(0x1673728cu, ImmutableString("textureSize(0Y").mangledNameHash());
+    ASSERT_EQ(0x1686aa87u, ImmutableString("textureSize(0c0C").mangledNameHash());
+    ASSERT_EQ(0x1684f1b3u, ImmutableString("textureSize(0d0C").mangledNameHash());
+    ASSERT_EQ(0x168115fbu, ImmutableString("textureSize(0e0C").mangledNameHash());
     ASSERT_EQ(0x1caa108bu, ImmutableString("textureProjLod(0H2B0B").mangledNameHash());
-    ASSERT_EQ(0x1ca8adb6u, ImmutableString("textureProjLod(0P2B0B").mangledNameHash());
-    ASSERT_EQ(0x1cabc05fu, ImmutableString("textureProjLod(0U2B0B").mangledNameHash());
+    ASSERT_EQ(0x1caa957cu, ImmutableString("textureProjLod(0Q2B0B").mangledNameHash());
+    ASSERT_EQ(0x1ca9ff27u, ImmutableString("textureProjLod(0W2B0B").mangledNameHash());
     ASSERT_EQ(0x1ca8c89au, ImmutableString("textureProjLod(0H3B0B").mangledNameHash());
-    ASSERT_EQ(0x1cadd758u, ImmutableString("textureProjLod(0P3B0B").mangledNameHash());
-    ASSERT_EQ(0x1cab218fu, ImmutableString("textureProjLod(0U3B0B").mangledNameHash());
-    ASSERT_EQ(0x1caf96afu, ImmutableString("textureProjLod(0I3B0B").mangledNameHash());
     ASSERT_EQ(0x1ca85d55u, ImmutableString("textureProjLod(0Q3B0B").mangledNameHash());
-    ASSERT_EQ(0x1cad9ae9u, ImmutableString("textureProjLod(0V3B0B").mangledNameHash());
-    ASSERT_EQ(0x1caef3bcu, ImmutableString("textureProjLod(0Z3B0B").mangledNameHash());
+    ASSERT_EQ(0x1cab3a35u, ImmutableString("textureProjLod(0W3B0B").mangledNameHash());
+    ASSERT_EQ(0x1caf96afu, ImmutableString("textureProjLod(0I3B0B").mangledNameHash());
+    ASSERT_EQ(0x1cae6ef8u, ImmutableString("textureProjLod(0R3B0B").mangledNameHash());
+    ASSERT_EQ(0x1cadb5feu, ImmutableString("textureProjLod(0X3B0B").mangledNameHash());
+    ASSERT_EQ(0x1ca81af6u, ImmutableString("textureProjLod(0c3B0B").mangledNameHash());
     ASSERT_EQ(0x148fd5b6u, ImmutableString("texelFetch(0H1C0C").mangledNameHash());
-    ASSERT_EQ(0x14894128u, ImmutableString("texelFetch(0P1C0C").mangledNameHash());
-    ASSERT_EQ(0x148ed16fu, ImmutableString("texelFetch(0U1C0C").mangledNameHash());
+    ASSERT_EQ(0x148e5d86u, ImmutableString("texelFetch(0Q1C0C").mangledNameHash());
+    ASSERT_EQ(0x148e6d96u, ImmutableString("texelFetch(0W1C0C").mangledNameHash());
     ASSERT_EQ(0x148bab65u, ImmutableString("texelFetch(0I2C0C").mangledNameHash());
-    ASSERT_EQ(0x1488b1e8u, ImmutableString("texelFetch(0Q2C0C").mangledNameHash());
-    ASSERT_EQ(0x14880e11u, ImmutableString("texelFetch(0V2C0C").mangledNameHash());
-    ASSERT_EQ(0x148d0a7bu, ImmutableString("texelFetch(0K2C0C").mangledNameHash());
-    ASSERT_EQ(0x148a2382u, ImmutableString("texelFetch(0S2C0C").mangledNameHash());
+    ASSERT_EQ(0x14885983u, ImmutableString("texelFetch(0R2C0C").mangledNameHash());
     ASSERT_EQ(0x148e100eu, ImmutableString("texelFetch(0X2C0C").mangledNameHash());
+    ASSERT_EQ(0x148d0a7bu, ImmutableString("texelFetch(0K2C0C").mangledNameHash());
+    ASSERT_EQ(0x148fb13cu, ImmutableString("texelFetch(0T2C0C").mangledNameHash());
+    ASSERT_EQ(0x14885e67u, ImmutableString("texelFetch(0Z2C0C").mangledNameHash());
     ASSERT_EQ(0x16a19c8du, ImmutableString("textureGrad(0H1B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a47be7u, ImmutableString("textureGrad(0P1B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a735dau, ImmutableString("textureGrad(0U1B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a2ff3du, ImmutableString("textureGrad(0Q1B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a4a66cu, ImmutableString("textureGrad(0W1B1B1B").mangledNameHash());
     ASSERT_EQ(0x16a00e04u, ImmutableString("textureGrad(0I2B2B2B").mangledNameHash());
-    ASSERT_EQ(0x16a19158u, ImmutableString("textureGrad(0Q2B2B2B").mangledNameHash());
-    ASSERT_EQ(0x16a7e88eu, ImmutableString("textureGrad(0V2B2B2B").mangledNameHash());
-    ASSERT_EQ(0x16a1ec87u, ImmutableString("textureGrad(0J2B2B2B").mangledNameHash());
     ASSERT_EQ(0x16a34692u, ImmutableString("textureGrad(0R2B2B2B").mangledNameHash());
-    ASSERT_EQ(0x16a11436u, ImmutableString("textureGrad(0W2B2B2B").mangledNameHash());
-    ASSERT_EQ(0x16a6a742u, ImmutableString("textureGrad(0Z2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a149ecu, ImmutableString("textureGrad(0a3B2B2B").mangledNameHash());
+    ASSERT_EQ(0x16a04ad9u, ImmutableString("textureGrad(0X2B2B2B").mangledNameHash());
+    ASSERT_EQ(0x16a1ec87u, ImmutableString("textureGrad(0J2B2B2B").mangledNameHash());
+    ASSERT_EQ(0x16a68a81u, ImmutableString("textureGrad(0S2B2B2B").mangledNameHash());
+    ASSERT_EQ(0x16a3b8f6u, ImmutableString("textureGrad(0Y2B2B2B").mangledNameHash());
+    ASSERT_EQ(0x16a3a842u, ImmutableString("textureGrad(0c2B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a4e27cu, ImmutableString("textureGrad(0d3B2B2B").mangledNameHash());
     ASSERT_EQ(0x16a71104u, ImmutableString("textureGrad(0K2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a57654u, ImmutableString("textureGrad(0S2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a22779u, ImmutableString("textureGrad(0X2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x16a53465u, ImmutableString("textureGrad(0b3B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a66883u, ImmutableString("textureGrad(0T2B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a6a742u, ImmutableString("textureGrad(0Z2B1B1B").mangledNameHash());
+    ASSERT_EQ(0x16a1478fu, ImmutableString("textureGrad(0e3B1B1B").mangledNameHash());
     ASSERT_EQ(0x1ec5ab9du, ImmutableString("textureProjGrad(0H2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x1ec374bcu, ImmutableString("textureProjGrad(0P2B1B1B").mangledNameHash());
-    ASSERT_EQ(0x1ec71f74u, ImmutableString("textureProjGrad(0U2B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1ec1a98bu, ImmutableString("textureProjGrad(0Q2B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1ec25826u, ImmutableString("textureProjGrad(0W2B1B1B").mangledNameHash());
     ASSERT_EQ(0x1ec323fdu, ImmutableString("textureProjGrad(0H3B1B1B").mangledNameHash());
-    ASSERT_EQ(0x1ec50275u, ImmutableString("textureProjGrad(0P3B1B1B").mangledNameHash());
-    ASSERT_EQ(0x1ec4aa1fu, ImmutableString("textureProjGrad(0U3B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1ec5fc9fu, ImmutableString("textureProjGrad(0Q3B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1ec67b05u, ImmutableString("textureProjGrad(0W3B1B1B").mangledNameHash());
     ASSERT_EQ(0x1ec3ee61u, ImmutableString("textureProjGrad(0I3B2B2B").mangledNameHash());
-    ASSERT_EQ(0x1ec1ecc3u, ImmutableString("textureProjGrad(0Q3B2B2B").mangledNameHash());
-    ASSERT_EQ(0x1ec19613u, ImmutableString("textureProjGrad(0V3B2B2B").mangledNameHash());
-    ASSERT_EQ(0x1ec64714u, ImmutableString("textureProjGrad(0Z3B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1ec578cfu, ImmutableString("textureProjGrad(0R3B2B2B").mangledNameHash());
+    ASSERT_EQ(0x1ec2304bu, ImmutableString("textureProjGrad(0X3B2B2B").mangledNameHash());
+    ASSERT_EQ(0x1ec719d1u, ImmutableString("textureProjGrad(0c3B1B1B").mangledNameHash());
+    ASSERT_EQ(0x1673f496u, ImmutableString("textureSize(0O").mangledNameHash());
+    ASSERT_EQ(0x167394d8u, ImmutableString("textureSize(0U").mangledNameHash());
+    ASSERT_EQ(0x16752ab6u, ImmutableString("textureSize(0a").mangledNameHash());
+    ASSERT_EQ(0x1673b4b7u, ImmutableString("textureSize(0P").mangledNameHash());
+    ASSERT_EQ(0x1673a791u, ImmutableString("textureSize(0V").mangledNameHash());
+    ASSERT_EQ(0x1675566fu, ImmutableString("textureSize(0b").mangledNameHash());
     ASSERT_EQ(0x1aa11785u, ImmutableString("textureOffset(0H1B1C").mangledNameHash());
-    ASSERT_EQ(0x1aa0931au, ImmutableString("textureOffset(0P1B1C").mangledNameHash());
-    ASSERT_EQ(0x1aa1c620u, ImmutableString("textureOffset(0U1B1C").mangledNameHash());
+    ASSERT_EQ(0x1aa01270u, ImmutableString("textureOffset(0Q1B1C").mangledNameHash());
+    ASSERT_EQ(0x1aa541b7u, ImmutableString("textureOffset(0W1B1C").mangledNameHash());
     ASSERT_EQ(0x1aa64995u, ImmutableString("textureOffset(0I2B2C").mangledNameHash());
-    ASSERT_EQ(0x1aa3c02eu, ImmutableString("textureOffset(0Q2B2C").mangledNameHash());
-    ASSERT_EQ(0x1aa08a7au, ImmutableString("textureOffset(0V2B2C").mangledNameHash());
-    ASSERT_EQ(0x1aa385c2u, ImmutableString("textureOffset(0Z2B1C").mangledNameHash());
+    ASSERT_EQ(0x1aa7a781u, ImmutableString("textureOffset(0R2B2C").mangledNameHash());
+    ASSERT_EQ(0x1aa31637u, ImmutableString("textureOffset(0X2B2C").mangledNameHash());
+    ASSERT_EQ(0x1aa05156u, ImmutableString("textureOffset(0c2B1C").mangledNameHash());
     ASSERT_EQ(0x1aa41f4au, ImmutableString("textureOffset(0K2B1C").mangledNameHash());
-    ASSERT_EQ(0x1aa2cd54u, ImmutableString("textureOffset(0S2B1C").mangledNameHash());
-    ASSERT_EQ(0x1aa39cdeu, ImmutableString("textureOffset(0X2B1C").mangledNameHash());
+    ASSERT_EQ(0x1aa26095u, ImmutableString("textureOffset(0T2B1C").mangledNameHash());
+    ASSERT_EQ(0x1aa385c2u, ImmutableString("textureOffset(0Z2B1C").mangledNameHash());
     ASSERT_EQ(0x22c0a359u, ImmutableString("textureProjOffset(0H2B1C").mangledNameHash());
-    ASSERT_EQ(0x22c4cdaau, ImmutableString("textureProjOffset(0P2B1C").mangledNameHash());
-    ASSERT_EQ(0x22c02df1u, ImmutableString("textureProjOffset(0U2B1C").mangledNameHash());
+    ASSERT_EQ(0x22c29005u, ImmutableString("textureProjOffset(0Q2B1C").mangledNameHash());
+    ASSERT_EQ(0x22c03489u, ImmutableString("textureProjOffset(0W2B1C").mangledNameHash());
     ASSERT_EQ(0x22c2da46u, ImmutableString("textureProjOffset(0H3B1C").mangledNameHash());
-    ASSERT_EQ(0x22c6f82eu, ImmutableString("textureProjOffset(0P3B1C").mangledNameHash());
-    ASSERT_EQ(0x22c0015bu, ImmutableString("textureProjOffset(0U3B1C").mangledNameHash());
+    ASSERT_EQ(0x22c246a2u, ImmutableString("textureProjOffset(0Q3B1C").mangledNameHash());
+    ASSERT_EQ(0x22c3e359u, ImmutableString("textureProjOffset(0W3B1C").mangledNameHash());
     ASSERT_EQ(0x22c458dcu, ImmutableString("textureProjOffset(0I3B2C").mangledNameHash());
-    ASSERT_EQ(0x22c2db53u, ImmutableString("textureProjOffset(0Q3B2C").mangledNameHash());
-    ASSERT_EQ(0x22c528fau, ImmutableString("textureProjOffset(0V3B2C").mangledNameHash());
-    ASSERT_EQ(0x22c5ec11u, ImmutableString("textureProjOffset(0Z3B1C").mangledNameHash());
+    ASSERT_EQ(0x22c43880u, ImmutableString("textureProjOffset(0R3B2C").mangledNameHash());
+    ASSERT_EQ(0x22c47909u, ImmutableString("textureProjOffset(0X3B2C").mangledNameHash());
+    ASSERT_EQ(0x22c19992u, ImmutableString("textureProjOffset(0c3B1C").mangledNameHash());
     ASSERT_EQ(0x20cc9477u, ImmutableString("textureLodOffset(0H1B0B1C").mangledNameHash());
-    ASSERT_EQ(0x20cbd512u, ImmutableString("textureLodOffset(0P1B0B1C").mangledNameHash());
-    ASSERT_EQ(0x20cfb2d5u, ImmutableString("textureLodOffset(0U1B0B1C").mangledNameHash());
+    ASSERT_EQ(0x20ccf3edu, ImmutableString("textureLodOffset(0Q1B0B1C").mangledNameHash());
+    ASSERT_EQ(0x20cdc61au, ImmutableString("textureLodOffset(0W1B0B1C").mangledNameHash());
     ASSERT_EQ(0x20cde748u, ImmutableString("textureLodOffset(0I2B0B2C").mangledNameHash());
-    ASSERT_EQ(0x20cc8384u, ImmutableString("textureLodOffset(0Q2B0B2C").mangledNameHash());
-    ASSERT_EQ(0x20ca735fu, ImmutableString("textureLodOffset(0V2B0B2C").mangledNameHash());
-    ASSERT_EQ(0x20ca4914u, ImmutableString("textureLodOffset(0Z2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x20ceb3dau, ImmutableString("textureLodOffset(0R2B0B2C").mangledNameHash());
+    ASSERT_EQ(0x20cde370u, ImmutableString("textureLodOffset(0X2B0B2C").mangledNameHash());
+    ASSERT_EQ(0x20c9733bu, ImmutableString("textureLodOffset(0c2B0B1C").mangledNameHash());
     ASSERT_EQ(0x20cd0de3u, ImmutableString("textureLodOffset(0K2B0B1C").mangledNameHash());
-    ASSERT_EQ(0x20caddbdu, ImmutableString("textureLodOffset(0S2B0B1C").mangledNameHash());
-    ASSERT_EQ(0x20c97fcau, ImmutableString("textureLodOffset(0X2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x20cd8d8du, ImmutableString("textureLodOffset(0T2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x20ca4914u, ImmutableString("textureLodOffset(0Z2B0B1C").mangledNameHash());
     ASSERT_EQ(0x28eab462u, ImmutableString("textureProjLodOffset(0H2B0B1C").mangledNameHash());
-    ASSERT_EQ(0x28eeff16u, ImmutableString("textureProjLodOffset(0P2B0B1C").mangledNameHash());
-    ASSERT_EQ(0x28ef67d8u, ImmutableString("textureProjLodOffset(0U2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x28ef956cu, ImmutableString("textureProjLodOffset(0Q2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x28e9a246u, ImmutableString("textureProjLodOffset(0W2B0B1C").mangledNameHash());
     ASSERT_EQ(0x28ebf99eu, ImmutableString("textureProjLodOffset(0H3B0B1C").mangledNameHash());
-    ASSERT_EQ(0x28ed5e33u, ImmutableString("textureProjLodOffset(0P3B0B1C").mangledNameHash());
-    ASSERT_EQ(0x28efc97eu, ImmutableString("textureProjLodOffset(0U3B0B1C").mangledNameHash());
+    ASSERT_EQ(0x28ec29a7u, ImmutableString("textureProjLodOffset(0Q3B0B1C").mangledNameHash());
+    ASSERT_EQ(0x28e8b7d0u, ImmutableString("textureProjLodOffset(0W3B0B1C").mangledNameHash());
     ASSERT_EQ(0x28eb8605u, ImmutableString("textureProjLodOffset(0I3B0B2C").mangledNameHash());
-    ASSERT_EQ(0x28eaec64u, ImmutableString("textureProjLodOffset(0Q3B0B2C").mangledNameHash());
-    ASSERT_EQ(0x28eb831cu, ImmutableString("textureProjLodOffset(0V3B0B2C").mangledNameHash());
-    ASSERT_EQ(0x28e8c0c1u, ImmutableString("textureProjLodOffset(0Z3B0B1C").mangledNameHash());
+    ASSERT_EQ(0x28e91d51u, ImmutableString("textureProjLodOffset(0R3B0B2C").mangledNameHash());
+    ASSERT_EQ(0x28eecd92u, ImmutableString("textureProjLodOffset(0X3B0B2C").mangledNameHash());
+    ASSERT_EQ(0x28efb13bu, ImmutableString("textureProjLodOffset(0c3B0B1C").mangledNameHash());
     ASSERT_EQ(0x20cb3102u, ImmutableString("texelFetchOffset(0H1C0C1C").mangledNameHash());
-    ASSERT_EQ(0x20c9c544u, ImmutableString("texelFetchOffset(0P1C0C1C").mangledNameHash());
-    ASSERT_EQ(0x20cc7638u, ImmutableString("texelFetchOffset(0U1C0C1C").mangledNameHash());
+    ASSERT_EQ(0x20cc1a52u, ImmutableString("texelFetchOffset(0Q1C0C1C").mangledNameHash());
+    ASSERT_EQ(0x20cbf8d9u, ImmutableString("texelFetchOffset(0W1C0C1C").mangledNameHash());
     ASSERT_EQ(0x20c8fa96u, ImmutableString("texelFetchOffset(0I2C0C2C").mangledNameHash());
-    ASSERT_EQ(0x20cd911au, ImmutableString("texelFetchOffset(0Q2C0C2C").mangledNameHash());
-    ASSERT_EQ(0x20ce3ec5u, ImmutableString("texelFetchOffset(0V2C0C2C").mangledNameHash());
+    ASSERT_EQ(0x20cbfefau, ImmutableString("texelFetchOffset(0R2C0C2C").mangledNameHash());
+    ASSERT_EQ(0x20c9a178u, ImmutableString("texelFetchOffset(0X2C0C2C").mangledNameHash());
     ASSERT_EQ(0x20cac068u, ImmutableString("texelFetchOffset(0K2C0C1C").mangledNameHash());
-    ASSERT_EQ(0x20c91b7du, ImmutableString("texelFetchOffset(0S2C0C1C").mangledNameHash());
-    ASSERT_EQ(0x20c863e3u, ImmutableString("texelFetchOffset(0X2C0C1C").mangledNameHash());
+    ASSERT_EQ(0x20cfe609u, ImmutableString("texelFetchOffset(0T2C0C1C").mangledNameHash());
+    ASSERT_EQ(0x20cb952du, ImmutableString("texelFetchOffset(0Z2C0C1C").mangledNameHash());
     ASSERT_EQ(0x22e71012u, ImmutableString("textureGradOffset(0H1B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x22e735f5u, ImmutableString("textureGradOffset(0P1B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x22e059fdu, ImmutableString("textureGradOffset(0U1B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e5c876u, ImmutableString("textureGradOffset(0Q1B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e0fe8cu, ImmutableString("textureGradOffset(0W1B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x22e3e9eau, ImmutableString("textureGradOffset(0I2B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x22e57332u, ImmutableString("textureGradOffset(0Q2B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x22e62421u, ImmutableString("textureGradOffset(0V2B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x22e68293u, ImmutableString("textureGradOffset(0Z2B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e5bb38u, ImmutableString("textureGradOffset(0R2B2B2B2C").mangledNameHash());
+    ASSERT_EQ(0x22e61729u, ImmutableString("textureGradOffset(0X2B2B2B2C").mangledNameHash());
+    ASSERT_EQ(0x22e7429eu, ImmutableString("textureGradOffset(0c2B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x22e165b8u, ImmutableString("textureGradOffset(0K2B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x22e54911u, ImmutableString("textureGradOffset(0S2B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x22e23b04u, ImmutableString("textureGradOffset(0X2B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x22e2defdu, ImmutableString("textureGradOffset(0b3B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e28d80u, ImmutableString("textureGradOffset(0T2B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e68293u, ImmutableString("textureGradOffset(0Z2B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x22e3ab1cu, ImmutableString("textureGradOffset(0e3B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x2b077535u, ImmutableString("textureProjGradOffset(0H2B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x2b02308fu, ImmutableString("textureProjGradOffset(0P2B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x2b04ab94u, ImmutableString("textureProjGradOffset(0U2B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x2b03ccf9u, ImmutableString("textureProjGradOffset(0Q2B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x2b03db51u, ImmutableString("textureProjGradOffset(0W2B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x2b022418u, ImmutableString("textureProjGradOffset(0H3B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x2b06523eu, ImmutableString("textureProjGradOffset(0P3B1B1B1C").mangledNameHash());
-    ASSERT_EQ(0x2b00a086u, ImmutableString("textureProjGradOffset(0U3B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x2b06f874u, ImmutableString("textureProjGradOffset(0Q3B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x2b07f768u, ImmutableString("textureProjGradOffset(0W3B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x2b02af8fu, ImmutableString("textureProjGradOffset(0I3B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x2b045d17u, ImmutableString("textureProjGradOffset(0Q3B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x2b00d555u, ImmutableString("textureProjGradOffset(0V3B2B2B2C").mangledNameHash());
-    ASSERT_EQ(0x2b0472aau, ImmutableString("textureProjGradOffset(0Z3B1B1B1C").mangledNameHash());
+    ASSERT_EQ(0x2b047dfau, ImmutableString("textureProjGradOffset(0R3B2B2B2C").mangledNameHash());
+    ASSERT_EQ(0x2b0252ccu, ImmutableString("textureProjGradOffset(0X3B2B2B2C").mangledNameHash());
+    ASSERT_EQ(0x2b00aacdu, ImmutableString("textureProjGradOffset(0c3B1B1B1C").mangledNameHash());
     ASSERT_EQ(0x1ab57bbcu, ImmutableString("textureOffset(0H1B1C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab6ec2cu, ImmutableString("textureOffset(0P1B1C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab2a609u, ImmutableString("textureOffset(0U1B1C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab55c9du, ImmutableString("textureOffset(0Q1B1C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab5d795u, ImmutableString("textureOffset(0W1B1C0B").mangledNameHash());
     ASSERT_EQ(0x1ab59b6cu, ImmutableString("textureOffset(0I2B2C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab09555u, ImmutableString("textureOffset(0Q2B2C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab0d39du, ImmutableString("textureOffset(0V2B2C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab29724u, ImmutableString("textureOffset(0Z2B1C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab63f72u, ImmutableString("textureOffset(0R2B2C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab0a952u, ImmutableString("textureOffset(0X2B2C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab7e533u, ImmutableString("textureOffset(0c2B1C0B").mangledNameHash());
     ASSERT_EQ(0x1ab63ddau, ImmutableString("textureOffset(0K2B1C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab6f64bu, ImmutableString("textureOffset(0S2B1C0B").mangledNameHash());
-    ASSERT_EQ(0x1ab1990bu, ImmutableString("textureOffset(0X2B1C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab5753fu, ImmutableString("textureOffset(0T2B1C0B").mangledNameHash());
+    ASSERT_EQ(0x1ab29724u, ImmutableString("textureOffset(0Z2B1C0B").mangledNameHash());
     ASSERT_EQ(0x22d6ee53u, ImmutableString("textureProjOffset(0H2B1C0B").mangledNameHash());
-    ASSERT_EQ(0x22d76183u, ImmutableString("textureProjOffset(0P2B1C0B").mangledNameHash());
-    ASSERT_EQ(0x22d65c37u, ImmutableString("textureProjOffset(0U2B1C0B").mangledNameHash());
+    ASSERT_EQ(0x22d60e91u, ImmutableString("textureProjOffset(0Q2B1C0B").mangledNameHash());
+    ASSERT_EQ(0x22d1425bu, ImmutableString("textureProjOffset(0W2B1C0B").mangledNameHash());
     ASSERT_EQ(0x22d62e81u, ImmutableString("textureProjOffset(0H3B1C0B").mangledNameHash());
-    ASSERT_EQ(0x22d3c514u, ImmutableString("textureProjOffset(0P3B1C0B").mangledNameHash());
-    ASSERT_EQ(0x22d2de73u, ImmutableString("textureProjOffset(0U3B1C0B").mangledNameHash());
+    ASSERT_EQ(0x22d11d67u, ImmutableString("textureProjOffset(0Q3B1C0B").mangledNameHash());
+    ASSERT_EQ(0x22d17100u, ImmutableString("textureProjOffset(0W3B1C0B").mangledNameHash());
     ASSERT_EQ(0x22d6b2e8u, ImmutableString("textureProjOffset(0I3B2C0B").mangledNameHash());
-    ASSERT_EQ(0x22d3ece3u, ImmutableString("textureProjOffset(0Q3B2C0B").mangledNameHash());
-    ASSERT_EQ(0x22d09aefu, ImmutableString("textureProjOffset(0V3B2C0B").mangledNameHash());
-    ASSERT_EQ(0x22d59e0cu, ImmutableString("textureProjOffset(0Z3B1C0B").mangledNameHash());
+    ASSERT_EQ(0x22d6074cu, ImmutableString("textureProjOffset(0R3B2C0B").mangledNameHash());
+    ASSERT_EQ(0x22d60cd3u, ImmutableString("textureProjOffset(0X3B2C0B").mangledNameHash());
+    ASSERT_EQ(0x22d1ca54u, ImmutableString("textureProjOffset(0c3B1C0B").mangledNameHash());
     ASSERT_EQ(0x0e661665u, ImmutableString("texture(0L1B").mangledNameHash());
     ASSERT_EQ(0x16838d15u, ImmutableString("textureProj(0L2B").mangledNameHash());
     ASSERT_EQ(0x16865716u, ImmutableString("textureProj(0L3B").mangledNameHash());
@@ -725,29 +728,29 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x168046b0u, ImmutableString("textureSize(0M0C").mangledNameHash());
     ASSERT_EQ(0x148a14a7u, ImmutableString("texelFetch(0M1C0C").mangledNameHash());
     ASSERT_EQ(0x0e76e7c1u, ImmutableString("texture(0H1B0B").mangledNameHash());
-    ASSERT_EQ(0x0e71dca8u, ImmutableString("texture(0P1B0B").mangledNameHash());
-    ASSERT_EQ(0x0e70395au, ImmutableString("texture(0U1B0B").mangledNameHash());
+    ASSERT_EQ(0x0e7386b0u, ImmutableString("texture(0Q1B0B").mangledNameHash());
+    ASSERT_EQ(0x0e70d11du, ImmutableString("texture(0W1B0B").mangledNameHash());
     ASSERT_EQ(0x0e77d1c8u, ImmutableString("texture(0I2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e737f67u, ImmutableString("texture(0Q2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e720b77u, ImmutableString("texture(0V2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e75d15fu, ImmutableString("texture(0J2B0B").mangledNameHash());
     ASSERT_EQ(0x0e7720c0u, ImmutableString("texture(0R2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e73f4c3u, ImmutableString("texture(0W2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e742a66u, ImmutableString("texture(0K2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e75399eu, ImmutableString("texture(0S2B0B").mangledNameHash());
     ASSERT_EQ(0x0e70eff9u, ImmutableString("texture(0X2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e75d15fu, ImmutableString("texture(0J2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e75399eu, ImmutableString("texture(0S2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e755c73u, ImmutableString("texture(0Y2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e742a66u, ImmutableString("texture(0K2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e7013d9u, ImmutableString("texture(0T2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e734ff8u, ImmutableString("texture(0Z2B0B").mangledNameHash());
     ASSERT_EQ(0x1696f029u, ImmutableString("textureProj(0H2B0B").mangledNameHash());
-    ASSERT_EQ(0x16955fbdu, ImmutableString("textureProj(0P2B0B").mangledNameHash());
-    ASSERT_EQ(0x1691d656u, ImmutableString("textureProj(0U2B0B").mangledNameHash());
+    ASSERT_EQ(0x16939955u, ImmutableString("textureProj(0Q2B0B").mangledNameHash());
+    ASSERT_EQ(0x169465e2u, ImmutableString("textureProj(0W2B0B").mangledNameHash());
     ASSERT_EQ(0x16965fd9u, ImmutableString("textureProj(0H3B0B").mangledNameHash());
-    ASSERT_EQ(0x16911478u, ImmutableString("textureProj(0P3B0B").mangledNameHash());
-    ASSERT_EQ(0x169292f8u, ImmutableString("textureProj(0U3B0B").mangledNameHash());
-    ASSERT_EQ(0x169350d8u, ImmutableString("textureProj(0I3B0B").mangledNameHash());
     ASSERT_EQ(0x16925badu, ImmutableString("textureProj(0Q3B0B").mangledNameHash());
-    ASSERT_EQ(0x1695499au, ImmutableString("textureProj(0V3B0B").mangledNameHash());
-    ASSERT_EQ(0x0e734ff8u, ImmutableString("texture(0Z2B0B").mangledNameHash());
-    ASSERT_EQ(0x0e77a0f1u, ImmutableString("texture(0a3B0B").mangledNameHash());
-    ASSERT_EQ(0x16910ba7u, ImmutableString("textureProj(0Z3B0B").mangledNameHash());
+    ASSERT_EQ(0x1690a3cfu, ImmutableString("textureProj(0W3B0B").mangledNameHash());
+    ASSERT_EQ(0x169350d8u, ImmutableString("textureProj(0I3B0B").mangledNameHash());
+    ASSERT_EQ(0x1694622au, ImmutableString("textureProj(0R3B0B").mangledNameHash());
+    ASSERT_EQ(0x1695f573u, ImmutableString("textureProj(0X3B0B").mangledNameHash());
+    ASSERT_EQ(0x0e716d8fu, ImmutableString("texture(0c2B0B").mangledNameHash());
+    ASSERT_EQ(0x0e740087u, ImmutableString("texture(0d3B0B").mangledNameHash());
+    ASSERT_EQ(0x1692d089u, ImmutableString("textureProj(0c3B0B").mangledNameHash());
     ASSERT_EQ(0x0e723219u, ImmutableString("texture(0L1B0B").mangledNameHash());
     ASSERT_EQ(0x1697e9b9u, ImmutableString("textureProj(0L2B0B").mangledNameHash());
     ASSERT_EQ(0x16900558u, ImmutableString("textureProj(0L3B0B").mangledNameHash());
@@ -755,46 +758,49 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x1691c2edu, ImmutableString("textureProj(0M2B0B").mangledNameHash());
     ASSERT_EQ(0x1690ae9fu, ImmutableString("textureProj(0M3B0B").mangledNameHash());
     ASSERT_EQ(0x14896e41u, ImmutableString("texelFetch(0O1C0C").mangledNameHash());
-    ASSERT_EQ(0x148c1ac9u, ImmutableString("texelFetch(0T1C0C").mangledNameHash());
-    ASSERT_EQ(0x148dd2bdu, ImmutableString("texelFetch(0Y1C0C").mangledNameHash());
+    ASSERT_EQ(0x148ed16fu, ImmutableString("texelFetch(0U1C0C").mangledNameHash());
+    ASSERT_EQ(0x148ddb10u, ImmutableString("texelFetch(0a1C0C").mangledNameHash());
+    ASSERT_EQ(0x148e872bu, ImmutableString("texelFetch(0P2C0C").mangledNameHash());
+    ASSERT_EQ(0x14880e11u, ImmutableString("texelFetch(0V2C0C").mangledNameHash());
+    ASSERT_EQ(0x1489244fu, ImmutableString("texelFetch(0b2C0C").mangledNameHash());
     ASSERT_EQ(0x1a92a1ceu, ImmutableString("textureGather(0H1B").mangledNameHash());
-    ASSERT_EQ(0x1a907855u, ImmutableString("textureGather(0P1B").mangledNameHash());
-    ASSERT_EQ(0x1a90d2c2u, ImmutableString("textureGather(0U1B").mangledNameHash());
+    ASSERT_EQ(0x1a92c882u, ImmutableString("textureGather(0Q1B").mangledNameHash());
+    ASSERT_EQ(0x1a92a168u, ImmutableString("textureGather(0W1B").mangledNameHash());
     ASSERT_EQ(0x1aa4c59du, ImmutableString("textureGather(0H1B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa086cfu, ImmutableString("textureGather(0P1B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa023e1u, ImmutableString("textureGather(0U1B0C").mangledNameHash());
+    ASSERT_EQ(0x1aa133bcu, ImmutableString("textureGather(0Q1B0C").mangledNameHash());
+    ASSERT_EQ(0x1aa220b0u, ImmutableString("textureGather(0W1B0C").mangledNameHash());
     ASSERT_EQ(0x1a94543du, ImmutableString("textureGather(0K2B").mangledNameHash());
-    ASSERT_EQ(0x1a9418e8u, ImmutableString("textureGather(0S2B").mangledNameHash());
-    ASSERT_EQ(0x1a93b6c9u, ImmutableString("textureGather(0X2B").mangledNameHash());
+    ASSERT_EQ(0x1a95f707u, ImmutableString("textureGather(0T2B").mangledNameHash());
+    ASSERT_EQ(0x1a94eb48u, ImmutableString("textureGather(0Z2B").mangledNameHash());
     ASSERT_EQ(0x1aa78b86u, ImmutableString("textureGather(0K2B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa3ef46u, ImmutableString("textureGather(0S2B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa1bc4cu, ImmutableString("textureGather(0X2B0C").mangledNameHash());
+    ASSERT_EQ(0x1aa2aafeu, ImmutableString("textureGather(0T2B0C").mangledNameHash());
+    ASSERT_EQ(0x1aa17115u, ImmutableString("textureGather(0Z2B0C").mangledNameHash());
     ASSERT_EQ(0x1a979ae3u, ImmutableString("textureGather(0J2B").mangledNameHash());
-    ASSERT_EQ(0x1a973644u, ImmutableString("textureGather(0R2B").mangledNameHash());
-    ASSERT_EQ(0x1a93d703u, ImmutableString("textureGather(0W2B").mangledNameHash());
+    ASSERT_EQ(0x1a9418e8u, ImmutableString("textureGather(0S2B").mangledNameHash());
+    ASSERT_EQ(0x1a910beau, ImmutableString("textureGather(0Y2B").mangledNameHash());
     ASSERT_EQ(0x1aa4986bu, ImmutableString("textureGather(0J2B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa590bdu, ImmutableString("textureGather(0R2B0C").mangledNameHash());
-    ASSERT_EQ(0x1aa6c806u, ImmutableString("textureGather(0W2B0C").mangledNameHash());
-    ASSERT_EQ(0x1a960122u, ImmutableString("textureGather(0Z1B").mangledNameHash());
-    ASSERT_EQ(0x1aa5f0c6u, ImmutableString("textureGather(0Z1B0B").mangledNameHash());
-    ASSERT_EQ(0x1a96f0e7u, ImmutableString("textureGather(0b2B").mangledNameHash());
-    ASSERT_EQ(0x1aa1ab43u, ImmutableString("textureGather(0b2B0B").mangledNameHash());
-    ASSERT_EQ(0x1a92e9e5u, ImmutableString("textureGather(0a2B").mangledNameHash());
-    ASSERT_EQ(0x1aa573ecu, ImmutableString("textureGather(0a2B0B").mangledNameHash());
+    ASSERT_EQ(0x1aa3ef46u, ImmutableString("textureGather(0S2B0C").mangledNameHash());
+    ASSERT_EQ(0x1aa7fa48u, ImmutableString("textureGather(0Y2B0C").mangledNameHash());
+    ASSERT_EQ(0x1a926b0du, ImmutableString("textureGather(0c1B").mangledNameHash());
+    ASSERT_EQ(0x1aa182eeu, ImmutableString("textureGather(0c1B0B").mangledNameHash());
+    ASSERT_EQ(0x1a94d27du, ImmutableString("textureGather(0e2B").mangledNameHash());
+    ASSERT_EQ(0x1aa039c7u, ImmutableString("textureGather(0e2B0B").mangledNameHash());
+    ASSERT_EQ(0x1a91963cu, ImmutableString("textureGather(0d2B").mangledNameHash());
+    ASSERT_EQ(0x1aa353f8u, ImmutableString("textureGather(0d2B0B").mangledNameHash());
     ASSERT_EQ(0x26d71952u, ImmutableString("textureGatherOffset(0H1B1C").mangledNameHash());
-    ASSERT_EQ(0x26d1d7a3u, ImmutableString("textureGatherOffset(0P1B1C").mangledNameHash());
-    ASSERT_EQ(0x26d7dce7u, ImmutableString("textureGatherOffset(0U1B1C").mangledNameHash());
+    ASSERT_EQ(0x26d0b451u, ImmutableString("textureGatherOffset(0Q1B1C").mangledNameHash());
+    ASSERT_EQ(0x26d00e91u, ImmutableString("textureGatherOffset(0W1B1C").mangledNameHash());
     ASSERT_EQ(0x26e476d0u, ImmutableString("textureGatherOffset(0H1B1C0C").mangledNameHash());
-    ASSERT_EQ(0x26e5b6bdu, ImmutableString("textureGatherOffset(0P1B1C0C").mangledNameHash());
-    ASSERT_EQ(0x26e2cb51u, ImmutableString("textureGatherOffset(0U1B1C0C").mangledNameHash());
+    ASSERT_EQ(0x26e567feu, ImmutableString("textureGatherOffset(0Q1B1C0C").mangledNameHash());
+    ASSERT_EQ(0x26e737a0u, ImmutableString("textureGatherOffset(0W1B1C0C").mangledNameHash());
     ASSERT_EQ(0x26d1f440u, ImmutableString("textureGatherOffset(0K2B1C").mangledNameHash());
-    ASSERT_EQ(0x26d29f74u, ImmutableString("textureGatherOffset(0S2B1C").mangledNameHash());
-    ASSERT_EQ(0x26d701d7u, ImmutableString("textureGatherOffset(0X2B1C").mangledNameHash());
+    ASSERT_EQ(0x26d2d875u, ImmutableString("textureGatherOffset(0T2B1C").mangledNameHash());
+    ASSERT_EQ(0x26d0db41u, ImmutableString("textureGatherOffset(0Z2B1C").mangledNameHash());
     ASSERT_EQ(0x26e459f8u, ImmutableString("textureGatherOffset(0K2B1C0C").mangledNameHash());
-    ASSERT_EQ(0x26e015c9u, ImmutableString("textureGatherOffset(0S2B1C0C").mangledNameHash());
-    ASSERT_EQ(0x26e1df8cu, ImmutableString("textureGatherOffset(0X2B1C0C").mangledNameHash());
-    ASSERT_EQ(0x26e596a4u, ImmutableString("textureGatherOffset(0Z1B0B1C").mangledNameHash());
-    ASSERT_EQ(0x26e6991bu, ImmutableString("textureGatherOffset(0b2B0B1C").mangledNameHash());
+    ASSERT_EQ(0x26e1982cu, ImmutableString("textureGatherOffset(0T2B1C0C").mangledNameHash());
+    ASSERT_EQ(0x26e47c82u, ImmutableString("textureGatherOffset(0Z2B1C0C").mangledNameHash());
+    ASSERT_EQ(0x26e580eau, ImmutableString("textureGatherOffset(0c1B0B1C").mangledNameHash());
+    ASSERT_EQ(0x26e53ca1u, ImmutableString("textureGatherOffset(0e2B0B1C").mangledNameHash());
     ASSERT_EQ(0x1a805162u, ImmutableString("atomicCounter(0F").mangledNameHash());
     ASSERT_EQ(0x2ccf8f34u, ImmutableString("atomicCounterIncrement(0F").mangledNameHash());
     ASSERT_EQ(0x2ccfbbbeu, ImmutableString("atomicCounterDecrement(0F").mangledNameHash());
@@ -814,9 +820,6 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x1c9b5eecu, ImmutableString("atomicExchange(0C0C").mangledNameHash());
     ASSERT_EQ(0x1caa900cu, ImmutableString("atomicCompSwap(0D0D0D").mangledNameHash());
     ASSERT_EQ(0x1ca86085u, ImmutableString("atomicCompSwap(0C0C0C").mangledNameHash());
-    ASSERT_EQ(0x12659f72u, ImmutableString("imageSize(0c").mangledNameHash());
-    ASSERT_EQ(0x1265c077u, ImmutableString("imageSize(0d").mangledNameHash());
-    ASSERT_EQ(0x1265c6e0u, ImmutableString("imageSize(0e").mangledNameHash());
     ASSERT_EQ(0x1265cc8du, ImmutableString("imageSize(0f").mangledNameHash());
     ASSERT_EQ(0x1265b53eu, ImmutableString("imageSize(0g").mangledNameHash());
     ASSERT_EQ(0x1265e603u, ImmutableString("imageSize(0h").mangledNameHash());
@@ -826,30 +829,33 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x12660ccfu, ImmutableString("imageSize(0l").mangledNameHash());
     ASSERT_EQ(0x12661578u, ImmutableString("imageSize(0m").mangledNameHash());
     ASSERT_EQ(0x12661be5u, ImmutableString("imageSize(0n").mangledNameHash());
-    ASSERT_EQ(0x12737e4du, ImmutableString("imageLoad(0c1C").mangledNameHash());
-    ASSERT_EQ(0x1273b8c5u, ImmutableString("imageLoad(0d1C").mangledNameHash());
-    ASSERT_EQ(0x12754b32u, ImmutableString("imageLoad(0e1C").mangledNameHash());
-    ASSERT_EQ(0x1274d104u, ImmutableString("imageLoad(0f2C").mangledNameHash());
-    ASSERT_EQ(0x12701a06u, ImmutableString("imageLoad(0g2C").mangledNameHash());
-    ASSERT_EQ(0x1270829bu, ImmutableString("imageLoad(0h2C").mangledNameHash());
+    ASSERT_EQ(0x1265e196u, ImmutableString("imageSize(0o").mangledNameHash());
+    ASSERT_EQ(0x126520f8u, ImmutableString("imageSize(0p").mangledNameHash());
+    ASSERT_EQ(0x12653967u, ImmutableString("imageSize(0q").mangledNameHash());
+    ASSERT_EQ(0x12739c87u, ImmutableString("imageLoad(0f1C").mangledNameHash());
+    ASSERT_EQ(0x12755603u, ImmutableString("imageLoad(0g1C").mangledNameHash());
+    ASSERT_EQ(0x12700109u, ImmutableString("imageLoad(0h1C").mangledNameHash());
     ASSERT_EQ(0x127539b2u, ImmutableString("imageLoad(0i2C").mangledNameHash());
     ASSERT_EQ(0x12715f47u, ImmutableString("imageLoad(0j2C").mangledNameHash());
     ASSERT_EQ(0x127474cau, ImmutableString("imageLoad(0k2C").mangledNameHash());
     ASSERT_EQ(0x1276656cu, ImmutableString("imageLoad(0l2C").mangledNameHash());
     ASSERT_EQ(0x12731984u, ImmutableString("imageLoad(0m2C").mangledNameHash());
     ASSERT_EQ(0x12712664u, ImmutableString("imageLoad(0n2C").mangledNameHash());
-    ASSERT_EQ(0x148d6aebu, ImmutableString("imageStore(0c1C3B").mangledNameHash());
-    ASSERT_EQ(0x148aca44u, ImmutableString("imageStore(0d1C3C").mangledNameHash());
-    ASSERT_EQ(0x148f334cu, ImmutableString("imageStore(0e1C3D").mangledNameHash());
-    ASSERT_EQ(0x148c5f8bu, ImmutableString("imageStore(0f2C3B").mangledNameHash());
-    ASSERT_EQ(0x148d8868u, ImmutableString("imageStore(0g2C3C").mangledNameHash());
-    ASSERT_EQ(0x148f864bu, ImmutableString("imageStore(0h2C3D").mangledNameHash());
+    ASSERT_EQ(0x12744c0du, ImmutableString("imageLoad(0o2C").mangledNameHash());
+    ASSERT_EQ(0x1274d54bu, ImmutableString("imageLoad(0p2C").mangledNameHash());
+    ASSERT_EQ(0x12737ed6u, ImmutableString("imageLoad(0q2C").mangledNameHash());
+    ASSERT_EQ(0x148d86dcu, ImmutableString("imageStore(0f1C3B").mangledNameHash());
+    ASSERT_EQ(0x148bb1bdu, ImmutableString("imageStore(0g1C3C").mangledNameHash());
+    ASSERT_EQ(0x148ffee8u, ImmutableString("imageStore(0h1C3D").mangledNameHash());
     ASSERT_EQ(0x148fd5f1u, ImmutableString("imageStore(0i2C3B").mangledNameHash());
     ASSERT_EQ(0x148e668au, ImmutableString("imageStore(0j2C3C").mangledNameHash());
     ASSERT_EQ(0x1488078cu, ImmutableString("imageStore(0k2C3D").mangledNameHash());
     ASSERT_EQ(0x148dcfd5u, ImmutableString("imageStore(0l2C3B").mangledNameHash());
     ASSERT_EQ(0x148e37b8u, ImmutableString("imageStore(0m2C3C").mangledNameHash());
     ASSERT_EQ(0x148ed534u, ImmutableString("imageStore(0n2C3D").mangledNameHash());
+    ASSERT_EQ(0x148f7a82u, ImmutableString("imageStore(0o2C3B").mangledNameHash());
+    ASSERT_EQ(0x148a0cecu, ImmutableString("imageStore(0p2C3C").mangledNameHash());
+    ASSERT_EQ(0x148c1e41u, ImmutableString("imageStore(0q2C3D").mangledNameHash());
     ASSERT_EQ(0x1a7538dfu, ImmutableString("memoryBarrier(").mangledNameHash());
     ASSERT_EQ(0x34ded18du, ImmutableString("memoryBarrierAtomicCounter(").mangledNameHash());
     ASSERT_EQ(0x26a7e24bu, ImmutableString("memoryBarrierBuffer(").mangledNameHash());
@@ -875,6 +881,7 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x7e55de86u, ImmutableString("usubBorrow").mangledNameHash());
     ASSERT_EQ(0x7e6746f4u, ImmutableString("umulExtended").mangledNameHash());
     ASSERT_EQ(0x7e62a9a0u, ImmutableString("imulExtended").mangledNameHash());
+    ASSERT_EQ(0x7e5e217eu, ImmutableString("textureSize").mangledNameHash());
     ASSERT_EQ(0x7e5237e1u, ImmutableString("texelFetch").mangledNameHash());
     ASSERT_EQ(0x7e6d0f32u, ImmutableString("textureGather").mangledNameHash());
     ASSERT_EQ(0x7e9d8ad9u, ImmutableString("textureGatherOffset").mangledNameHash());
@@ -943,7 +950,6 @@ TEST(ImmutableStringTest, ScriptGeneratedHashesMatch)
     ASSERT_EQ(0x7e39ebd7u, ImmutableString("texture").mangledNameHash());
     ASSERT_EQ(0x7e5caafbu, ImmutableString("textureProj").mangledNameHash());
     ASSERT_EQ(0x7e501e0cu, ImmutableString("textureLod").mangledNameHash());
-    ASSERT_EQ(0x7e5e217eu, ImmutableString("textureSize").mangledNameHash());
     ASSERT_EQ(0x7e75ae2fu, ImmutableString("textureProjLod").mangledNameHash());
     ASSERT_EQ(0x7e599347u, ImmutableString("textureGrad").mangledNameHash());
     ASSERT_EQ(0x7e7bc1fdu, ImmutableString("textureProjGrad").mangledNameHash());

src/tests/compiler_tests/SamplerMultisample_test.cpp

@@ -7,9 +7,9 @@
 // Tests compiling shaders that use gsampler2DMS types
 //
 
+#include "GLSLANG/ShaderLang.h"
 #include "angle_gl.h"
 #include "gtest/gtest.h"
-#include "GLSLANG/ShaderLang.h"
 #include "tests/test_utils/ShaderCompileTreeTest.h"
 
 using namespace sh;
@@ -24,21 +24,36 @@ class SamplerMultisampleTest : public ShaderCompileTreeTest
     ShShaderSpec getShaderSpec() const override { return SH_GLES3_1_SPEC; }
 };
 
-// checks whether compiler has parsed the gsampler2DMS, texelfetch qualifiers correctly
-TEST_F(SamplerMultisampleTest, TexelFetchSampler2DMSQualifier)
+class SamplerMultisampleArrayTest : public ShaderCompileTreeTest
+{
+  public:
+    SamplerMultisampleArrayTest() {}
+
+    void initResources(ShBuiltInResources *resources) override
+    {
+        resources->ANGLE_texture_multisample_array = 1;
+    }
+
+  protected:
+    ::GLenum getShaderType() const override { return GL_FRAGMENT_SHADER; }
+    ShShaderSpec getShaderSpec() const override { return SH_GLES3_1_SPEC; }
+};
+
+// Checks whether compiler has parsed the gsampler2DMS, texelfetch correctly.
+TEST_F(SamplerMultisampleTest, TexelFetchSampler2DMS)
 {
     const std::string &shaderString =
-        "#version 310 es\n"
-        "precision highp float;\n"
-        "uniform highp sampler2DMS s;\n"
-        "uniform highp isampler2DMS is;\n"
-        "uniform highp usampler2DMS us;\n"
-        ""
-        "void main() {\n"
-        "    vec4 tex1 = texelFetch(s, ivec2(0, 0), 0);\n"
-        "    ivec4 tex2 = texelFetch(is, ivec2(0, 0), 0);\n"
-        "    uvec4 tex3 = texelFetch(us, ivec2(0, 0), 0);\n"
-        "}\n";
+        R"(#version 310 es
+        precision highp float;
+        uniform highp sampler2DMS s;
+        uniform highp isampler2DMS is;
+        uniform highp usampler2DMS us;
+
+        void main() {
+            vec4 tex1 = texelFetch(s, ivec2(0, 0), 0);
+            ivec4 tex2 = texelFetch(is, ivec2(0, 0), 0);
+            uvec4 tex3 = texelFetch(us, ivec2(0, 0), 0);
+        })";
 
     if (!compile(shaderString))
     {
@@ -46,21 +61,21 @@ TEST_F(SamplerMultisampleTest, TexelFetchSampler2DMSQualifier)
     }
 }
 
-// checks whether compiler has parsed the gsampler2DMS, texturesize qualifiers correctly
-TEST_F(SamplerMultisampleTest, TextureSizeSampler2DMSQualifier)
+// Checks whether compiler has parsed the gsampler2DMS, textureSize correctly.
+TEST_F(SamplerMultisampleTest, TextureSizeSampler2DMS)
 {
     const std::string &shaderString =
-        "#version 310 es\n"
-        "precision highp float;\n"
-        "uniform highp sampler2DMS s;\n"
-        "uniform highp isampler2DMS is;\n"
-        "uniform highp usampler2DMS us;\n"
-        ""
-        "void main() {\n"
-        "    ivec2 size = textureSize(s);\n"
-        "    size = textureSize(is);\n"
-        "    size = textureSize(us);\n"
-        "}\n";
+        R"(#version 310 es
+        precision highp float;
+        uniform highp sampler2DMS s;
+        uniform highp isampler2DMS is;
+        uniform highp usampler2DMS us;
+
+        void main() {
+            ivec2 size = textureSize(s);
+            size = textureSize(is);
+            size = textureSize(us);
+        })";
 
     if (!compile(shaderString))
     {
@@ -68,17 +83,246 @@ TEST_F(SamplerMultisampleTest, TextureSizeSampler2DMSQualifier)
     }
 }
 
-// checks gsampler2DMS has no default precision
+// Check that sampler2DMS has no default precision.
 TEST_F(SamplerMultisampleTest, NoPrecisionSampler2DMS)
 {
     const std::string &shaderString =
-        "#version 310 es\n"
-        "precision highp float;\n"
-        "uniform sampler2DMS s;\n"
-        "uniform isampler2DMS is;\n"
-        "uniform usampler2DMS us;\n"
-        ""
-        "void main() {}\n";
+        R"(#version 310 es
+        precision highp float;
+        uniform sampler2DMS s;
+
+        void main() {})";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Check that isampler2DMS has no default precision.
+TEST_F(SamplerMultisampleTest, NoPrecisionISampler2DMS)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        precision highp float;
+        uniform isampler2DMS s;
+
+        void main() {})";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Check that usampler2DMS has no default precision.
+TEST_F(SamplerMultisampleTest, NoPrecisionUSampler2DMS)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        precision highp float;
+        uniform usampler2DMS s;
+
+        void main() {})";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that sampler2DMS is not usable in ESSL 3.00.
+TEST_F(SamplerMultisampleTest, Sampler2DMSESSL300)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision highp float;
+        uniform highp sampler2DMS s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that isampler2DMS is not usable in ESSL 3.00.
+TEST_F(SamplerMultisampleTest, ISampler2DMSESSL300)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision highp float;
+        uniform highp isampler2DMS s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that usampler2DMS is not usable in ESSL 3.00.
+TEST_F(SamplerMultisampleTest, USampler2DMSESSL300)
+{
+    const std::string &shaderString =
+        R"(#version 300 es
+        precision highp float;
+        uniform highp usampler2DMS s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that sampler2DMSArray is not usable in ESSL 3.10 without extensions.
+TEST_F(SamplerMultisampleTest, Sampler2DMSArrayNotSupported)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        precision highp float;
+        uniform highp sampler2DMSArray s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that isampler2DMSArray is not usable in ESSL 3.10 without extensions.
+TEST_F(SamplerMultisampleTest, ISampler2DMSArrayNotSupported)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        precision highp float;
+        uniform highp isampler2DMSArray s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Negative test: checks that usampler2DMSArray is not usable in ESSL 3.10 without extensions.
+TEST_F(SamplerMultisampleTest, USampler2DMSArrayNotSupported)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        precision highp float;
+        uniform highp usampler2DMSArray s;
+
+        void main() {
+        })";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Checks whether compiler has parsed the gsampler2DMSArray, texelfetch correctly.
+TEST_F(SamplerMultisampleArrayTest, TexelFetchSampler2DMSArray)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        #extension GL_ANGLE_texture_multisample_array : require
+        precision highp float;
+        uniform highp sampler2DMSArray s;
+        uniform highp isampler2DMSArray is;
+        uniform highp usampler2DMSArray us;
+
+        void main() {
+            vec4 tex1 = texelFetch(s, ivec3(0, 0, 0), 0);
+            ivec4 tex2 = texelFetch(is, ivec3(0, 0, 0), 0);
+            uvec4 tex3 = texelFetch(us, ivec3(0, 0, 0), 0);
+        })";
+
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed, expecting success:\n" << mInfoLog;
+    }
+}
+
+// Checks whether compiler has parsed the gsampler2DMSArray, textureSize correctly.
+TEST_F(SamplerMultisampleArrayTest, TextureSizeSampler2DMSArray)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        #extension GL_ANGLE_texture_multisample_array : require
+        precision highp float;
+        uniform highp sampler2DMSArray s;
+        uniform highp isampler2DMSArray is;
+        uniform highp usampler2DMSArray us;
+
+        void main() {
+            ivec3 size = textureSize(s);
+            size = textureSize(is);
+            size = textureSize(us);
+        })";
+
+    if (!compile(shaderString))
+    {
+        FAIL() << "Shader compilation failed, expecting success:\n" << mInfoLog;
+    }
+}
+
+// Check that sampler2DMSArray has no default precision.
+TEST_F(SamplerMultisampleArrayTest, NoPrecisionSampler2DMSArray)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        #extension GL_ANGLE_texture_multisample_array : require
+        precision highp float;
+        uniform sampler2DMSArray s;
+
+        void main() {})";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Check that isampler2DMSArray has no default precision.
+TEST_F(SamplerMultisampleArrayTest, NoPrecisionISampler2DMSArray)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        #extension GL_ANGLE_texture_multisample_array : require
+        precision highp float;
+        uniform isampler2DMSArray s;
+
+        void main() {})";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Check that usampler2DMSArray has no default precision.
+TEST_F(SamplerMultisampleArrayTest, NoPrecisionUSampler2DMSArray)
+{
+    const std::string &shaderString =
+        R"(#version 310 es
+        #extension GL_ANGLE_texture_multisample_array : require
+        precision highp float;
+        uniform usampler2DMSArray s;
+
+        void main() {})";
 
     if (compile(shaderString))
     {